json 1.1.0-mswin32 → 1.1.1-mswin32

data/lib/json/editor.rb

@@ -52,14 +52,12 @@ module JSON
         MessageDialog::ERROR, 
         MessageDialog::BUTTONS_CLOSE, text)
       dialog.show_all
-      window.focus = dialog
       dialog.run
     rescue TypeError
       dialog = MessageDialog.new(Editor.window, Dialog::MODAL, 
         MessageDialog::ERROR, 
         MessageDialog::BUTTONS_CLOSE, text)
       dialog.show_all
-      window.focus = dialog
       dialog.run
     ensure
       dialog.destroy if dialog
@@ -73,7 +71,6 @@ module JSON
         MessageDialog::QUESTION, 
         MessageDialog::BUTTONS_YES_NO, text)
       dialog.show_all
-      window.focus = dialog
       dialog.run do |response|
         return Gtk::Dialog::RESPONSE_YES === response
       end
@@ -1102,9 +1099,11 @@ module JSON
       # Quit this editor, that is, leave this editor's main loop.
       def quit
         ask_save if @changed
-        destroy
-        Gtk.main_quit
-        true
+        if Gtk.main_level > 0
+          destroy
+          Gtk.main_quit
+        end
+        nil
       end
 
       # Display the new title according to the editor's current state.
@@ -1185,20 +1184,21 @@ module JSON
         if filename
           if File.directory?(filename)
             Editor.error_dialog(self, "Try to select a JSON file!")
-            return
+            nil
           else
-            data = read_data(filename)
             @filename = filename
-            toplevel.display_status("Loaded data from '#@filename'.")
+            if data = read_data(filename)
+              toplevel.display_status("Loaded data from '#@filename'.")
+            end
             display_title
-            return data
+            data
           end
         end
       end
 
       # Load the data at location _uri_ into the editor as a JSON document.
       def load_location(uri)
-        data = read_data(uri)
+        data = read_data(uri) or return
         @filename = nil
         toplevel.display_status("Loaded data from '#{uri}'.")
         display_title
@@ -1217,11 +1217,9 @@ module JSON
           end
           return JSON::parse(json, :max_nesting => false)
         end
-      rescue JSON::JSONError => e
+      rescue => e
         Editor.error_dialog(self, "Failed to parse JSON file: #{e}!")
         return
-      rescue SystemCallError => e
-        quit
       end
 
       # Open a file selecton dialog, displaying _message_, and return the

data/lib/json/pure/generator.rb

@@ -89,15 +89,22 @@ module JSON
         # * *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: ''),
         # * *check_circular*: true if checking for circular data structures
+        #   should be done (the default), false otherwise.
+        # * *check_circular*: true if checking for circular data structures
         #   should be done, false (the default) otherwise.
+        # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+        #   generated, otherwise an exception is thrown, if these values are
+        #   encountered. This options defaults to false.
         def initialize(opts = {})
-          @indent         = opts[:indent]       || ''
-          @space          = opts[:space]        || ''
-          @space_before   = opts[:space_before] || ''
-          @object_nl      = opts[:object_nl]    || ''
-          @array_nl       = opts[:array_nl]     || ''
-          @check_circular = !!(opts[:check_circular] || false)
-          @seen           = {}
+          @seen = {}
+          @indent         = ''
+          @space          = ''
+          @space_before   = ''
+          @object_nl      = ''
+          @array_nl       = ''
+          @check_circular = true
+          @allow_nan      = false
+          configure opts
         end
 
         # This string is used to indent levels in the JSON text.
@@ -117,12 +124,29 @@ module JSON
         # This string is put at the end of a line that holds a JSON array.
         attr_accessor :array_nl
 
+        # This integer returns the maximum level of data structure nesting in
+        # the generated JSON, max_nesting = 0 if no maximum is checked.
+        attr_accessor :max_nesting
+
+        def check_max_nesting(depth) # :nodoc:
+          return if @max_nesting.zero?
+          current_nesting = depth + 1
+          current_nesting > @max_nesting and
+            raise NestingError, "nesting of #{current_nesting} is too deep"
+        end
+
         # Returns true, if circular data structures should be checked,
         # otherwise returns false.
         def check_circular?
           @check_circular
         end
 
+        # Returns true if NaN, Infinity, and -Infinity should be considered as
+        # valid JSON and output.
+        def allow_nan?
+          @allow_nan
+        end
+
         # Returns _true_, if _object_ was already seen during this generating
         # run. 
         def seen?(object)
