Feature #19706: Make JSON.[] support ARGF object

• Status: Third Party's Issue
• Assignee: -
• Target version: -

[tatzyr (Tatsuya Otsuka)]

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.[]:

  ### 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.

[nobu (Nobuyoshi Nakada)]

• Status changed from Open to Third Party's Issue

Json has its own upstream, https://github.com/flori/json.

BTW: I've never used JSON[], but it looks like whole opposite functions are crammed into one method.

[nobu (Nobuyoshi Nakada)]

JSON.load(ARGF)["foo"] is possible in all versions (1.5.5 bundled with ruby1.9, at least).