brianmario-yajl-ruby 0.5.4 → 0.5.5

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.5.5 (June 17th, 2009)
+* Introduction of the JSON gem API compatibility layer
+** NOTE: this isn't a 1:1 compatibility API, the goal was to be compatible with as many of the projects using the JSON gem as possible - not the JSON gem API itself
+** the compatibility API must be explicitly enabled by requiring 'yajl/json_gem' in your project
+** JSON.parse, JSON.generate, and the #to_json instance method extension to ruby's primitive classes are all included
+* Fix Yajl::Encoder to ensure map keys are strings
+* Encoding multiple JSON objects to a single stream doesn't separate by a newline character anymore
+* Yajl::Encoder now checks for the existence of, and will call #to_json on any non-primitive object
+
 ## 0.5.4 (June 16th, 2009)
 * Yajl::Parser's :symbolize_keys option now defaults to false
 * remove use of sprintf for a little speed improvement while parsing

data/README.rdoc

@@ -4,6 +4,19 @@ This gem (although not in gem form just yet) is a C binding to the excellent YAJ
 
 You can read more info at the projects website http://lloydforge.org/projects/yajl or check out it's codes at http://github.com/lloyd/yajl.
 
+== Features
+
+* JSON parsing and encoding directly to and from an IO stream (file, socket, etc) or String. Compressed stream parsing and encoding supported for Bzip2, Gzip and Deflate.
+* Parse and encode *multiple* JSON objects to and from streams or strings continuously.
+* JSON gem compatibility API - allows yajl-ruby to be used as a drop-in replacement for the JSON gem
+* Basic HTTP client (only GET requests supported for now) which parses JSON directly off the response body *as it's being received*
+* ~3.5x faster than JSON.generate
+* ~1.9x faster than JSON.parse
+* ~4.5x faster than YAML.load
+* ~377.5x faster than YAML.dump
+* ~1.5x faster than Marshal.load
+* ~2x faster than Marshal.dump
+
 == How to install
 
 Install it like any other gem hosted at the Githubs like so:
@@ -114,7 +127,7 @@ This allows you to encode JSON as a stream, writing directly to a socket
  socket = TCPSocket.new(192.168.1.101, 9000)
  hash = {:foo => 12425125, :bar => "some string", ... }
  encoder = Yajl::Encoder.new
- Yajl::encoder.encode(hash, socket)
+ Yajl::Encoder.encode(hash, socket)
 
 Or what if you wanted to compress the stream over the wire?
 
@@ -135,7 +148,24 @@ This example will encode and send 50 JSON objects over the same stream, continuo
 
 You can also use Yajl::Bzip2::StreamWriter and Yajl::Deflate::StreamWriter. So you can pick whichever fits your CPU/bandwidth sweet-spot.
 
-There are a lot more possibilities, some of which I'm going to write other gems/plugins for.
+== JSON gem Compatibility API
+
+The JSON gem compatibility API isn't enabled by default. You have to explicitly require it like so:
+
+ require 'yajl/json_gem'
+
+That's right, you can just replace "require 'json'" with the line above and you're done!
+
+This will require yajl-ruby itself, as well as enable it's JSON gem compatibility API.
+
+This includes the following API:
+
+ JSON.parse, JSON.generate, JSON.pretty_generate, JSON.load, JSON.dump
+ and all of the #to_json instance method overrides for Ruby's primitive objects
+
+Once the compatibility API is enabled, you're existing or new project should work as if the JSON gem itself were being used. Only you'll be using Yajl ;)
+
+There are a lot more possibilities that I'd love to see other gems/plugins for someday.
 
 Some ideas are:
 * parsing logs in JSON format
@@ -192,7 +222,7 @@ NOTE: I converted the 2.4MB JSON file to YAML for this test.
 
 * Yajl::Parser#parse: 4.33s
 * JSON.parse: 5.37s
-* YAML.load_stream: 19.47s
+* YAML.load: 19.47s
 
 ==== Encode Time (to their respective formats)
 