@@ -139,6 +163,36 @@ module JSON
         def forget(object)
           @seen.delete object.__id__
         end
+
+        # Configure this State instance with the Hash _opts_, and return
+        # itself.
+        def configure(opts)
+          @indent         = opts[:indent] if opts.key?(:indent)
+          @space          = opts[:space] if opts.key?(:space)
+          @space_before   = opts[:space_before] if opts.key?(:space_before)
+          @object_nl      = opts[:object_nl] if opts.key?(:object_nl)
+          @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
+          @check_circular = !!opts[:check_circular] if opts.key?(:check_circular)
+          @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
+          if !opts.key?(:max_nesting) # defaults to 19
+            @max_nesting = 19
+          elsif opts[:max_nesting]
+            @max_nesting = opts[:max_nesting]
+          else
+            @max_nesting = 0
+          end
+          self
+        end
+
+        # Returns the configuration instance variables as a hash, that can be
+        # passed to the configure method.
+        def to_h
+          result = {}
+          for iv in %w[indent space space_before object_nl array_nl check_circular allow_nan max_nesting]
+            result[iv.intern] = instance_variable_get("@#{iv}")
+          end
+          result
+        end
       end
 
       module GeneratorMethods
@@ -158,6 +212,7 @@ module JSON
           def to_json(state = nil, depth = 0, *)
             if state
               state = JSON.state.from_state(state)
+              state.check_max_nesting(depth)
               json_check_circular(state) { json_transform(state, depth) }
             else
               json_transform(state, depth)
@@ -167,7 +222,7 @@ module JSON
           private
 
           def json_check_circular(state)
-            if state
+            if state and state.check_circular?
               state.seen?(self) and raise JSON::CircularDatastructure,
                   "circular data structures not supported!"
               state.remember self
@@ -211,6 +266,7 @@ module JSON
           def to_json(state = nil, depth = 0, *)
             if state
               state = JSON.state.from_state(state)
+              state.check_max_nesting(depth)
               json_check_circular(state) { json_transform(state, depth) }
             else
               json_transform(state, depth)
@@ -220,7 +276,7 @@ module JSON
           private
 
           def json_check_circular(state)
-            if state
+            if state and state.check_circular?
               state.seen?(self) and raise JSON::CircularDatastructure,
                 "circular data structures not supported!"
               state.remember self
@@ -257,7 +313,24 @@ module JSON
 
         module Float
           # Returns a JSON string representation for this Float number.
-          def to_json(*) to_s end
+          def to_json(state = nil, *)
+            case
+            when infinite?
+              if !state || state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            when nan?
+              if !state || state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            else
+              to_s
+            end
+          end
         end
 
         module String

data/lib/json/pure/parser.rb

@@ -19,6 +19,9 @@ module JSON
                                   (?i:e[+-]?\d+)
                                 )
                                 )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
       OBJECT_OPEN           = /\{/
       OBJECT_CLOSE          = /\}/
       ARRAY_OPEN            = /\[/
@@ -50,7 +53,11 @@ module JSON
       # It will be configured by the _opts_ hash. _opts_ can have the following
       # keys:
       # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
-      #   structures. Disable depth checking with :max_nesting => false.
+      #   structures. Disable depth checking with :max_nesting => false|nil|0,
+      #   it defaults to 19.
+      # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+      #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+      #   to false.
       def initialize(source, opts = {})
         super
         if !opts.key?(:max_nesting) # defaults to 19
@@ -60,6 +67,7 @@ module JSON
         else
           @max_nesting = 0
         end
+        @allow_nan = !!opts[:allow_nan]
         @create_id = JSON.create_id
       end
 
@@ -153,6 +161,12 @@ module JSON
           obj = parse_object
           @current_nesting -= 1
           obj
+        when @allow_nan && scan(NAN)
+          NaN
+        when @allow_nan && scan(INFINITY)
+          Infinity
+        when @allow_nan && scan(MINUS_INFINITY)
+          MinusInfinity
         else
           UNPARSED
         end

data/lib/json/version.rb

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

data/tests/fixtures/fail18.json

@@ -1 +1 @@
-[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]] // No, we don't limit our depth: Moved to pass...
+[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]

data/tests/test_json.rb

@@ -2,6 +2,7 @@
 
 require 'test/unit'
 require 'json'
+require 'stringio'
 
 class TC_JSON < Test::Unit::TestCase
   include JSON
