json 2.6.3 → 2.7.1

data/lib/json/add/rational.rb

@@ -4,14 +4,28 @@ unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
 end
 
 class Rational
-  # Deserializes JSON string by converting numerator value <tt>n</tt>,
-  # denominator value <tt>d</tt>, to a Rational object.
+
+  # See #as_json.
   def self.json_create(object)
     Rational(object['n'], object['d'])
   end
 
-  # Returns a hash, that will be turned into a JSON object and represent this
-  # object.
+  # Methods <tt>Rational#as_json</tt> and +Rational.json_create+ may be used
+  # to serialize and deserialize a \Rational object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Rational#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/rational'
+  #   x = Rational(2, 3).as_json
+  #   # => {"json_class"=>"Rational", "n"=>2, "d"=>3}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Rational object:
+  #
+  #   Rational.json_create(x)
+  #   # => (2/3)
+  #
   def as_json(*)
     {
       JSON.create_id => self.class.name,
@@ -20,7 +34,15 @@ class Rational
     }
   end
 
-  # Stores class name (Rational) along with numerator value <tt>n</tt> and denominator value <tt>d</tt> as JSON string
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/rational'
+  #   puts Rational(2, 3).to_json
+  #
+  # Output:
+  #
+  #   {"json_class":"Rational","n":2,"d":3}
+  #
   def to_json(*args)
     as_json.to_json(*args)
   end

data/lib/json/add/regexp.rb

@@ -5,15 +5,26 @@ end
 
 class Regexp
 
-  # Deserializes JSON string by constructing new Regexp object with source
-  # <tt>s</tt> (Regexp or String) and options <tt>o</tt> serialized by
-  # <tt>to_json</tt>
+  # See #as_json.
   def self.json_create(object)
     new(object['s'], object['o'])
   end
 
-  # Returns a hash, that will be turned into a JSON object and represent this
-  # object.
+  # Methods <tt>Regexp#as_json</tt> and +Regexp.json_create+ may be used
+  # to serialize and deserialize a \Regexp object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Regexp#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/regexp'
+  #   x = /foo/.as_json
+  #   # => {"json_class"=>"Regexp", "o"=>0, "s"=>"foo"}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Regexp object:
+  #
+  #   Regexp.json_create(x) # => /foo/
+  #
   def as_json(*)
     {
       JSON.create_id => self.class.name,
@@ -22,8 +33,15 @@ class Regexp
     }
   end
 
-  # Stores class name (Regexp) with options <tt>o</tt> and source <tt>s</tt>
-  # (Regexp or String) as JSON string
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/regexp'
+  #   puts /foo/.to_json
+  #
+  # Output:
+  #
+  #    {"json_class":"Regexp","o":0,"s":"foo"}
+  #
   def to_json(*args)
     as_json.to_json(*args)
   end

data/lib/json/add/set.rb

@@ -4,16 +4,27 @@ end
 defined?(::Set) or require 'set'
 
 class Set
-  # Import a JSON Marshalled object.
-  #
-  # method used for JSON marshalling support.
+
+  # See #as_json.
   def self.json_create(object)
     new object['a']
   end
 
-  # Marshal the object to JSON.
+  # Methods <tt>Set#as_json</tt> and +Set.json_create+ may be used
+  # to serialize and deserialize a \Set object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Set#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/set'
+  #   x = Set.new(%w/foo bar baz/).as_json
+  #   # => {"json_class"=>"Set", "a"=>["foo", "bar", "baz"]}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Set object:
+  #
+  #   Set.json_create(x) # => #<Set: {"foo", "bar", "baz"}>
   #
-  # method used for JSON marshalling support.
   def as_json(*)
     {
       JSON.create_id => self.class.name,
@@ -21,7 +32,15 @@ class Set
     }
   end
 
-  # return the JSON value
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/set'
+  #   puts Set.new(%w/foo bar baz/).to_json
+  #
+  # Output:
+  #
+  #   {"json_class":"Set","a":["foo","bar","baz"]}
+  #
   def to_json(*args)
     as_json.to_json(*args)
   end

