Issue #19706 has been updated by nobu (Nobuyoshi Nakada). `JSON.load(ARGF)["foo"]` is possible in all versions (1.5.5 bundled with ruby1.9, at least). ---------------------------------------- Feature #19706: Make JSON.[] support ARGF object https://bugs.ruby-lang.org/issues/19706#change-103386 * Author: tatzyr (Tatsuya Otsuka) * Status: Third Party's Issue * Priority: Normal ---------------------------------------- **Abstract** I propose to extend the `JSON.[]` method in the `json` standard library to support `ARGF` object directly. **Background** Currently, the `JSON.[]` method supports parsing from a string or generating a string from an object. However, it does not directly support `ARGF`, which is often used to handle command-line input. With this extension, `ARGF` object can be effectively used with the `JSON.[]` method to parse JSON from command-line input. **Proposal** This proposal aims to provide a more concise way to handle JSON input than the current method, `JSON.parse(ARGF.read)`. An example usage would be: `echo '{"foo": "bar"}' | ruby -rjson -e 'puts JSON[ARGF]["foo"]'`. This will enable developers to parse JSON in a similar way to how the `jq` utility works. **Implementation** Here's the proposed change to `JSON.[]`: ```diff ### ext/json/lib/json/common.rb module JSON class << self def [](object, opts = {}) if object.respond_to? :to_str JSON.parse(object.to_str, opts) + elsif object.is_a?(ARGF.class) + JSON.parse(object.read, opts) else JSON.generate(object, opts) end end end end ``` This change checks whether the given `object` is an instance of `ARGF.class` and, if so, reads from it and parses the result as JSON. Other options like `object.respond_to? :read` or `object.is_a?(IO)` were considered, but were not chosen due to significant implications for backward compatibility. **Evaluation & Discussion** While this enhancement does not alter the existing behavior of `JSON.[]` for types of objects it currently handles, it would change the behavior when `ARGF` is used. This change may not be fully backward-compatible. However, it significantly simplifies the code required to parse JSON from the command line, which is a common use case. One crucial aspect to note is that the result of `JSON[ARGF]` will change due to this modification. Currently, it returns the string `"\"ARGF\""`, but with this proposed change, it would parse the JSON content read from `ARGF` and return a Hash. **Summary** By extending `JSON.[]` method to directly support `ARGF`, developers will be able to more concisely handle JSON input from command line. This change, while not fully backward-compatible, will make `JSON.[]` more suitable for use cases involving command line input, thereby simplifying the required code. I look forward to hearing your thoughts on this proposal. -- https://bugs.ruby-lang.org/