json 1.8.2 → 2.3.1

data/Rakefile

@@ -23,12 +23,13 @@ class UndocumentedTestTask < Rake::TestTask
   def desc(*) end
 end
 
-def skip_sdoc(src)
-  src.gsub(/^.*sdoc.*/) { |s| s + ' if RUBY_VERSION > "1.8.6"' }
-end
+which = lambda { |c|
+  w = `which #{c}`
+  break w.chomp unless w.empty?
+}
 
-MAKE   = ENV['MAKE']   || %w[gmake make].find { |c| system(c, '-v') }
-BUNDLE = ENV['BUNDLE'] || %w[bundle].find { |c| system(c, '-v') }
+MAKE   = ENV['MAKE']   || %w[gmake make].find(&which)
+BUNDLE = ENV['BUNDLE'] || %w[bundle].find(&which)
 PKG_NAME          = 'json'
 PKG_TITLE         = 'JSON Implementation for Ruby'
 PKG_VERSION       = File.read('VERSION').chomp
@@ -51,8 +52,8 @@ JAVA_CLASSES        = []
 JRUBY_PARSER_JAR    = File.expand_path("lib/json/ext/parser.jar")
 JRUBY_GENERATOR_JAR = File.expand_path("lib/json/ext/generator.jar")
 
-RAGEL_CODEGEN     = %w[rlcodegen rlgen-cd ragel].find { |c| system(c, '-v') }
-RAGEL_DOTGEN      = %w[rlgen-dot rlgen-cd ragel].find { |c| system(c, '-v') }
+RAGEL_CODEGEN     = %w[rlcodegen rlgen-cd ragel].find(&which)
+RAGEL_DOTGEN      = %w[rlgen-dot rlgen-cd ragel].find(&which)
 
 desc "Installing library (pure)"
 task :install_pure => :version do
@@ -77,90 +78,12 @@ task :install_ext => [ :compile, :install_pure, :install_ext_really ]
 desc "Installing library (extension)"
 task :install => :install_ext
 
-if defined?(Gem) and defined?(Gem::PackageTask)
-  spec_pure = Gem::Specification.new do |s|
-    s.name = 'json_pure'
-    s.version = PKG_VERSION
-    s.summary = PKG_TITLE
-    s.description = "This is a JSON implementation in pure Ruby."
-
-    s.files = PKG_FILES
-
-    s.require_path = 'lib'
-    s.add_development_dependency 'permutation'
-    s.add_development_dependency 'sdoc', '~>0.3.16'
-    s.add_development_dependency 'rake', '~>0.9.2'
-
-    s.extra_rdoc_files << 'README.rdoc'
-    s.rdoc_options <<
-      '--title' <<  'JSON implemention for ruby' << '--main' << 'README.rdoc'
-    s.test_files.concat Dir['./tests/test_*.rb']
-
-    s.author = "Florian Frank"
-    s.email = "flori@ping.de"
-    s.homepage = "http://flori.github.com/#{PKG_NAME}"
-    s.license = 'Ruby'
-  end
-
-  desc 'Creates a json_pure.gemspec file'
-  task :gemspec_pure => :version do
-    File.open('json_pure.gemspec', 'w') do |gemspec|
-      gemspec.write skip_sdoc(spec_pure.to_ruby)
-    end
-  end
-
-  Gem::PackageTask.new(spec_pure) do |pkg|
-      pkg.need_tar = true
-      pkg.package_files = PKG_FILES
-  end
-
-  spec_ext = Gem::Specification.new do |s|
-    s.name = 'json'
-    s.version = PKG_VERSION
-    s.summary = PKG_TITLE
-    s.description = "This is a JSON implementation as a Ruby extension in C."
-
-    s.files = PKG_FILES
-
-    s.extensions = FileList['ext/**/extconf.rb']
-
-    s.require_path = 'lib'
-    s.add_development_dependency 'permutation'
-    s.add_development_dependency 'sdoc', '~>0.3.16'
-
-    s.extra_rdoc_files << 'README.rdoc'
-    s.rdoc_options <<
-      '--title' <<  'JSON implemention for Ruby' << '--main' << 'README.rdoc'
-    s.test_files.concat Dir['./tests/test_*.rb']
-
-    s.author = "Florian Frank"
-    s.email = "flori@ping.de"
-    s.homepage = "http://flori.github.com/#{PKG_NAME}"
-    s.license = 'Ruby'
-  end
-
-  desc 'Creates a json.gemspec file'
-  task :gemspec_ext => :version do
-    File.open('json.gemspec', 'w') do |gemspec|
-      gemspec.write skip_sdoc(spec_ext.to_ruby)
-    end
-  end
-
-  Gem::PackageTask.new(spec_ext) do |pkg|
-    pkg.need_tar      = true
-    pkg.package_files = PKG_FILES
-  end
-
-
-  desc 'Create all gemspec files'
-  task :gemspec => [ :gemspec_pure, :gemspec_ext ]
-end
-
 desc m = "Writing version information for #{PKG_VERSION}"
 task :version do
   puts m
   File.open(File.join('lib', 'json', 'version.rb'), 'w') do |v|
     v.puts <<EOT