@@ -61,6 +62,12 @@ class TC_JSON < Test::Unit::TestCase
     assert_equal_float [3.141], parse('[3141.0E-3]')
     assert_equal_float [-3.141], parse('[-3141.0e-3]')
     assert_equal_float [-3.141], parse('[-3141e-3]')
+    assert_raises(ParserError) { parse('[NaN]') }
+    assert parse('[NaN]', :allow_nan => true).first.nan?
+    assert_raises(ParserError) { parse('[Infinity]') }
+    assert_equal [1.0/0], parse('[Infinity]', :allow_nan => true)
+    assert_raises(ParserError) { parse('[-Infinity]') }
+    assert_equal [-1.0/0], parse('[-Infinity]', :allow_nan => true)
     assert_equal([""], parse('[""]'))
     assert_equal(["foobar"], parse('["foobar"]'))
     assert_equal([{}], parse('[{}]'))
@@ -238,18 +245,50 @@ EOT
   end
 
   def test_nesting
-    to_deep = '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]'
-    assert_raises(JSON::NestingError) { JSON.parse to_deep }
-    assert_raises(JSON::NestingError) { JSON.parser.new(to_deep).parse }
-    assert_raises(JSON::NestingError) { JSON.parse to_deep, :max_nesting => 19 }
-    ok = JSON.parse to_deep, :max_nesting => 20
-    assert_kind_of Array, ok
-    ok = JSON.parse to_deep, :max_nesting => nil
-    assert_kind_of Array, ok
-    ok = JSON.parse to_deep, :max_nesting => false
-    assert_kind_of Array, ok
-    ok = JSON.parse to_deep, :max_nesting => 0
-    assert_kind_of Array, ok
+    assert_raises(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
+    assert_raises(JSON::NestingError) { JSON.parser.new('[[]]', :max_nesting => 1).parse }
+    assert_equal [[]], JSON.parse('[[]]', :max_nesting => 2)
+    too_deep = '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]'
+    too_deep_ary = eval too_deep
+    assert_raises(JSON::NestingError) { JSON.parse too_deep }
+    assert_raises(JSON::NestingError) { JSON.parser.new(too_deep).parse }
+    assert_raises(JSON::NestingError) { JSON.parse too_deep, :max_nesting => 19 }
+    ok = JSON.parse too_deep, :max_nesting => 20
+    assert_equal too_deep_ary, ok
+    ok = JSON.parse too_deep, :max_nesting => nil
+    assert_equal too_deep_ary, ok
+    ok = JSON.parse too_deep, :max_nesting => false
+    assert_equal too_deep_ary, ok
+    ok = JSON.parse too_deep, :max_nesting => 0
+    assert_equal too_deep_ary, ok
+    assert_raises(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
+    assert_equal '[[]]', JSON.generate([[]], :max_nesting => 2)
+    assert_raises(JSON::NestingError) { JSON.generate too_deep_ary }
+    assert_raises(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 19 }
+    ok = JSON.generate too_deep_ary, :max_nesting => 20
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => nil
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => false
+    assert_equal too_deep, ok
+    ok = JSON.generate too_deep_ary, :max_nesting => 0
+    assert_equal too_deep, ok
+  end
+
+  def test_load_dump
+    too_deep = '[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]'
+    assert_equal too_deep, JSON.dump(eval(too_deep))
+    assert_kind_of String, Marshal.dump(eval(too_deep))
+    assert_raises(ArgumentError) { JSON.dump(eval(too_deep), 19) }
+    assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 19) }
+    assert_equal too_deep, JSON.dump(eval(too_deep), 20)
+    assert_kind_of String, Marshal.dump(eval(too_deep), 20)
+    output = StringIO.new
+    JSON.dump(eval(too_deep), output)
+    assert_equal too_deep, output.string
+    output = StringIO.new
+    JSON.dump(eval(too_deep), output, 20)
+    assert_equal too_deep, output.string
   end
 end
   # vim: set et sw=2 ts=2:

data/tests/test_json_addition.rb

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 
 require 'test/unit'
-require 'json'
+require 'json/add/core'
+require 'date'
 
 class TC_JSONAddition < Test::Unit::TestCase
   include JSON
@@ -23,7 +24,7 @@ class TC_JSONAddition < Test::Unit::TestCase
 
     def to_json(*args)
       {
-        'json_class'  => self.class,
+        'json_class'  => self.class.name,
         'args'        => [ @a ],
       }.to_json(*args)
     end