@@ -200,6 +230,22 @@ NOTE: I converted the 2.4MB JSON file to YAML for this test.
 * JSON#to_json: 6.6s
 * YAML.dump(obj, io): 1309.93s
 
+=== Compared to Marshal.load/Marshal.dump
+
+NOTE: I converted the 2.4MB JSON file to a Hash and a dump file from Marshal.dump for this test.
+
+==== Parse Time (from their respective formats)
+
+* Yajl::Parser#parse: 4.54s
+* JSON.parse: 7.40s
+* Marshal.load: 7s
+
+==== Encode Time (to their respective formats)
+
+* Yajl::Encoder#encode: 2.39s
+* JSON#to_json: 8.37s
+* Marshal.dump: 4.66s
+
 == Third Party Sources Bundled
 
 This project includes code from the BSD licensed yajl project, copyright 2007-2009 Lloyd Hilaiel

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 5
-:patch: 4
+:patch: 5

data/benchmark/encode_json_and_marshal.rb

@@ -5,12 +5,12 @@ require 'yajl_ext'
 require 'stringio'
 require 'json'
 
-filename = ARGV[0] || 'benchmark/subjects/contacts.json'
+times = ARGV[0] ? ARGV[0].to_i : 1
+filename = 'benchmark/subjects/contacts.json'
 json = File.new(filename, 'r')
 hash = Yajl::Parser.new.parse(json)
 json.close
 