+# frozen_string_literal: false
 module JSON
   # JSON version
   VERSION         = '#{PKG_VERSION}'
@@ -173,22 +96,24 @@ EOT
   end
 end
 
+task :check_env do
+  ENV.key?('JSON') or fail "JSON env var is required"
+end
+
 desc "Testing library (pure ruby)"
-task :test_pure => [ :clean, :do_test_pure ]
+task :test_pure => [ :set_env_pure, :check_env, :do_test_pure ]
+task(:set_env_pure) { ENV['JSON'] = 'pure' }
 
 UndocumentedTestTask.new do |t|
   t.name = 'do_test_pure'
-  t.libs << 'lib'
-  t.test_files = FileList['tests/test_*.rb']
+  t.libs << 'lib' << 'tests'
+  t.test_files = FileList['tests/*_test.rb']
   t.verbose = true
   t.options = '-v'
 end
 
 desc "Testing library (pure ruby and extension)"
-task :test do
-  sh "env JSON=pure #{BUNDLE} exec rake test_pure" or exit 1
-  sh "env JSON=ext #{BUNDLE} exec rake test_ext"  or exit 1
-end
+task :test => [ :test_pure, :test_ext ]
 
 namespace :gems do
   desc 'Install all development gems'
@@ -198,13 +123,11 @@ namespace :gems do
 end
 
 if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
-  if ENV.key?('JAVA_HOME')
-    warn " *** JAVA_HOME was set to #{ENV['JAVA_HOME'].inspect}"
-  elsif File.directory?(local_java = '/usr/local/java/jdk') ||
-    File.directory?(local_java = '/usr/lib/jvm/java-6-openjdk')
-  then
-    ENV['JAVA_HOME'] = local_java
-  end
+  ENV['JAVA_HOME'] ||= [
+    '/usr/local/java/jdk',
+    '/usr/lib/jvm/java-6-openjdk',
+    '/Library/Java/Home',
+  ].find { |c| File.directory?(c) }
   if ENV['JAVA_HOME']
     warn " *** JAVA_HOME is set to #{ENV['JAVA_HOME'].inspect}"
     ENV['PATH'] = ENV['PATH'].split(/:/).unshift(java_path = "#{ENV['JAVA_HOME']}/bin") * ':'
@@ -238,7 +161,7 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
       classpath = (Dir['java/lib/*.jar'] << 'java/src' << JRUBY_JAR) * ':'
       obj = src.sub(/\.java\Z/, '.class')
       file obj => src do
-        sh 'javac', '-classpath', classpath, '-source', '1.5', '-target', '1.5', src
+        sh 'javac', '-classpath', classpath, '-source', '1.6', '-target', '1.6', src
       end
       JAVA_CLASSES << obj
     end
@@ -257,12 +180,13 @@ if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
   end
 
   desc "Testing library (jruby)"
-  task :test_ext => [ :create_jar, :do_test_ext ]
+  task :test_ext => [ :set_env_ext, :create_jar, :check_env, :do_test_ext ]
+  task(:set_env_ext) { ENV['JSON'] = 'ext' }
 
   UndocumentedTestTask.new do |t|
     t.name = 'do_test_ext'
