json_pure 1.4.0 → 1.4.6

data/ext/json/ext/{generator.h → generator/generator.h}

@@ -70,9 +70,10 @@ static void fbuffer_free(FBuffer *fb);
 static void fbuffer_free_only_buffer(FBuffer *fb);
 static void fbuffer_clear(FBuffer *fb);
 static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned int len);
-static void fbuffer_append_integer(FBuffer *fb, int number);
+static void fbuffer_append_long(FBuffer *fb, long number);
 static void fbuffer_append_char(FBuffer *fb, char newchr);
 static FBuffer *fbuffer_dup(FBuffer *fb);
+static VALUE fbuffer_to_s(FBuffer *fb);
 
 /* unicode defintions */
 
@@ -123,15 +124,29 @@ typedef struct JSON_Generator_StateStruct {
     long max_nesting;
     char allow_nan;
     char ascii_only;
+    long depth;
 } JSON_Generator_State;
 
 #define GET_STATE(self)                       \
     JSON_Generator_State *state;              \
     Data_Get_Struct(self, JSON_Generator_State, state)
 
+#define GENERATE_JSON(type)                                                                     \
+    FBuffer *buffer;                                                                            \
+    VALUE Vstate;                                                                               \
+    JSON_Generator_State *state;                                                                \
+                                                                                                \
+    rb_scan_args(argc, argv, "01", &Vstate);                                                    \
+    Vstate = cState_from_state_s(cState, Vstate);                                               \
+    Data_Get_Struct(Vstate, JSON_Generator_State, state);                                       \
+    buffer = cState_prepare_buffer(Vstate);                                                     \
+    generate_json_##type(buffer, Vstate, state, self);                                          \
+    return fbuffer_to_s(buffer)
+
 static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self);
-static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self);
+static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self);
+static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mString_included_s(VALUE self, VALUE modul);
 static VALUE mString_to_json(int argc, VALUE *argv, VALUE self);
@@ -147,8 +162,17 @@ static JSON_Generator_State *State_allocate();
 static VALUE cState_s_allocate(VALUE klass);
 static VALUE cState_configure(VALUE self, VALUE opts);
 static VALUE cState_to_h(VALUE self);
-static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj, long depth);
-static VALUE cState_partial_generate(VALUE self, VALUE obj, VALUE depth);
+static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+static VALUE cState_partial_generate(VALUE self, VALUE obj);
 static VALUE cState_generate(VALUE self, VALUE obj);
 static VALUE cState_initialize(int argc, VALUE *argv, VALUE self);
 static VALUE cState_from_state_s(VALUE self, VALUE opts);
@@ -166,5 +190,8 @@ static VALUE cState_max_nesting(VALUE self);
 static VALUE cState_max_nesting_set(VALUE self, VALUE depth);
 static VALUE cState_allow_nan_p(VALUE self);
 static VALUE cState_ascii_only_p(VALUE self);
+static VALUE cState_depth(VALUE self);
+static VALUE cState_depth_set(VALUE self, VALUE depth);
+static FBuffer *cState_prepare_buffer(VALUE self);
 
 #endif

data/ext/json/ext/{extconf_parser.rb → parser/extconf.rb}

@@ -12,4 +12,4 @@ if CONFIG['CC'] =~ /gcc/
 end
 
 have_header("re.h")
-create_makefile 'parser'
+create_makefile 'json/ext/parser'

data/ext/json/ext/{parser.c → parser/parser.c}

@@ -147,8 +147,9 @@ case 2:
 tr2:
 #line 127 "parser.rl"
 	{
+        char *np;
         json->parsing_name = 1;
-        char *np = JSON_parse_string(json, p, pe, &last_name);
+        np = JSON_parse_string(json, p, pe, &last_name);
         json->parsing_name = 0;
         if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else {p = (( np))-1;}
     }

data/ext/json/ext/{parser.rl → parser/parser.rl}

@@ -125,8 +125,9 @@ static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
     }
 
     action parse_name {
+        char *np;
         json->parsing_name = 1;
-        char *np = JSON_parse_string(json, fpc, pe, &last_name);
+        np = JSON_parse_string(json, fpc, pe, &last_name);
         json->parsing_name = 0;
         if (np == NULL) { fhold; fbreak; } else fexec np;
     }

data/lib/json/common.rb