data/lib/json/add/struct.rb

@@ -5,14 +5,28 @@ end
 
 class Struct
 
-  # Deserializes JSON string by constructing new Struct object with values
-  # <tt>v</tt> serialized by <tt>to_json</tt>.
+  # See #as_json.
   def self.json_create(object)
     new(*object['v'])
   end
 
-  # Returns a hash, that will be turned into a JSON object and represent this
-  # object.
+  # Methods <tt>Struct#as_json</tt> and +Struct.json_create+ may be used
+  # to serialize and deserialize a \Struct object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Struct#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/struct'
+  #   Customer = Struct.new('Customer', :name, :address, :zip)
+  #   x = Struct::Customer.new.as_json
+  #   # => {"json_class"=>"Struct::Customer", "v"=>[nil, nil, nil]}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Struct object:
+  #
+  #   Struct::Customer.json_create(x)
+  #   # => #<struct Struct::Customer name=nil, address=nil, zip=nil>
+  #
   def as_json(*)
     klass = self.class.name
     klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
@@ -22,8 +36,16 @@ class Struct
     }
   end
 
-  # Stores class name (Struct) with Struct values <tt>v</tt> as a JSON string.
-  # Only named structs are supported.
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/struct'
+  #   Customer = Struct.new('Customer', :name, :address, :zip)
+  #   puts Struct::Customer.new.to_json
+  #
+  # Output:
+  #
+  #   {"json_class":"Struct","t":{'name':'Rowdy',"age":null}}
+  #
   def to_json(*args)
     as_json.to_json(*args)
   end

data/lib/json/add/symbol.rb

@@ -1,11 +1,26 @@
+
 #frozen_string_literal: false
 unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
   require 'json'
 end
 
 class Symbol
-  # Returns a hash, that will be turned into a JSON object and represent this
-  # object.
+
+  # Methods <tt>Symbol#as_json</tt> and +Symbol.json_create+ may be used
+  # to serialize and deserialize a \Symbol object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Symbol#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/symbol'
+  #   x = :foo.as_json
+  #   # => {"json_class"=>"Symbol", "s"=>"foo"}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Symbol object:
+  #
+  #   Symbol.json_create(x) # => :foo
+  #
   def as_json(*)
     {
       JSON.create_id => self.class.name,
@@ -13,12 +28,20 @@ class Symbol
     }
   end
 
-  # Stores class name (Symbol) with String representation of Symbol as a JSON string.
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/symbol'
+  #   puts :foo.to_json
+  #
+  # Output:
+  #
+  #   # {"json_class":"Symbol","s":"foo"}
+  #
   def to_json(*a)
     as_json.to_json(*a)
   end
 
-  # Deserializes JSON string by converting the <tt>string</tt> value stored in the object to a Symbol
+  # See #as_json.
   def self.json_create(o)
     o['s'].to_sym
   end

data/lib/json/add/time.rb

@@ -5,7 +5,7 @@ end
 
 class Time
 
-  # Deserializes JSON string by converting time since epoch to Time
+  # See #as_json.
   def self.json_create(object)
     if usec = object.delete('u') # used to be tv_usec -> tv_nsec
       object['n'] = usec * 1000
@@ -17,8 +17,22 @@ class Time
     end
   end
 
-  # Returns a hash, that will be turned into a JSON object and represent this
-  # object.
+  # Methods <tt>Time#as_json</tt> and +Time.json_create+ may be used
+  # to serialize and deserialize a \Time object;
+  # see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
+  #
+  # \Method <tt>Time#as_json</tt> serializes +self+,
+  # returning a 2-element hash representing +self+:
+  #
+  #   require 'json/add/time'
+  #   x = Time.now.as_json
+  #   # => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}
+  #
+  # \Method +JSON.create+ deserializes such a hash, returning a \Time object:
+  #
+  #    Time.json_create(x)
+  #    # => 2023-11-25 11:00:56.472846644 -0600
+  #
   def as_json(*)
     nanoseconds = [ tv_usec * 1000 ]
     respond_to?(:tv_nsec) and nanoseconds << tv_nsec