-times = ARGV[1] ? ARGV[1].to_i : 1
 puts "Starting benchmark encoding #{filename} #{times} times\n\n"
 Benchmark.bm { |x|
   encoder = Yajl::Encoder.new

data/benchmark/parse_json_and_marshal.rb

@@ -6,23 +6,26 @@ require 'json'
 
 # JSON section
 filename = 'benchmark/subjects/contacts.json'
+marshal_filename = 'benchmark/subjects/contacts.marshal_dump'
 json = File.new(filename, 'r')
+marshal_file = File.new(marshal_filename, 'r')
 
 # warm up the filesystem
 json.read
 json.rewind
+marshal_file.read
+marshal_file.rewind
 
 hash = {}
 
 times = ARGV[0] ? ARGV[0].to_i : 1
 puts "Starting benchmark parsing #{File.size(filename)} bytes of JSON data #{times} times\n\n"
 Benchmark.bm { |x|
-  parser = Yajl::Parser.new
   x.report {
     puts "Yajl::Parser#parse"
     times.times {
       json.rewind
-      hash = parser.parse(json)
+      hash = Yajl::Parser.new.parse(json)
     }
   }
   x.report {
@@ -32,12 +35,13 @@ Benchmark.bm { |x|
       JSON.parse(json.read, :max_nesting => false)
     }
   }
-  data = Marshal.dump(hash)
   x.report {
     puts "Marshal.load"
     times.times {
-      Marshal.load(data)
+      marshal_file.rewind
+      Marshal.load(marshal_file)
     }
   }
 }
-json.close
+json.close
+marshal_file.close

data/ext/yajl_ext.c

@@ -62,13 +62,13 @@ inline void yajl_set_static_value(void * ctx, VALUE val) {
 
 void yajl_encode_part(yajl_gen hand, VALUE obj, VALUE io) {
     VALUE str, outBuff, otherObj;
-    int objLen;
+    yajl_gen_status status;
     int idx = 0;
     const unsigned char * buffer;
     unsigned int len;
     
     if (io != Qnil) {
-        yajl_gen_get_buf(hand, &buffer, &len);
+        status = yajl_gen_get_buf(hand, &buffer, &len);
         if (len >= WRITE_BUFSIZE) {
             outBuff = rb_str_new((const char *)buffer, len);
             rb_io_write(io, outBuff);
@@ -78,49 +78,55 @@ void yajl_encode_part(yajl_gen hand, VALUE obj, VALUE io) {
     
     switch (TYPE(obj)) {
         case T_HASH:
-            yajl_gen_map_open(hand);
+            status = yajl_gen_map_open(hand);
             
             // TODO: itterate through keys in the hash
             VALUE keys = rb_funcall(obj, intern_keys, 0);
-            VALUE entry;
+            VALUE entry, keyStr;
             for(idx=0; idx<RARRAY_LEN(keys); idx++) {
                 entry = rb_ary_entry(keys, idx);
+                keyStr = rb_funcall(entry, intern_to_s, 0); // key must be a string
                 // the key
-                yajl_encode_part(hand, entry, io);
+                yajl_encode_part(hand, keyStr, io);
                 // the value
                 yajl_encode_part(hand, rb_hash_aref(obj, entry), io);
             }
             
-            yajl_gen_map_close(hand);
+            status = yajl_gen_map_close(hand);
             break;
         case T_ARRAY:
-            yajl_gen_array_open(hand);
+            status = yajl_gen_array_open(hand);
             for(idx=0; idx<RARRAY_LEN(obj); idx++) {
                 otherObj = rb_ary_entry(obj, idx);
                 yajl_encode_part(hand, otherObj, io);
             }
-            yajl_gen_array_close(hand);
+            status = yajl_gen_array_close(hand);
             break;
         case T_NIL:
-            yajl_gen_null(hand);
+            status = yajl_gen_null(hand);
             break;
         case T_TRUE:
-            yajl_gen_bool(hand, 1);
+            status = yajl_gen_bool(hand, 1);
             break;
         case T_FALSE:
-            yajl_gen_bool(hand, 0);
+            status = yajl_gen_bool(hand, 0);
             break;
         case T_FIXNUM:
         case T_FLOAT:
         case T_BIGNUM:
             str = rb_funcall(obj, intern_to_s, 0);
-            objLen = RSTRING_LEN(str);
-            yajl_gen_number(hand, RSTRING_PTR(str), (unsigned int)objLen);
+            status = yajl_gen_number(hand, RSTRING_PTR(str), (unsigned int)RSTRING_LEN(str));
+            break;
+        case T_STRING:
+            status = yajl_gen_string(hand, (const unsigned char *)RSTRING_PTR(obj), (unsigned int)RSTRING_LEN(obj));
             break;
         default:
-            str = rb_funcall(obj, intern_to_s, 0);
-            objLen = RSTRING_LEN(str);
-            yajl_gen_string(hand, (const unsigned char *)RSTRING_PTR(str), (unsigned int)objLen);
+            if (rb_respond_to(obj, intern_to_json)) {
+                str = rb_funcall(obj, intern_to_json, 0);
+            } else {
+                str = rb_funcall(obj, intern_to_s, 0);
+            }
+            status = yajl_gen_string(hand, (const unsigned char *)RSTRING_PTR(str), (unsigned int)RSTRING_LEN(str));
             break;
     }
 }
@@ -515,13 +521,228 @@ static VALUE rb_yajl_encoder_encode(int argc, VALUE * argv, VALUE self) {
     return Qnil;
 }
 
+
+// JSON Gem compatibility
+
+/*
+ * Document-class: Object
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of Object to JSON
+ */
+static VALUE rb_yajl_json_ext_object_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: Hash
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of Hash to JSON
+ */
+static VALUE rb_yajl_json_ext_hash_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: Array
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of Array to JSON
+ */
+static VALUE rb_yajl_json_ext_array_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: Fixnum
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of Fixnum to JSON
+ */
+static VALUE rb_yajl_json_ext_fixnum_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: Float
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of Float to JSON
+ */
+static VALUE rb_yajl_json_ext_float_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: String
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of TrueClass to JSON
+ */
+static VALUE rb_yajl_json_ext_string_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: TrueClass
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of TrueClass to JSON
+ */
+static VALUE rb_yajl_json_ext_true_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: FalseClass
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of FalseClass to JSON
+ */
+static VALUE rb_yajl_json_ext_false_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: NilClass
+ */
+/*
+ * Document-method: to_json
+ *
+ * call-seq: to_json(encoder=Yajl::Encoder.new)
+ *
+ * +encoder+ is an existing Yajl::Encoder used to encode JSON
+ *
+ * Encodes an instance of NilClass to JSON
+ */
+static VALUE rb_yajl_json_ext_nil_to_json(int argc, VALUE * argv, VALUE self) {
+    VALUE rb_encoder;
+    rb_scan_args(argc, argv, "01", &rb_encoder);
+    if (rb_encoder == Qnil) {
+        rb_encoder = rb_yajl_encoder_new(0, NULL, cEncoder);
+    }
+    return rb_yajl_encoder_encode(1, &self, rb_encoder);
+}
+
+/*
+ * Document-class: Yajl::Encoder
+ */
+/*
+ * Document-method: enable_json_gem_compatability
+ *
+ * call-seq: enable_json_gem_compatability
+ *
+ * Enables the JSON gem compatibility API
+ */
+static VALUE rb_yajl_encoder_enable_json_gem_ext(VALUE klass) {
+    rb_define_method(rb_cObject, "to_json", rb_yajl_json_ext_object_to_json, -1);
+    rb_define_method(rb_cHash, "to_json", rb_yajl_json_ext_hash_to_json, -1);
+    rb_define_method(rb_cArray, "to_json", rb_yajl_json_ext_array_to_json, -1);
+    rb_define_method(rb_cFixnum, "to_json", rb_yajl_json_ext_fixnum_to_json, -1);
+    rb_define_method(rb_cFloat, "to_json", rb_yajl_json_ext_float_to_json, -1);
+    rb_define_method(rb_cString, "to_json", rb_yajl_json_ext_string_to_json, -1);
+    rb_define_method(rb_cTrueClass, "to_json", rb_yajl_json_ext_true_to_json, -1);
+    rb_define_method(rb_cFalseClass, "to_json", rb_yajl_json_ext_false_to_json, -1);
+    rb_define_method(rb_cNilClass, "to_json", rb_yajl_json_ext_nil_to_json, -1);
+    return Qnil;
+}
+
+
 // Ruby Extension initializer
 void Init_yajl_ext() {
     mYajl = rb_define_module("Yajl");
     
-    VALUE rb_cStandardError = rb_const_get(rb_cObject, rb_intern("StandardError"));
-    cParseError = rb_define_class_under(mYajl, "ParseError", rb_cStandardError);
-    cEncodeError = rb_define_class_under(mYajl, "EncodeError", rb_cStandardError);
+    cParseError = rb_define_class_under(mYajl, "ParseError", rb_eStandardError);
+    cEncodeError = rb_define_class_under(mYajl, "EncodeError", rb_eStandardError);
     
     cParser = rb_define_class_under(mYajl, "Parser", rb_cObject);
     rb_define_singleton_method(cParser, "new", rb_yajl_parser_new, -1);
@@ -536,14 +757,18 @@ void Init_yajl_ext() {
     rb_define_method(cEncoder, "initialize", rb_yajl_encoder_init, -1);
     rb_define_method(cEncoder, "encode", rb_yajl_encoder_encode, -1);
     
+    rb_define_singleton_method(cEncoder, "enable_json_gem_compatability", rb_yajl_encoder_enable_json_gem_ext, 0);
+    
     intern_io_read = rb_intern("read");
     intern_eof = rb_intern("eof?");
     intern_call = rb_intern("call");
     intern_keys = rb_intern("keys");
     intern_to_s = rb_intern("to_s");
+    intern_to_json = rb_intern("to_json");
+    
     sym_allow_comments = rb_intern("allow_comments");
     sym_check_utf8 = rb_intern("check_utf8");
     sym_pretty = rb_intern("pretty");
     sym_indent = rb_intern("indent");
     sym_symbolize_keys = rb_intern("symbolize_keys");
-}
+}

data/ext/yajl_ext.h

@@ -6,7 +6,7 @@
 #define WRITE_BUFSIZE 8092
 
 static VALUE cParseError, cEncodeError, mYajl, cParser, cEncoder;
-static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s,
+static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s, intern_to_json,
           sym_allow_comments, sym_check_utf8, sym_pretty, sym_indent, sym_symbolize_keys;
 
 #define GetParser(obj, sval) (sval = (struct yajl_parser_wrapper*)DATA_PTR(obj));
@@ -60,4 +60,15 @@ static VALUE rb_yajl_set_complete_cb(VALUE self, VALUE callback);
 
 static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass);
 static VALUE rb_yajl_encoder_init(int argc, VALUE * argv, VALUE self);
-static VALUE rb_yajl_encoder_encode(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_encoder_encode(int argc, VALUE * argv, VALUE self);
+
+static VALUE rb_yajl_json_ext_object_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_hash_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_array_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_fixnum_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_float_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_string_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_true_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_false_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_json_ext_nil_to_json(int argc, VALUE * argv, VALUE self);
+static VALUE rb_yajl_encoder_enable_json_gem_ext(VALUE klass);

data/ext/yajl_gen.c

@@ -152,9 +152,7 @@ yajl_gen_free(yajl_gen g)
             break;                                  \
     }                                               \
 
-#define FINAL_NEWLINE                                        \
-    if (g->state[g->depth] == yajl_gen_start)                \
-        yajl_buf_append(g->buf, "\n", 1);        
+#define FINAL_NEWLINE
     
 yajl_gen_status
 yajl_gen_integer(yajl_gen g, long int number)

data/lib/yajl/http_stream.rb

@@ -7,7 +7,7 @@ module Yajl
   # are streamed directly into Yajl.
   class HttpStream
     
-    # This Exception is thrown when an HTTP response isn't application/json
+    # This Exception is thrown when an HTTP response isn't in ALLOWED_MIME_TYPES
     # and therefore cannot be parsed.
     class InvalidContentType < Exception; end
     

data/lib/yajl/json_gem.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+require 'yajl' unless defined?(Yajl::Parser)
+
+# NOTE: this is probably temporary until I can split out the JSON compat C code into it's own
+# extension that can be included when this file is.
+Yajl::Encoder.enable_json_gem_compatability
+
+module JSON
+  
+  class ParserError < Yajl::ParseError; end
+  
+  def self.parse(str, opts={})
+    begin
+      Yajl::Parser.parse(str, opts)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+  
+  def self.generate(obj, opts={})
+    begin
+      options_map = {}
+      if opts.has_key?(:indent)
+        options_map[:pretty] = true
+        options_map[:indent] = opts[:indent]
+      end
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+  
+  def self.pretty_generate(obj, opts={})
+    begin
+      options_map = {}
+      options_map[:pretty] = true
+      options_map[:indent] = opts[:indent] if opts.has_key?(:indent)
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+  
+  def self.load(input, *args)
+    begin
+      Yajl::Parser.parse(input)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+  
+  def self.dump(obj, io=nil, *args)
+    begin
+      Yajl::Encoder.encode(obj, io)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+end
+
+module ::Kernel
+  def JSON(object, opts = {})
+    if object.respond_to? :to_s
+      JSON.parse(object.to_s, opts)
+    else
+      JSON.generate(object, opts)
+    end
+  end
+end

data/lib/yajl.rb

@@ -13,7 +13,7 @@ require 'yajl_ext'
 #
 # Ruby bindings to the excellent Yajl (Yet Another JSON Parser) ANSI C library.
 module Yajl
-  VERSION = "0.5.3"
+  VERSION = "0.5.5"
   
   class Parser
     # A helper method for parse-and-forget use-cases

data/spec/encoding/encoding_spec.rb

@@ -1,6 +1,12 @@
 # encoding: UTF-8
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 
+class Dummy2
+  def to_json
+    "hawtness"
+  end
+end
+
 describe "Yajl JSON encoder" do
   FILES = Dir[File.dirname(__FILE__)+'/../../benchmark/subjects/*.json']
   
@@ -56,9 +62,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with :pretty turned on and a single space indent, to an IO" do
-    output = "{\n \"foo\": {\n  \"name\": \"bar\",\n  \"id\": 1234\n }\n}\n"
+    output = "{\n \"foo\": {\n  \"name\": \"bar\",\n  \"id\": 1234\n }\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}\n"
+      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     io = StringIO.new
@@ -69,9 +75,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with :pretty turned on and a single space indent, and return a String" do
-    output = "{\n \"foo\": {\n  \"name\": \"bar\",\n  \"id\": 1234\n }\n}\n"
+    output = "{\n \"foo\": {\n  \"name\": \"bar\",\n  \"id\": 1234\n }\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}\n"
+      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
@@ -80,9 +86,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with :pretty turned on and a tab character indent, to an IO" do
-    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}\n"
+    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}\n"
+      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     io = StringIO.new
@@ -93,9 +99,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with :pretty turned on and a tab character indent, and return a String" do
-    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}\n"
+    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}\n"
+      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
@@ -104,9 +110,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with it's class method with :pretty and a tab character indent options set, to an IO" do
-    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}\n"
+    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}\n"
+      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     io = StringIO.new
@@ -116,9 +122,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with it's class method with :pretty and a tab character indent options set, and return a String" do
-    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}\n"
+    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}\n"
+      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     output = Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t")
@@ -126,9 +132,9 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode with it's class method with :pretty and a tab character indent options set, to a block" do
-    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}\n"
+    output = "{\n\t\"foo\": {\n\t\t\"name\": \"bar\",\n\t\t\"id\": 1234\n\t}\n}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}\n"
+      output = "{\n\t\"foo\": {\n\t\t\"id\": 1234,\n\t\t\"name\": \"bar\"\n\t}\n}"
     end
     obj = {:foo => {:id => 1234, :name => "bar"}}
     output = ''