@@ -11,9 +11,9 @@ module JSON
     # generate and parse for their documentation.
     def [](object, opts = {})
       if object.respond_to? :to_str
-        JSON.parse(object.to_str, opts => {})
+        JSON.parse(object.to_str, opts)
       else
-        JSON.generate(object, opts => {})
+        JSON.generate(object, opts)
       end
     end
 
@@ -63,20 +63,20 @@ module JSON
       end
       self.state = generator::State
       const_set :State, self.state
-      const_set :SAFE_STATE_PROTOTYPE, State.new.freeze
+      const_set :SAFE_STATE_PROTOTYPE, State.new
       const_set :FAST_STATE_PROTOTYPE, State.new(
         :indent         => '',
         :space          => '',
         :object_nl      => "",
         :array_nl       => "",
         :max_nesting    => false
-      ).freeze
+      )
       const_set :PRETTY_STATE_PROTOTYPE, State.new(
         :indent         => '  ',
         :space          => ' ',
         :object_nl      => "\n",
         :array_nl       => "\n"
-      ).freeze
+      )
     end
 
     # Returns the JSON generator modul, that is used by JSON. This might be
@@ -196,6 +196,7 @@ module JSON
   # amount of sanity checks, and the pretty_generate method for some
   # defaults for a pretty output.
   def generate(obj, opts = nil)
+    state = SAFE_STATE_PROTOTYPE.dup
     if opts
       if opts.respond_to? :to_hash
         opts = opts.to_hash
@@ -204,10 +205,7 @@ module JSON
       else
         raise TypeError, "can't convert #{opts.class} into Hash"
       end
-      state = SAFE_STATE_PROTOTYPE.dup
       state = state.configure(opts)
-    else
-      state = SAFE_STATE_PROTOTYPE
     end
     state.generate(obj)
   end
@@ -225,6 +223,7 @@ module JSON
   # *WARNING*: Be careful not to pass any Ruby data structures with circles as
   # _obj_ argument, because this will cause JSON to go into an infinite loop.
   def fast_generate(obj, opts = nil)
+    state = FAST_STATE_PROTOTYPE.dup
     if opts
       if opts.respond_to? :to_hash
         opts = opts.to_hash
@@ -233,10 +232,7 @@ module JSON
       else
         raise TypeError, "can't convert #{opts.class} into Hash"
       end
-      state = FAST_STATE_PROTOTYPE.dup
       state.configure(opts)
-    else
-      state = FAST_STATE_PROTOTYPE
     end
     state.generate(obj)
   end
@@ -254,6 +250,7 @@ module JSON
   # The _opts_ argument can be used to configure the generator, see the
   # generate method for a more detailed explanation.
   def pretty_generate(obj, opts = nil)
+    state = PRETTY_STATE_PROTOTYPE.dup
     if opts
       if opts.respond_to? :to_hash
         opts = opts.to_hash
@@ -262,10 +259,7 @@ module JSON
       else
         raise TypeError, "can't convert #{opts.class} into Hash"
       end
-      state = PRETTY_STATE_PROTOTYPE.dup
       state.configure(opts)
-    else
-      state = PRETTY_STATE_PROTOTYPE
     end
     state.generate(obj)
   end
@@ -377,11 +371,11 @@ module ::Kernel
   #
   # The _opts_ argument is passed through to generate/parse respectively, see
   # generate and parse for their documentation.
-  def JSON(object, opts = {})
+  def JSON(object, *args)
     if object.respond_to? :to_str
-      JSON.parse(object.to_str, opts)
+      JSON.parse(object.to_str, args.first)
     else
-      JSON.generate(object, opts)
+      JSON.generate(object, args.first)
     end
   end
 end

data/lib/json/pure/generator.rb

@@ -112,7 +112,7 @@ module JSON
           when Hash
             new(opts)
           else
-            SAFE_STATE_PROTOTYPE
+            SAFE_STATE_PROTOTYPE.dup
           end
         end
 
@@ -163,7 +163,11 @@ module JSON
         # the generated JSON, max_nesting = 0 if no maximum is checked.
         attr_accessor :max_nesting
 
-        def check_max_nesting(depth) # :nodoc:
+        # This integer returns the current depth data structure nesting in the
+        # generated JSON.
+        attr_accessor :depth
+
+        def check_max_nesting # :nodoc:
           return if @max_nesting.zero?
           current_nesting = depth + 1
           current_nesting > @max_nesting and