-    t.libs << 'lib'
-    t.test_files = FileList['tests/test_*.rb']
+    t.libs << 'lib' << 'tests'
+    t.test_files = FileList['tests/*_test.rb']
     t.verbose = true
     t.options = '-v'
   end
@@ -331,21 +255,16 @@ else
   end
 
   desc "Testing library (extension)"
-  task :test_ext => [ :compile, :do_test_ext ]
+  task :test_ext => [ :check_env, :compile, :do_test_ext ]
 
   UndocumentedTestTask.new do |t|
     t.name = 'do_test_ext'
-    t.libs << 'ext' << 'lib'
-    t.test_files = FileList['tests/test_*.rb']
+    t.libs << 'ext' << 'lib' << 'tests'
+    t.test_files = FileList['tests/*_test.rb']
     t.verbose = true
     t.options = '-v'
   end
 
-  desc "Create RDOC documentation"
-  task :doc => [ :version, EXT_PARSER_SRC ] do
-    sh "sdoc -o doc -t '#{PKG_TITLE}' -m README.rdoc README.rdoc lib/json.rb #{FileList['lib/json/**/*.rb']} #{EXT_PARSER_SRC} #{EXT_GENERATOR_SRC}"
-  end
-
   desc "Generate parser with ragel"
   task :ragel => EXT_PARSER_SRC
 
@@ -367,6 +286,9 @@ else
         sh "ragel -x parser.rl | #{RAGEL_CODEGEN} -G2"
       end
       src = File.read("parser.c").gsub(/[ \t]+$/, '')
+      src.gsub!(/^static const int (JSON_.*=.*);$/, 'enum {\1};')
+      src.gsub!(/0 <= \(\*p\) && \(\*p\) <= 31/, "0 <= (signed char)(*p) && (*p) <= 31")
+      src[0, 0] = "/* This file is automatically generated from parser.rl by using ragel */"
       File.open("parser.c", "w") {|f| f.print src}
     end
   end
@@ -409,4 +331,4 @@ else
 end
 
 desc "Compile in the the source directory"
-task :default => [ :clean, :gemspec, :test ]
+task :default => [ :clean, :test ]

data/VERSION

@@ -1 +1 @@
-1.8.2
+2.3.1

data/ext/json/ext/fbuffer/fbuffer.h

@@ -12,9 +12,6 @@
 #define RFLOAT_VALUE(val) (RFLOAT(val)->value)
 #endif
 
-#ifndef RARRAY_PTR
-#define RARRAY_PTR(ARRAY) RARRAY(ARRAY)->ptr
-#endif
 #ifndef RARRAY_LEN
 #define RARRAY_LEN(ARRAY) RARRAY(ARRAY)->len
 #endif

data/ext/json/ext/generator/generator.c

@@ -7,14 +7,20 @@ static ID i_encoding, i_encode;
 #endif
 
 static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,
-             mHash, mArray, mFixnum, mBignum, mFloat, mString, mString_Extend,
+             mHash, mArray,
+#ifdef RUBY_INTEGER_UNIFICATION
+             mInteger,
+#else
+             mFixnum, mBignum,
+#endif
+             mFloat, mString, mString_Extend,
              mTrueClass, mFalseClass, mNilClass, eGeneratorError,
-             eNestingError, CRegexp_MULTILINE, CJSON_SAFE_STATE_PROTOTYPE,
+             eNestingError,
              i_SAFE_STATE_PROTOTYPE;
 
 static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
           i_object_nl, i_array_nl, i_max_nesting, i_allow_nan, i_ascii_only,
-          i_quirks_mode, i_pack, i_unpack, i_create_id, i_extend, i_key_p,
+          i_pack, i_unpack, i_create_id, i_extend, i_key_p,
           i_aref, i_send, i_respond_to_p, i_match, i_keys, i_depth,
           i_buffer_initial_length, i_dup;
 