@@ -30,8 +44,15 @@ class Time
     }
   end
 
-  # Stores class name (Time) with number of seconds since epoch and number of
-  # microseconds for Time as JSON string
+  # Returns a JSON string representing +self+:
+  #
+  #   require 'json/add/time'
+  #   puts Time.now.to_json
+  #
+  # Output:
+  #
+  #   {"json_class":"Time","s":1700931678,"n":980650786}
+  #
   def to_json(*args)
     as_json.to_json(*args)
   end

data/lib/json/common.rb

@@ -3,6 +3,9 @@ require 'json/version'
 require 'json/generic_object'
 
 module JSON
+  NOT_SET = Object.new.freeze
+  private_constant :NOT_SET
+
   class << self
     # :call-seq:
     #   JSON[object] -> new_array or new_string
@@ -295,19 +298,9 @@ module JSON
   #
   def generate(obj, opts = nil)
     if State === opts
-      state, opts = opts, nil
+      state = opts
     else
-      state = State.new
-    end
-    if opts
-      if opts.respond_to? :to_hash
-        opts = opts.to_hash
-      elsif opts.respond_to? :to_h
-        opts = opts.to_h
-      else
-        raise TypeError, "can't convert #{opts.class} into Hash"
-      end
-      state = state.configure(opts)
+      state = State.new(opts)
     end
     state.generate(obj)
   end
@@ -334,19 +327,9 @@ module JSON
   #   JSON.fast_generate(a)
   def fast_generate(obj, opts = nil)
     if State === opts
-      state, opts = opts, nil
+      state = opts
     else
-      state = JSON.create_fast_state
-    end
-    if opts
-      if opts.respond_to? :to_hash
-        opts = opts.to_hash
-      elsif opts.respond_to? :to_h
-        opts = opts.to_h
-      else
-        raise TypeError, "can't convert #{opts.class} into Hash"
-      end
-      state.configure(opts)
+      state = JSON.create_fast_state.configure(opts)
     end
     state.generate(obj)
   end
@@ -592,13 +575,13 @@ module JSON
     # Sets or returns the default options for the JSON.dump method.
     # Initially:
     #   opts = JSON.dump_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false}
+    #   opts # => {:max_nesting=>false, :allow_nan=>true, :script_safe=>false}
     attr_accessor :dump_default_options
   end
   self.dump_default_options = {
     :max_nesting => false,
     :allow_nan   => true,
-    :escape_slash => false,
+    :script_safe => false,
   }
 
   # :call-seq:
@@ -628,16 +611,18 @@ module JSON
   #   puts File.read(path)
   # Output:
   #   {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
-  def dump(obj, anIO = nil, limit = nil)
-    if anIO and limit.nil?
-      anIO = anIO.to_io if anIO.respond_to?(:to_io)
-      unless anIO.respond_to?(:write)
-        limit = anIO
-        anIO = nil
-      end
+  def dump(obj, anIO = nil, limit = nil, kwargs = nil)
+    io_limit_opt = [anIO, limit, kwargs].compact
+    kwargs = io_limit_opt.pop if io_limit_opt.last.is_a?(Hash)
+    anIO, limit = io_limit_opt
+    if anIO.respond_to?(:to_io)
+      anIO = anIO.to_io
+    elsif limit.nil? && !anIO.respond_to?(:write)
+      anIO, limit = nil, anIO
     end
     opts = JSON.dump_default_options
     opts = opts.merge(:max_nesting => limit) if limit
+    opts = merge_dump_options(opts, **kwargs) if kwargs
     result = generate(obj, opts)
     if anIO
       anIO.write result
@@ -653,6 +638,15 @@ module JSON
   def self.iconv(to, from, string)
     string.encode(to, from)
   end
+
+  def merge_dump_options(opts, strict: NOT_SET)
+    opts = opts.merge(strict: strict) if NOT_SET != strict
+    opts
+  end
+
+  class << self
+    private :merge_dump_options
+  end
 end
 
 module ::Kernel