@@ -147,9 +153,9 @@ describe "Yajl JSON encoder" do
       encoder.encode(obj, io)
     end
     io.rewind
-    output = "{\"baz\":1234,\"foo\":\"bar\"}\n{\"baz\":1234,\"foo\":\"bar\"}\n{\"baz\":1234,\"foo\":\"bar\"}\n{\"baz\":1234,\"foo\":\"bar\"}\n{\"baz\":1234,\"foo\":\"bar\"}\n"
+    output = "{\"baz\":1234,\"foo\":\"bar\"}{\"baz\":1234,\"foo\":\"bar\"}{\"baz\":1234,\"foo\":\"bar\"}{\"baz\":1234,\"foo\":\"bar\"}{\"baz\":1234,\"foo\":\"bar\"}"
     if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\"foo\":\"bar\",\"baz\":1234}\n{\"foo\":\"bar\",\"baz\":1234}\n{\"foo\":\"bar\",\"baz\":1234}\n{\"foo\":\"bar\",\"baz\":1234}\n{\"foo\":\"bar\",\"baz\":1234}\n"
+      output = "{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}"
     end
     io.read.should == output
   end
@@ -168,4 +174,13 @@ describe "Yajl JSON encoder" do
     end
     json_output.should == output
   end
+  
+  it "should encode all map keys as strings" do
+    Yajl::Encoder.encode({1=>1}).should eql("{\"1\":1}")
+  end
+  
+  it "should check for and call #to_json if it exists on custom objects" do
+    d = Dummy2.new
+    Yajl::Encoder.encode({:foo => d}).should eql('{"foo":"hawtness"}')
+  end
 end