@@ -216,6 +222,7 @@ static void convert_UTF8_to_JSON_ASCII(FBuffer *buffer, VALUE string)
             unicode_escape_to_buffer(buffer, buf, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START));
         }
     }
+    RB_GC_GUARD(string);
 }
 
 /* Converts string to a JSON string in FBuffer buffer, where only the
@@ -230,6 +237,7 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
     int escape_len;
     unsigned char c;
     char buf[6] = { '\\', 'u' };
+    int ascii_only = rb_enc_str_asciionly_p(string);
 
     for (start = 0, end = 0; end < len;) {
         p = ptr + end;
@@ -274,14 +282,17 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
                     break;
                 default:
                     {
-                        unsigned short clen = trailingBytesForUTF8[c] + 1;
-                        if (end + clen > len) {
-                            rb_raise(rb_path2class("JSON::GeneratorError"),
-                                    "partial character in source, but hit end");
-                        }
-                        if (!isLegalUTF8((UTF8 *) p, clen)) {
-                            rb_raise(rb_path2class("JSON::GeneratorError"),
-                                    "source sequence is illegal/malformed utf-8");
+                        unsigned short clen = 1;
+                        if (!ascii_only) {
+                            clen += trailingBytesForUTF8[c];
+                            if (end + clen > len) {
+                                rb_raise(rb_path2class("JSON::GeneratorError"),
+                                        "partial character in source, but hit end");
+                            }
+                            if (!isLegalUTF8((UTF8 *) p, clen)) {
+                                rb_raise(rb_path2class("JSON::GeneratorError"),
+                                        "source sequence is illegal/malformed utf-8");
+                            }
                         }
                         end += clen;
                     }
@@ -301,7 +312,7 @@ static char *fstrndup(const char *ptr, unsigned long len) {
   char *result;
   if (len <= 0) return NULL;
   result = ALLOC_N(char, len);
-  memccpy(result, ptr, 0, len);
+  memcpy(result, ptr, len);
   return result;
 }
 
@@ -317,6 +328,76 @@ static char *fstrndup(const char *ptr, unsigned long len) {
  *
  */
 