data/lib/json/pure/generator.rb

@@ -37,25 +37,34 @@ module JSON
     '\\'  =>  '\\\\',
   } # :nodoc:
 
-  ESCAPE_SLASH_MAP = MAP.merge(
+  ESCAPE_PATTERN = /[\/"\\\x0-\x1f]/n # :nodoc:
+
+  SCRIPT_SAFE_MAP = MAP.merge(
     '/'  =>  '\\/',
+    "\u2028".b => '\u2028',
+    "\u2029".b => '\u2029',
   )
 
+  SCRIPT_SAFE_ESCAPE_PATTERN = Regexp.union(ESCAPE_PATTERN, "\u2028".b, "\u2029".b)
+
   # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
   # UTF16 big endian characters as \u????, and return it.
-  def utf8_to_json(string, escape_slash = false) # :nodoc:
+  def utf8_to_json(string, script_safe = false) # :nodoc:
     string = string.dup
     string.force_encoding(::Encoding::ASCII_8BIT)
-    map = escape_slash ? ESCAPE_SLASH_MAP : MAP
-    string.gsub!(/[\/"\\\x0-\x1f]/) { map[$&] || $& }
+    if script_safe
+      string.gsub!(SCRIPT_SAFE_ESCAPE_PATTERN) { SCRIPT_SAFE_MAP[$&] || $& }
+    else
+      string.gsub!(ESCAPE_PATTERN) { MAP[$&] || $& }
+    end
     string.force_encoding(::Encoding::UTF_8)
     string
   end
 
-  def utf8_to_json_ascii(string, escape_slash = false) # :nodoc:
+  def utf8_to_json_ascii(string, script_safe = false) # :nodoc:
     string = string.dup
     string.force_encoding(::Encoding::ASCII_8BIT)
-    map = escape_slash ? ESCAPE_SLASH_MAP : MAP
+    map = script_safe ? SCRIPT_SAFE_MAP : MAP
     string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
     string.gsub!(/(
       (?:
@@ -115,7 +124,8 @@ module JSON
         # * *space_before*: a string that is put before a : pair delimiter (default: ''),
         # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
         # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-        # * *escape_slash*: true if forward slash (/) should be escaped (default: false)
+        # * *script_safe*: true if U+2028, U+2029 and forward slash (/) should be escaped
+        #   as to make the JSON object safe to interpolate in a script tag (default: false).
         # * *check_circular*: is deprecated now, use the :max_nesting option instead,
         # * *max_nesting*: sets the maximum level of data structure nesting in
         #   the generated JSON, max_nesting = 0 if no maximum should be checked.
@@ -130,7 +140,8 @@ module JSON
           @array_nl              = ''
           @allow_nan             = false
           @ascii_only            = false
-          @escape_slash          = false
+          @script_safe          = false
+          @strict                = false
           @buffer_initial_length = 1024
           configure opts
         end
@@ -158,7 +169,11 @@ module JSON
 
         # If this attribute is set to true, forward slashes will be escaped in
         # all json strings.
-        attr_accessor :escape_slash
+        attr_accessor :script_safe
+
+        # If this attribute is set to true, attempting to serialize types not
+        # supported by the JSON spec will raise a JSON::GeneratorError
+        attr_accessor :strict
 
         # :stopdoc:
         attr_reader :buffer_initial_length
@@ -200,8 +215,13 @@ module JSON
         end
 
         # Returns true, if forward slashes are escaped. Otherwise returns false.
-        def escape_slash?
-          @escape_slash
+        def script_safe?
+          @script_safe
+        end
+
+        # Returns true, if forward slashes are escaped. Otherwise returns false.
+        def strict?
+          @strict
         end
 
         # Configure this State instance with the Hash _opts_, and return
@@ -214,7 +234,7 @@ module JSON
           else
             raise TypeError, "can't convert #{opts.class} into Hash"
           end
-          for key, value in opts
+          opts.each do |key, value|
             instance_variable_set "@#{key}", value
           end
           @indent                = opts[:indent] if opts.key?(:indent)
@@ -226,7 +246,16 @@ module JSON
           @ascii_only            = opts[:ascii_only] if opts.key?(:ascii_only)
           @depth                 = opts[:depth] || 0
           @buffer_initial_length ||= opts[:buffer_initial_length]
-          @escape_slash          = !!opts[:escape_slash] if opts.key?(:escape_slash)
+
+          @script_safe = if opts.key?(:script_safe)
+            !!opts[:script_safe]
+          elsif opts.key?(:escape_slash)
+            !!opts[:escape_slash]
+          else
+            false
+          end
+
+          @strict                = !!opts[:strict] if opts.key?(:strict)
 
           if !opts.key?(:max_nesting) # defaults to 100
             @max_nesting = 100
@@ -243,7 +272,7 @@ module JSON
         # passed to the configure method.
         def to_h
           result = {}
-          for iv in instance_variables
+          instance_variables.each do |iv|
             iv = iv.to_s[1..-1]
             result[iv.to_sym] = self[iv]
           end
@@ -287,7 +316,13 @@ module JSON
           # Converts this object to a string (calling #to_s), converts
           # it to a JSON string, and returns the result. This is a fallback, if no
           # special method #to_json was defined for some object.
-          def to_json(*) to_s.to_json end
+          def to_json(generator_state)
+            if generator_state.strict?
+              raise GeneratorError, "#{self.class} not allowed in JSON"
+            else
+              to_s.to_json
+            end
+          end
         end
 
         module Hash
@@ -310,21 +345,18 @@ module JSON
           end
 
           def json_transform(state)
-            delim = ','
-            delim << state.object_nl
-            result = '{'
-            result << state.object_nl
+            delim = ",#{state.object_nl}"
+            result = "{#{state.object_nl}"
             depth = state.depth += 1
             first = true
             indent = !state.object_nl.empty?
-            each { |key,value|
+            each { |key, value|
               result << delim unless first
               result << state.indent * depth if indent
-              result << key.to_s.to_json(state)
-              result << state.space_before
-              result << ':'
-              result << state.space
-              if value.respond_to?(:to_json)
+              result = "#{result}#{key.to_s.to_json(state)}#{state.space_before}:#{state.space}"
+              if state.strict?
+                raise GeneratorError, "#{value.class} not allowed in JSON"
+              elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
               else
                 result << %{"#{String(value)}"}
@@ -365,7 +397,9 @@ module JSON
             each { |value|
               result << delim unless first
               result << state.indent * depth if indent
-              if value.respond_to?(:to_json)
+              if state.strict?
+                raise GeneratorError, "#{value.class} not allowed in JSON"
+              elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
               else
                 result << %{"#{String(value)}"}
@@ -419,9 +453,9 @@ module JSON
               string = encode(::Encoding::UTF_8)
             end
             if state.ascii_only?
-              '"' << JSON.utf8_to_json_ascii(string, state.escape_slash) << '"'
+              '"' << JSON.utf8_to_json_ascii(string, state.script_safe) << '"'
             else
-              '"' << JSON.utf8_to_json(string, state.escape_slash) << '"'
+              '"' << JSON.utf8_to_json(string, state.script_safe) << '"'
             end
           end
 

data/lib/json/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: false
 module JSON
   # JSON version
-  VERSION         = '2.6.3'
+  VERSION         = '2.7.1'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/json.rb

@@ -285,6 +285,15 @@ require 'json/common'
 #   # Raises JSON::NestingError (nesting of 2 is too deep):
 #   JSON.generate(obj, max_nesting: 2)
 #
+# ====== Escaping Options
+#
+# Options +script_safe+ (boolean) specifies wether <tt>'\u2028'</tt>, <tt>'\u2029'</tt>
+# and <tt>'/'</tt> should be escaped as to make the JSON object safe to interpolate in script
+# tags.
+#
+# Options +ascii_only+ (boolean) specifies wether all characters outside the ASCII range
+# should be escaped.
+#
 # ====== Output Options
 #
 # The default formatting options generate the most compact