data/spec/json_gem_compatibility/compatibility_spec.rb

@@ -0,0 +1,170 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+class Dummy; end
+
+describe "JSON Gem compatability API" do
+  it "shoud not mixin #to_json on base objects until compatability has been enabled" do
+    d = Dummy.new
+    
+    d.respond_to?(:to_json).should_not be_true
+    "".respond_to?(:to_json).should_not be_true
+    1.respond_to?(:to_json).should_not be_true
+    "1.5".to_f.respond_to?(:to_json).should_not be_true
+    [].respond_to?(:to_json).should_not be_true
+    {:foo => "bar"}.respond_to?(:to_json).should_not be_true
+    true.respond_to?(:to_json).should_not be_true
+    false.respond_to?(:to_json).should_not be_true
+    nil.respond_to?(:to_json).should_not be_true
+  end
+  
+  it "should mixin #to_json on base objects after compatability has been enabled" do
+    Yajl::Encoder.enable_json_gem_compatability
+    d = Dummy.new
+    
+    d.respond_to?(:to_json).should be_true
+    "".respond_to?(:to_json).should be_true
+    1.respond_to?(:to_json).should be_true
+    "1.5".to_f.respond_to?(:to_json).should be_true
+    [].respond_to?(:to_json).should be_true
+    {:foo => "bar"}.respond_to?(:to_json).should be_true
+    true.respond_to?(:to_json).should be_true
+    false.respond_to?(:to_json).should be_true
+    nil.respond_to?(:to_json).should be_true
+  end
+  
+  it "should require yajl/json_gem to enable the compatability API" do
+    require 'yajl/json_gem'
+    
+    defined?(JSON).should be_true
+    
+    JSON.respond_to?(:parse).should be_true
+    JSON.respond_to?(:generate).should be_true
+    JSON.respond_to?(:pretty_generate).should be_true
+    JSON.respond_to?(:load).should be_true
+    JSON.respond_to?(:dump).should be_true
+  end
+  
+  context "ported tests for Unicode" do
+    it "should be able to encode and parse unicode" do
+      pending if RUBY_VERSION.include?('1.9') # FIXME: Some string encoding problem with 1.9
+      '""'.should eql(''.to_json)
+      '"\\b"'.should eql("\b".to_json)
+      '"\u0001"'.should eql(0x1.chr.to_json)
+      '"\u001F"'.should eql(0x1f.chr.to_json)
+      '" "'.should eql(' '.to_json)
+      "\"#{0x7f.chr}\"".should eql(0x7f.chr.to_json)
+      utf8 = [ "© ≠ €! \01" ]
+      json = '["© ≠ €! \u0001"]'
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+      json = "[\"あいうえお\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ['საქართველო']
+      json = "[\"საქართველო\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      '["Ã"]'.should eql(JSON.generate(["Ã"]))
+      ["€"].should eql(JSON.parse('["\u20ac"]'))
+      utf8_str = "\xf0\xa0\x80\x81"
+      utf8 = [utf8_str]
+      json = "[\"#{utf8_str}\"]"
+      json.should eql(JSON.generate(utf8))
+      utf8.should eql(JSON.parse(json))
+    end
+  end
+  
+  context "ported tests for generation" do
+    before(:all) do
+      @hash = {
+        'a' => 2,
+        'b' => 3.141,
+        'c' => 'c',
+        'd' => [ 1, "b", 3.14 ],
+        'e' => { 'foo' => 'bar' },
+        'g' => "blah",
+        'h' => 1000.0,
+        'i' => 0.001
+      }
+      
+      @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},"g":"blah","h":1000.0,"i":0.001}'
+      
+      @json3 = %{
+        {
+          "a": 2,
+          "b": 3.141,
+          "c": "c",
+          "d": [1, "b", 3.14],
+          "e": {"foo": "bar"},
+          "g": "blah",
+          "h": 1000.0,
+          "i": 0.001
+        }
+      }.chomp
+    end
+    
+    it "should be able to unparse" do
+      json = JSON.generate(@hash)
+      JSON.parse(@json2).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.generate({1=>2})
+      '{"1":2}'.should eql(json)
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+    
+    it "should be able to unparse pretty" do
+      json = JSON.pretty_generate(@hash)
+      JSON.parse(@json3).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.pretty_generate({1=>2})
+      test = "{\n  \"1\": 2\n}".chomp
+      test.should == json
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+  end
+  
+  context "ported fixture tests" do
+    fixtures = File.join(File.dirname(__FILE__), '../parsing/fixtures/*.json')
+    passed, failed = Dir[fixtures].partition { |f| f['pass'] }
+    JSON_PASSED = passed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    JSON_FAILED = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should_not raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should_not raise_error(Yajl::ParseError)
+      end
+    end
+  end
+end