+/* Explanation of the following: that's the only way to not pollute
+ * standard library's docs with GeneratorMethods::<ClassName> which
+ * are uninformative and take a large place in a list of classes
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Array
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Bignum
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::FalseClass
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Fixnum
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Float
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Hash
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Integer
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::NilClass
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::Object
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::String
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::String::Extend
+ * :nodoc:
+ */
+
+/*
+ * Document-module: JSON::Ext::Generator::GeneratorMethods::TrueClass
+ * :nodoc:
+ */
+
 /*
  * call-seq: to_json(state = nil)
  *
@@ -342,6 +423,18 @@ static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
     GENERATE_JSON(array);
 }
 
+#ifdef RUBY_INTEGER_UNIFICATION
+/*
+ * call-seq: to_json(*)
+ *
+ * Returns a JSON string representation for this Integer number.
+ */
+static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
+{
+    GENERATE_JSON(integer);
+}
+
+#else
 /*
  * call-seq: to_json(*)
  *
@@ -361,6 +454,7 @@ static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self)
 {
     GENERATE_JSON(bignum);
 }
+#endif
 
 /*
  * call-seq: to_json(*)
@@ -526,17 +620,11 @@ static const rb_data_type_t JSON_Generator_State_type = {
 };
 #endif
 
-static JSON_Generator_State *State_allocate(void)
-{
-    JSON_Generator_State *state = ALLOC(JSON_Generator_State);
-    MEMZERO(state, JSON_Generator_State, 1);
-    return state;
-}
-
 static VALUE cState_s_allocate(VALUE klass)
 {
-    JSON_Generator_State *state = State_allocate();
-    return TypedData_Wrap_Struct(klass, &JSON_Generator_State_type, state);
+    JSON_Generator_State *state;
+    return TypedData_Make_Struct(klass, JSON_Generator_State,
+				 &JSON_Generator_State_type, state);
 }
 
 /*
@@ -628,8 +716,6 @@ static VALUE cState_configure(VALUE self, VALUE opts)
     state->allow_nan = RTEST(tmp);
     tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
     state->ascii_only = RTEST(tmp);
-    tmp = rb_hash_aref(opts, ID2SYM(i_quirks_mode));
-    state->quirks_mode = RTEST(tmp);
     return self;
 }
 
@@ -663,7 +749,6 @@ static VALUE cState_to_h(VALUE self)
     rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len));
     rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse);
-    rb_hash_aset(result, ID2SYM(i_quirks_mode), state->quirks_mode ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
     rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth));
     rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length));
@@ -681,7 +766,7 @@ static VALUE cState_aref(VALUE self, VALUE name)
     if (RTEST(rb_funcall(self, i_respond_to_p, 1, name))) {
         return rb_funcall(self, i_send, 1, name);
     } else {
-        return rb_ivar_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
+        return rb_attr_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
     }
 }
 
@@ -704,43 +789,83 @@ static VALUE cState_aset(VALUE self, VALUE name, VALUE value)
     return Qnil;
 }
 
-static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+struct hash_foreach_arg {
+    FBuffer *buffer;
+    JSON_Generator_State *state;
+    VALUE Vstate;
+    int iter;
+};
+
+static int
+json_object_i(VALUE key, VALUE val, VALUE _arg)
 {
+    struct hash_foreach_arg *arg = (struct hash_foreach_arg *)_arg;
+    FBuffer *buffer = arg->buffer;
+    JSON_Generator_State *state = arg->state;
+    VALUE Vstate = arg->Vstate;
+
     char *object_nl = state->object_nl;
     long object_nl_len = state->object_nl_len;
     char *indent = state->indent;
     long indent_len = state->indent_len;
-    long max_nesting = state->max_nesting;
     char *delim = FBUFFER_PTR(state->object_delim);
     long delim_len = FBUFFER_LEN(state->object_delim);
     char *delim2 = FBUFFER_PTR(state->object_delim2);
     long delim2_len = FBUFFER_LEN(state->object_delim2);
+    long depth = state->depth;
+    int j;
+    VALUE klass, key_to_s;
+
+    if (arg->iter > 0) fbuffer_append(buffer, delim, delim_len);
+    if (object_nl) {
+        fbuffer_append(buffer, object_nl, object_nl_len);
+    }
+    if (indent) {
+        for (j = 0; j < depth; j++) {
+            fbuffer_append(buffer, indent, indent_len);
+        }
+    }
+
+    klass = CLASS_OF(key);
+    if (klass == rb_cString) {
+        key_to_s = key;
+    } else if (klass == rb_cSymbol) {
+        key_to_s = rb_id2str(SYM2ID(key));
+    } else {
+        key_to_s = rb_funcall(key, i_to_s, 0);
+    }
+    Check_Type(key_to_s, T_STRING);
+    generate_json(buffer, Vstate, state, key_to_s);
+    fbuffer_append(buffer, delim2, delim2_len);
+    generate_json(buffer, Vstate, state, val);
+
+    arg->iter++;
+    return ST_CONTINUE;
+}
+
+static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    char *object_nl = state->object_nl;
+    long object_nl_len = state->object_nl_len;
+    char *indent = state->indent;
+    long indent_len = state->indent_len;
+    long max_nesting = state->max_nesting;
     long depth = ++state->depth;
-    int i, j;
-    VALUE key, key_to_s, keys;
+    int j;
+    struct hash_foreach_arg arg;
+
     if (max_nesting != 0 && depth > max_nesting) {
         fbuffer_free(buffer);
         rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
     }
     fbuffer_append_char(buffer, '{');
-    keys = rb_funcall(obj, i_keys, 0);
-    for(i = 0; i < RARRAY_LEN(keys); i++) {
-        if (i > 0) fbuffer_append(buffer, delim, delim_len);
-        if (object_nl) {
-            fbuffer_append(buffer, object_nl, object_nl_len);
-        }
-        if (indent) {
-            for (j = 0; j < depth; j++) {
-                fbuffer_append(buffer, indent, indent_len);
-            }
-        }
-        key = rb_ary_entry(keys, i);
-        key_to_s = rb_funcall(key, i_to_s, 0);
-        Check_Type(key_to_s, T_STRING);
-        generate_json(buffer, Vstate, state, key_to_s);
-        fbuffer_append(buffer, delim2, delim2_len);
-        generate_json(buffer, Vstate, state, rb_hash_aref(obj, key));
-    }
+
+    arg.buffer = buffer;
+    arg.state = state;
+    arg.Vstate = Vstate;
+    arg.iter = 0;
+    rb_hash_foreach(obj, json_object_i, (VALUE)&arg);
+
     depth = --state->depth;
     if (object_nl) {
         fbuffer_append(buffer, object_nl, object_nl_len);
@@ -791,11 +916,22 @@ static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_St
     fbuffer_append_char(buffer, ']');
 }
 
+#ifdef HAVE_RUBY_ENCODING_H
+static int enc_utf8_compatible_p(rb_encoding *enc)
+{
+    if (enc == rb_usascii_encoding()) return 1;
+    if (enc == rb_utf8_encoding()) return 1;
+    return 0;
+}
+#endif
+
 static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
 {
     fbuffer_append_char(buffer, '"');
 #ifdef HAVE_RUBY_ENCODING_H
-    obj = rb_funcall(obj, i_encode, 1, CEncoding_UTF_8);
+    if (!enc_utf8_compatible_p(rb_enc_get(obj))) {
+        obj = rb_str_encode(obj, CEncoding_UTF_8, 0, Qnil);
+    }
 #endif
     if (state->ascii_only) {
         convert_UTF8_to_JSON_ASCII(buffer, obj);
@@ -831,6 +967,15 @@ static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_S
     fbuffer_append_str(buffer, tmp);
 }
 
+#ifdef RUBY_INTEGER_UNIFICATION
+static void generate_json_integer(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    if (FIXNUM_P(obj))
+        generate_json_fixnum(buffer, Vstate, state, obj);
+    else
+        generate_json_bignum(buffer, Vstate, state, obj);
+}
+#endif
 static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
 {
     double value = RFLOAT_VALUE(obj);
@@ -864,9 +1009,9 @@ static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *s
         generate_json_false(buffer, Vstate, state, obj);
     } else if (obj == Qtrue) {
         generate_json_true(buffer, Vstate, state, obj);
-    } else if (klass == rb_cFixnum) {
+    } else if (FIXNUM_P(obj)) {
         generate_json_fixnum(buffer, Vstate, state, obj);
-    } else if (klass == rb_cBignum) {
+    } else if (RB_TYPE_P(obj, T_BIGNUM)) {
         generate_json_bignum(buffer, Vstate, state, obj);
     } else if (klass == rb_cFloat) {
         generate_json_float(buffer, Vstate, state, obj);
@@ -877,7 +1022,7 @@ static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *s
     } else {
         tmp = rb_funcall(obj, i_to_s, 0);
         Check_Type(tmp, T_STRING);
-        generate_json(buffer, Vstate, state, tmp);
+        generate_json_string(buffer, Vstate, state, tmp);
     }
 }
 
@@ -920,21 +1065,6 @@ static VALUE cState_partial_generate(VALUE self, VALUE obj)
     return fbuffer_to_s(buffer);
 }
 
-/*
- * This function returns true if string is either a JSON array or JSON object.
- * It might suffer from false positives, e. g. syntactically incorrect JSON in
- * the string or certain UTF-8 characters on the right hand side.
- */
-static int isArrayOrObject(VALUE string)
-{
-    long string_len = RSTRING_LEN(string);
-    char *p = RSTRING_PTR(string), *q = p + string_len - 1;
-    if (string_len < 2) return 0;
-    for (; p < q && isspace((unsigned char)*p); p++);
-    for (; q > p && isspace((unsigned char)*q); q--);
-    return (*p == '[' && *q == ']') || (*p == '{' && *q == '}');
-}
-
 /*
  * call-seq: generate(obj)
  *
@@ -946,9 +1076,7 @@ static VALUE cState_generate(VALUE self, VALUE obj)
 {
     VALUE result = cState_partial_generate(self, obj);
     GET_STATE(self);
-    if (!state->quirks_mode && !isArrayOrObject(result)) {
-        rb_raise(eGeneratorError, "only generation of JSON objects or arrays allowed");
-    }
+    (void)state;
     return result;
 }
 
@@ -967,8 +1095,8 @@ static VALUE cState_generate(VALUE self, VALUE obj)
  * * *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.
- * * *quirks_mode*: Enables quirks_mode for parser, that is for example
- *   generating single JSON values instead of documents is possible.
+ * * *ascii_only*: true if only ASCII characters should be generated. This
+ *   option defaults to false.
  * * *buffer_initial_length*: sets the initial length of the generator's
  *   internal buffer.
  */