@@ -32,7 +33,7 @@ class TC_JSONAddition < Test::Unit::TestCase
   class B
     def to_json(*args)
       {
-        'json_class'  => self.class,
+        'json_class'  => self.class.name,
       }.to_json(*args)
     end
   end
@@ -91,4 +92,34 @@ EOT
     raw_again = JSON.parse(json)
     assert_equal raw, raw_again
   end
+
+  def test_core
+    t = Time.now
+    assert_equal t, JSON(JSON(t))
+    d = Date.today
+    assert_equal d, JSON(JSON(d))
+    d = DateTime.civil(2007, 6, 14, 14, 57, 10, Rational(1, 12), 2299161)
+    assert_equal d, JSON(JSON(d))
+    assert_equal 1..10, JSON(JSON(1..10))
+    assert_equal 1...10, JSON(JSON(1...10))
+    assert_equal "a".."c", JSON(JSON("a".."c"))
+    assert_equal "a"..."c", JSON(JSON("a"..."c"))
+    struct = Struct.new 'MyStruct', :foo, :bar
+    s = struct.new 4711, 'foot'
+    assert_equal s, JSON(JSON(s))
+    struct = Struct.new :foo, :bar
+    s = struct.new 4711, 'foot'
+    assert_raises(JSONError) { JSON(s) }
+    begin
+      raise TypeError, "test me"
+    rescue TypeError => e
+      e_json = JSON.generate e
+      e_again = JSON e_json
+      assert_kind_of TypeError, e_again
+      assert_equal e.message, e_again.message
+      assert_equal e.backtrace, e_again.backtrace
+    end
+    assert_equal /foo/, JSON(JSON(/foo/))
+    assert_equal /foo/i, JSON(JSON(/foo/i))
+  end
 end

data/tests/test_json_fixtures.rb

@@ -13,14 +13,14 @@ class TC_JSONFixtures < Test::Unit::TestCase
   end
 
   def test_passing
-    for (name, source) in @passed
+    for name, source in @passed
       assert JSON.parse(source),
         "Did not pass for fixture '#{name}'"
     end
   end
 
   def test_failing
-    for (name, source) in @failed
+    for name, source in @failed
       assert_raises(JSON::ParserError, JSON::NestingError,
         "Did not fail for fixture '#{name}'") do
         JSON.parse(source)

data/tests/test_json_generate.rb

@@ -40,7 +40,7 @@ EOT
 
   def test_unparse
     json = unparse(@hash)
-    assert_equal(@json2, json)
+    assert_equal(JSON.parse(@json2), JSON.parse(json))
     parsed_json = parse(json)
     assert_equal(@hash, parsed_json)
     json = generate({1=>2})
@@ -51,7 +51,7 @@ EOT
 
   def test_unparse_pretty
     json = pretty_unparse(@hash)
-    assert_equal(@json3, json)
+    assert_equal(JSON.parse(@json3), JSON.parse(json))
     parsed_json = parse(json)
     assert_equal(@hash, parsed_json)
     json = pretty_generate({1=>2})
@@ -71,6 +71,7 @@ EOT
     #assert s.check_circular
     h = { 1=>2 }
     h[3] = h
+    assert_raises(JSON::CircularDatastructure) {  generate(h) }
     assert_raises(JSON::CircularDatastructure) {  generate(h, s) }
     s = JSON.state.new(:check_circular => true)
     #assert s.check_circular
@@ -78,4 +79,22 @@ EOT
     a << a
     assert_raises(JSON::CircularDatastructure) {  generate(a, s) }
   end
+
+  def test_allow_nan
+    assert_raises(GeneratorError) { generate([JSON::NaN]) }
+    assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true)
+    assert_equal '[NaN]', fast_generate([JSON::NaN])
+    assert_raises(GeneratorError) { pretty_generate([JSON::NaN]) }
+    assert_equal "[\n  NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true)
+    assert_raises(GeneratorError) { generate([JSON::Infinity]) }
+    assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true)
+    assert_equal '[Infinity]', fast_generate([JSON::Infinity])
+    assert_raises(GeneratorError) { pretty_generate([JSON::Infinity]) }
+    assert_equal "[\n  Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true)
+    assert_raises(GeneratorError) { generate([JSON::MinusInfinity]) }
+    assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true)
+    assert_equal '[-Infinity]', fast_generate([JSON::MinusInfinity])
+    assert_raises(GeneratorError) { pretty_generate([JSON::MinusInfinity]) }
+    assert_equal "[\n  -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true)
+  end
 end