data/yajl-ruby.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{yajl-ruby}
-  s.version = "0.5.4"
+  s.version = "0.5.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Lopez", "Lloyd Hilaiel"]
-  s.date = %q{2009-06-16}
+  s.date = %q{2009-06-18}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = [
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
      "benchmark/parse_json_and_yaml.rb",
      "benchmark/parse_stream.rb",
      "benchmark/subjects/contacts.json",
+     "benchmark/subjects/contacts.marshal_dump",
      "benchmark/subjects/contacts.yml",
      "benchmark/subjects/item.json",
      "benchmark/subjects/ohai.json",
@@ -69,12 +70,14 @@ Gem::Specification.new do |s|
      "lib/yajl/gzip/stream_reader.rb",
      "lib/yajl/gzip/stream_writer.rb",
      "lib/yajl/http_stream.rb",
+     "lib/yajl/json_gem.rb",
      "spec/encoding/encoding_spec.rb",
      "spec/http/fixtures/http.bzip2.dump",
      "spec/http/fixtures/http.deflate.dump",
      "spec/http/fixtures/http.gzip.dump",
      "spec/http/fixtures/http.raw.dump",
      "spec/http/http_spec.rb",
+     "spec/json_gem_compatibility/compatibility_spec.rb",
      "spec/parsing/active_support_spec.rb",
      "spec/parsing/chunked_spec.rb",
      "spec/parsing/fixtures/fail.15.json",
@@ -147,6 +150,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/encoding/encoding_spec.rb",
      "spec/http/http_spec.rb",
+     "spec/json_gem_compatibility/compatibility_spec.rb",
      "spec/parsing/active_support_spec.rb",
      "spec/parsing/chunked_spec.rb",
      "spec/parsing/fixtures_spec.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: brianmario-yajl-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors: 
 - Brian Lopez
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-16 00:00:00 -07:00
+date: 2009-06-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,7 @@ files:
 - benchmark/parse_json_and_yaml.rb
 - benchmark/parse_stream.rb
 - benchmark/subjects/contacts.json
+- benchmark/subjects/contacts.marshal_dump
 - benchmark/subjects/contacts.yml
 - benchmark/subjects/item.json
 - benchmark/subjects/ohai.json
@@ -79,12 +80,14 @@ files:
 - lib/yajl/gzip/stream_reader.rb
 - lib/yajl/gzip/stream_writer.rb
 - lib/yajl/http_stream.rb
+- lib/yajl/json_gem.rb
 - spec/encoding/encoding_spec.rb
 - spec/http/fixtures/http.bzip2.dump
 - spec/http/fixtures/http.deflate.dump
 - spec/http/fixtures/http.gzip.dump
 - spec/http/fixtures/http.raw.dump
 - spec/http/http_spec.rb
+- spec/json_gem_compatibility/compatibility_spec.rb
 - spec/parsing/active_support_spec.rb
 - spec/parsing/chunked_spec.rb
 - spec/parsing/fixtures/fail.15.json
@@ -178,6 +181,7 @@ summary: Ruby C bindings to the excellent Yajl JSON stream-based parser library.
 test_files: 
 - spec/encoding/encoding_spec.rb
 - spec/http/http_spec.rb
+- spec/json_gem_compatibility/compatibility_spec.rb
 - spec/parsing/active_support_spec.rb
 - spec/parsing/chunked_spec.rb
 - spec/parsing/fixtures_spec.rb