@@ -1024,10 +1152,8 @@ static VALUE cState_from_state_s(VALUE self, VALUE opts)
     } else if (rb_obj_is_kind_of(opts, rb_cHash)) {
         return rb_funcall(self, i_new, 1, opts);
     } else {
-        if (NIL_P(CJSON_SAFE_STATE_PROTOTYPE)) {
-            CJSON_SAFE_STATE_PROTOTYPE = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
-        }
-        return rb_funcall(CJSON_SAFE_STATE_PROTOTYPE, i_dup, 0);
+        VALUE prototype = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
+        return rb_funcall(prototype, i_dup, 0);
     }
 }
 
@@ -1061,7 +1187,7 @@ static VALUE cState_indent_set(VALUE self, VALUE indent)
         }
     } else {
         if (state->indent) ruby_xfree(state->indent);
-        state->indent = strdup(RSTRING_PTR(indent));
+        state->indent = fstrndup(RSTRING_PTR(indent), len);
         state->indent_len = len;
     }
     return Qnil;
@@ -1099,7 +1225,7 @@ static VALUE cState_space_set(VALUE self, VALUE space)
         }
     } else {
         if (state->space) ruby_xfree(state->space);
-        state->space = strdup(RSTRING_PTR(space));
+        state->space = fstrndup(RSTRING_PTR(space), len);
         state->space_len = len;
     }
     return Qnil;