@@ -196,6 +200,7 @@ module JSON
           @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
           @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
           @ascii_only     = opts[:ascii_only] if opts.key?(:ascii_only)
+          @depth          = opts[:depth] || 0
           if !opts.key?(:max_nesting) # defaults to 19
             @max_nesting = 19
           elsif opts[:max_nesting]
@@ -210,7 +215,7 @@ module JSON
         # passed to the configure method.
         def to_h
           result = {}
-          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting]
+          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting ascii_only depth]
             result[iv.intern] = instance_variable_get("@#{iv}")
           end
           result
@@ -247,51 +252,41 @@ module JSON
           # _state_ is a JSON::State object, that can also be used to configure the
           # produced JSON string output further.
           # _depth_ is used to find out nesting depth, to indent accordingly.
-          def to_json(state = nil, depth = 0, *)
-            if state
-              state = State.from_state(state)
-              state.check_max_nesting(depth)
-            end
-            json_transform(state, depth)
+          def to_json(state = nil, *)
+            state = State.from_state(state)
+            state.check_max_nesting
+            json_transform(state)
           end
 
           private
 
-          def json_shift(state, depth)
-            state and not state.object_nl.empty? or return ''
-            state.indent * depth
+          def json_shift(state)
+            state.object_nl.empty? or return ''
+            state.indent * state.depth
           end
 
-          def json_transform(state, depth)
+          def json_transform(state)
             delim = ','
-            if state
-              delim << state.object_nl
-              result = '{'
-              result << state.object_nl
-              depth += 1
-              first = true
-              indent = state && !state.object_nl.empty?
-              each { |key,value|
-                result << delim unless first
-                result << state.indent * depth if indent
-                result << key.to_s.to_json(state, depth)
-                result << state.space_before
-                result << ':'
-                result << state.space
-                result << value.to_json(state, depth)
-                first = false
-              }
-              depth -= 1
-              result << state.object_nl
-              result << state.indent * depth if indent if indent
-              result << '}'
-            else
-              result = '{'
-              result << map { |key,value|
-                key.to_s.to_json << ':' << value.to_json
-              }.join(delim)
-              result << '}'
-            end
+            delim << state.object_nl
+            result = '{'
+            result << state.object_nl
+            depth = state.depth += 1
+            first = true
+            indent = !state.object_nl.empty?
+            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
+              result << value.to_json(state)
+              first = false
+            }
+            depth = state.depth -= 1
+            result << state.object_nl
+            result << state.indent * depth if indent if indent
+            result << '}'
             result
           end
         end
@@ -301,39 +296,32 @@ module JSON
           # this Array instance.
           # _state_ is a JSON::State object, that can also be used to configure the
           # produced JSON string output further.
-          # _depth_ is used to find out nesting depth, to indent accordingly.
-          def to_json(state = nil, depth = 0, *)
-            if state
-              state = State.from_state(state)
-              state.check_max_nesting(depth)
-            end
-            json_transform(state, depth)
+          def to_json(state = nil, *)
+            state = State.from_state(state)
+            state.check_max_nesting
+            json_transform(state)
           end
 
           private
 
-          def json_transform(state, depth)
+          def json_transform(state)
             delim = ','
-            if state
-              delim << state.array_nl
-              result = '['
-              result << state.array_nl
-              depth += 1
-              first = true
-              indent = state && !state.array_nl.empty?
-              each { |value|
-                result << delim unless first
-                result << state.indent * depth if indent
-                result << value.to_json(state, depth)
-                first = false
-              }
-              depth -= 1
-              result << state.array_nl
+            delim << state.array_nl
+            result = '['
+            result << state.array_nl
+            depth = state.depth += 1
+            first = true
+            indent = !state.array_nl.empty?
+            each { |value|
+              result << delim unless first
               result << state.indent * depth if indent
-              result << ']'
-            else
-              '[' << map { |value| value.to_json }.join(delim) << ']'
-            end
+              result << value.to_json(state)
+              first = false
+            }
+            depth = state.depth -= 1
+            result << state.array_nl
+            result << state.indent * depth if indent
+            result << ']'
           end
         end
 
@@ -345,15 +333,16 @@ module JSON
         module Float
           # Returns a JSON string representation for this Float number.
           def to_json(state = nil, *)
+            state = State.from_state(state)
             case
             when infinite?