@@ -1135,7 +1261,7 @@ static VALUE cState_space_before_set(VALUE self, VALUE space_before)
         }
     } else {
         if (state->space_before) ruby_xfree(state->space_before);
-        state->space_before = strdup(RSTRING_PTR(space_before));
+        state->space_before = fstrndup(RSTRING_PTR(space_before), len);
         state->space_before_len = len;
     }
     return Qnil;
@@ -1172,7 +1298,7 @@ static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
         }
     } else {
         if (state->object_nl) ruby_xfree(state->object_nl);
-        state->object_nl = strdup(RSTRING_PTR(object_nl));
+        state->object_nl = fstrndup(RSTRING_PTR(object_nl), len);
         state->object_nl_len = len;
     }
     return Qnil;
@@ -1207,7 +1333,7 @@ static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
         }
     } else {
         if (state->array_nl) ruby_xfree(state->array_nl);
-        state->array_nl = strdup(RSTRING_PTR(array_nl));
+        state->array_nl = fstrndup(RSTRING_PTR(array_nl), len);
         state->array_nl_len = len;
     }
     return Qnil;
@@ -1266,7 +1392,7 @@ static VALUE cState_allow_nan_p(VALUE self)
 /*
  * call-seq: ascii_only?
  *
- * Returns true, if NaN, Infinity, and -Infinity should be generated, otherwise
+ * Returns true, if only ASCII characters should be generated. Otherwise
  * returns false.
  */
 static VALUE cState_ascii_only_p(VALUE self)
@@ -1275,29 +1401,6 @@ static VALUE cState_ascii_only_p(VALUE self)
     return state->ascii_only ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq: quirks_mode?