-              if state && state.allow_nan?
+              if state.allow_nan?
                 to_s
               else
                 raise GeneratorError, "#{self} not allowed in JSON"
               end
             when nan?
-              if state && state.allow_nan?
+              if state.allow_nan?
                 to_s
               else
                 raise GeneratorError, "#{self} not allowed in JSON"
@@ -369,9 +358,8 @@ module JSON
             # This string should be encoded with UTF-8 A call to this method
             # returns a JSON string encoded with UTF16 big endian characters as
             # \u????.
-            def to_json(*args)
-              state, = *args
-              state ||= State.from_state(state)
+            def to_json(state = nil, *args)
+              state = State.from_state(state)
               if encoding == ::Encoding::UTF_8
                 string = self
               else
@@ -387,9 +375,8 @@ module JSON
             # This string should be encoded with UTF-8 A call to this method
             # returns a JSON string encoded with UTF16 big endian characters as
             # \u????.
-            def to_json(*args)
-              state, = *args
-              state ||= State.from_state(state)
+            def to_json(state = nil, *args)
+              state = State.from_state(state)
               if state.ascii_only?
                 '"' << JSON.utf8_to_json_ascii(self) << '"'
               else

data/lib/json/pure/parser.rb

@@ -69,40 +69,42 @@ module JSON
       # * *object_class*: Defaults to Hash
       # * *array_class*: Defaults to Array
       def initialize(source, opts = {})