- *
- * Returns true, if quirks mode is enabled. Otherwise returns false.
- */
-static VALUE cState_quirks_mode_p(VALUE self)
-{
-    GET_STATE(self);
-    return state->quirks_mode ? Qtrue : Qfalse;
-}
-
-/*
- * call-seq: quirks_mode=(enable)
- *
- * If set to true, enables the quirks_mode mode.
- */
-static VALUE cState_quirks_mode_set(VALUE self, VALUE enable)
-{
-    GET_STATE(self);
-    state->quirks_mode = RTEST(enable);
-    return Qnil;
-}
-
 /*
  * call-seq: depth
  *
@@ -1357,6 +1460,7 @@ static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_l
  */
 void Init_generator(void)
 {
+#undef rb_intern
     rb_require("json/common");
 
     mJSON = rb_define_module("JSON");
@@ -1365,6 +1469,8 @@ void Init_generator(void)
 
     eGeneratorError = rb_path2class("JSON::GeneratorError");
     eNestingError = rb_path2class("JSON::NestingError");
+    rb_gc_register_mark_object(eGeneratorError);
+    rb_gc_register_mark_object(eNestingError);
 
     cState = rb_define_class_under(mGenerator, "State", rb_cObject);
     rb_define_alloc_func(cState, cState_s_allocate);
@@ -1386,9 +1492,6 @@ void Init_generator(void)
     rb_define_method(cState, "check_circular?", cState_check_circular_p, 0);
     rb_define_method(cState, "allow_nan?", cState_allow_nan_p, 0);
     rb_define_method(cState, "ascii_only?", cState_ascii_only_p, 0);
-    rb_define_method(cState, "quirks_mode?", cState_quirks_mode_p, 0);
-    rb_define_method(cState, "quirks_mode", cState_quirks_mode_p, 0);
-    rb_define_method(cState, "quirks_mode=", cState_quirks_mode_set, 1);
     rb_define_method(cState, "depth", cState_depth, 0);
     rb_define_method(cState, "depth=", cState_depth_set, 1);
     rb_define_method(cState, "buffer_initial_length", cState_buffer_initial_length, 0);
@@ -1408,10 +1511,15 @@ void Init_generator(void)
     rb_define_method(mHash, "to_json", mHash_to_json, -1);
     mArray = rb_define_module_under(mGeneratorMethods, "Array");
     rb_define_method(mArray, "to_json", mArray_to_json, -1);
+#ifdef RUBY_INTEGER_UNIFICATION
+    mInteger = rb_define_module_under(mGeneratorMethods, "Integer");
+    rb_define_method(mInteger, "to_json", mInteger_to_json, -1);
+#else
     mFixnum = rb_define_module_under(mGeneratorMethods, "Fixnum");
     rb_define_method(mFixnum, "to_json", mFixnum_to_json, -1);
     mBignum = rb_define_module_under(mGeneratorMethods, "Bignum");
     rb_define_method(mBignum, "to_json", mBignum_to_json, -1);
+#endif
     mFloat = rb_define_module_under(mGeneratorMethods, "Float");
     rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
     mString = rb_define_module_under(mGeneratorMethods, "String");
@@ -1428,7 +1536,6 @@ void Init_generator(void)
     mNilClass = rb_define_module_under(mGeneratorMethods, "NilClass");
     rb_define_method(mNilClass, "to_json", mNilClass_to_json, -1);
 
-    CRegexp_MULTILINE = rb_const_get(rb_cRegexp, rb_intern("MULTILINE"));
     i_to_s = rb_intern("to_s");
     i_to_json = rb_intern("to_json");
     i_new = rb_intern("new");
@@ -1440,7 +1547,6 @@ void Init_generator(void)
     i_max_nesting = rb_intern("max_nesting");
     i_allow_nan = rb_intern("allow_nan");
     i_ascii_only = rb_intern("ascii_only");
-    i_quirks_mode = rb_intern("quirks_mode");
     i_depth = rb_intern("depth");
     i_buffer_initial_length = rb_intern("buffer_initial_length");
     i_pack = rb_intern("pack");
@@ -1460,5 +1566,4 @@ void Init_generator(void)
     i_encode = rb_intern("encode");
 #endif
     i_SAFE_STATE_PROTOTYPE = rb_intern("SAFE_STATE_PROTOTYPE");
-    CJSON_SAFE_STATE_PROTOTYPE = Qnil;
 }