-          if defined?(::Encoding)
-            if source.encoding == Encoding::ASCII_8BIT
-              b = source[0, 4].bytes.to_a
-              source = case
-                       when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-                         source.dup.force_encoding(Encoding::UTF_32BE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[0] == 0 && b[2] == 0
-                         source.dup.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-                         source.dup.force_encoding(Encoding::UTF_32LE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[1] == 0 && b[3] == 0
-                         source.dup.force_encoding(Encoding::UTF_16LE).encode!(Encoding::UTF_8)
-                       else
-                         source.dup
-                       end
-            else
-              source = source.encode(Encoding::UTF_8)
-            end
-            source.force_encoding(Encoding::ASCII_8BIT)
-          else
-            b = source
+        opts ||= {}
+        if defined?(::Encoding)
+          if source.encoding == ::Encoding::ASCII_8BIT
+            b = source[0, 4].bytes.to_a
             source = case
                      when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-                       JSON.iconv('utf-8', 'utf-32be', b)
+                       source.dup.force_encoding(::Encoding::UTF_32BE).encode!(::Encoding::UTF_8)
                      when b.size >= 4 && b[0] == 0 && b[2] == 0
-                       JSON.iconv('utf-8', 'utf-16be', b)
+                       source.dup.force_encoding(::Encoding::UTF_16BE).encode!(::Encoding::UTF_8)
                      when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-                       JSON.iconv('utf-8', 'utf-32le', b)
+                       source.dup.force_encoding(::Encoding::UTF_32LE).encode!(::Encoding::UTF_8)
+
                      when b.size >= 4 && b[1] == 0 && b[3] == 0
-                       JSON.iconv('utf-8', 'utf-16le', b)
+                       source.dup.force_encoding(::Encoding::UTF_16LE).encode!(::Encoding::UTF_8)
                      else
-                       b
+                       source.dup
                      end
+          else
+            source = source.encode(::Encoding::UTF_8)
           end
+          source.force_encoding(::Encoding::ASCII_8BIT)
+        else
+          b = source
+          source = case
+                   when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+                     JSON.iconv('utf-8', 'utf-32be', b)
+                   when b.size >= 4 && b[0] == 0 && b[2] == 0
+                     JSON.iconv('utf-8', 'utf-16be', b)
+                   when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+                     JSON.iconv('utf-8', 'utf-32le', b)
+                   when b.size >= 4 && b[1] == 0 && b[3] == 0
+                     JSON.iconv('utf-8', 'utf-16le', b)
+                   else
+                     b
+                   end
+        end
         super source
         if !opts.key?(:max_nesting) # defaults to 19
           @max_nesting = 19
@@ -180,7 +182,7 @@ module JSON
             end
           end
           if string.respond_to?(:force_encoding)
-            string.force_encoding(Encoding::UTF_8)
+            string.force_encoding(::Encoding::UTF_8)
           end
           string
         else

data/lib/json/version.rb

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

data/tests/test_json.rb

@@ -160,6 +160,20 @@ class TC_JSON < Test::Unit::TestCase
 
   class SubArray < Array; end
 
+  class SubArray2 < Array
+    def to_json(*a)
+      {
+        JSON.create_id => self.class.name,
+        'ary'          => to_a,
+      }.to_json(*a)
+    end
+
+    def self.json_create(o)
+      o.delete JSON.create_id
+      o['ary']
+    end
+  end
+
   def test_parse_array_custom_class
     res = parse('[]', :array_class => SubArray)
     assert_equal([], res)
@@ -173,12 +187,52 @@ class TC_JSON < Test::Unit::TestCase
     assert_equal({'foo'=>'bar'}, parse('    { "foo"  :   "bar"   }   '))
   end
 
-  class SubHash < Hash; end
+  class SubHash < Hash
+  end
+
+  class SubHash2 < Hash
+    def to_json(*a)
+      {
+        JSON.create_id => self.class.name,
+      }.merge(self).to_json(*a)
+    end
+
+    def self.json_create(o)
+      o.delete JSON.create_id
+      self[o]
+    end
+  end
 
   def test_parse_object_custom_class
-    res = parse('{}', :object_class => SubHash)
+    res = parse('{}', :object_class => SubHash2)
     assert_equal({}, res)
-    assert_equal(SubHash, res.class)
+    assert_equal(SubHash2, res.class)
+  end
+
+  def test_generation_of_core_subclasses_with_new_to_json
+    obj = SubHash2["foo" => SubHash2["bar" => true]]
+    obj_json = JSON(obj)
+    obj_again = JSON(obj_json)
+    assert_kind_of SubHash2, obj_again
+    assert_kind_of SubHash2, obj_again['foo']
+    assert obj_again['foo']['bar']
+    assert_equal obj, obj_again
+    assert_equal ["foo"], JSON(JSON(SubArray2["foo"]))
+  end
+
+  def test_generation_of_core_subclasses_with_default_to_json
+    assert_equal '{"foo":"bar"}', JSON(SubHash["foo" => "bar"])
+    assert_equal '["foo"]', JSON(SubArray["foo"])
+  end
+
+  def test_generation_of_core_subclasses
+    obj = SubHash["foo" => SubHash["bar" => true]]
+    obj_json = JSON(obj)
+    obj_again = JSON(obj_json)
+    assert_kind_of Hash, obj_again
+    assert_kind_of Hash, obj_again['foo']
+    assert obj_again['foo']['bar']
+    assert_equal obj, obj_again
   end
 
   def test_parser_reset
@@ -324,4 +378,17 @@ EOT
     JSON.dump(eval(too_deep), output, 20)
     assert_equal too_deep, output.string
   end
+
+  def test_big_integers
+    json1 = JSON([orig = (1 << 31) - 1])
+    assert_equal orig, JSON[json1][0]
+    json2 = JSON([orig = 1 << 31])
+    assert_equal orig, JSON[json2][0]
+    json3 = JSON([orig = (1 << 62) - 1])
+    assert_equal orig, JSON[json3][0]
+    json4 = JSON([orig = 1 << 62])
+    assert_equal orig, JSON[json4][0]
+    json5 = JSON([orig = 1 << 64])
+    assert_equal orig, JSON[json5][0]
+  end
 end

data/tests/test_json_addition.rb

@@ -151,12 +151,12 @@ class TC_JSONAddition < Test::Unit::TestCase
   def test_utc_datetime
     now = Time.now
     d = DateTime.parse(now.to_s)                    # usual case
-    assert d, JSON.parse(d.to_json)
+    assert_equal d, JSON.parse(d.to_json)
     d = DateTime.parse(now.utc.to_s)                # of = 0
-    assert d, JSON.parse(d.to_json)
-    d = DateTime.civil(2008, 6, 17, 11, 48, 32, 1)  # of = 1 / 12 => 1/12
-    assert d, JSON.parse(d.to_json)
-    d = DateTime.civil(2008, 6, 17, 11, 48, 32, 12) # of = 12 / 12 => 12
-    assert d, JSON.parse(d.to_json)
+    assert_equal d, JSON.parse(d.to_json)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(1,24))
+    assert_equal d, JSON.parse(d.to_json)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(12,24))
+    assert_equal d, JSON.parse(d.to_json)
   end
 end