yajl-ruby 0.6.3 → 0.6.4

data/ext/yajl_ext.h

@@ -5,9 +5,24 @@
 #define READ_BUFSIZE 8092
 #define WRITE_BUFSIZE 8092
 
+// Older versions of Ruby (< 1.8.6) need these
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+
 static VALUE cParseError, cEncodeError, mYajl, cParser, cEncoder;
-static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s, intern_to_json, intern_has_key,
-          sym_allow_comments, sym_check_utf8, sym_pretty, sym_indent, sym_terminator, sym_symbolize_keys;
+static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s,
+            intern_to_json, intern_has_key, intern_to_sym;
+static ID sym_allow_comments, sym_check_utf8, sym_pretty, sym_indent, sym_terminator, sym_symbolize_keys;
 
 #define GetParser(obj, sval) (sval = (struct yajl_parser_wrapper*)DATA_PTR(obj));
 #define GetEncoder(obj, sval) (sval = (struct yajl_encoder_wrapper*)DATA_PTR(obj));
@@ -80,4 +95,6 @@ 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);
+static VALUE rb_yajl_encoder_enable_json_gem_ext(VALUE klass);
+
+void Init_yajl_ext();

data/ext/yajl_gen.c

@@ -37,6 +37,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <math.h>
 
 typedef enum {
     yajl_gen_start,
@@ -166,11 +167,19 @@ yajl_gen_integer(yajl_gen g, long int number)
     return yajl_gen_status_ok;
 }
 
+#ifdef WIN32
+#include <float.h>
+#define isnan _isnan
+#define isinf _finite
+#endif
+
 yajl_gen_status
 yajl_gen_double(yajl_gen g, double number)
 {
     char i[32];
-    ENSURE_VALID_STATE; ENSURE_NOT_KEY; INSERT_SEP; INSERT_WHITESPACE;
+    ENSURE_VALID_STATE; ENSURE_NOT_KEY; 
+    if (isnan(number) || isinf(number)) return yajl_gen_invalid_number;
+    INSERT_SEP; INSERT_WHITESPACE;
     sprintf(i, "%g", number);
     yajl_buf_append(g->buf, i, strlen(i));
     APPENDED_ATOM;

data/ext/yajl_parser.c

@@ -307,8 +307,8 @@ yajl_do_parse(yajl_handle hand, unsigned int * offset,
             {
                 yajl_state s = yajl_bs_current(hand->stateStack);
                 if (s == yajl_state_start) {
-                    // HACK: is this even safe to do?
-                    // yajl_bs_set(hand->stateStack, yajl_state_parse_complete);
+                    /* HACK: is this even safe to do?
+                     yajl_bs_set(hand->stateStack, yajl_state_parse_complete); */
                     yajl_reset_parser(hand);
                 } else if (s == yajl_state_map_need_val) {
                     yajl_bs_set(hand->stateStack, yajl_state_map_got_val);

data/lib/yajl.rb

@@ -13,7 +13,17 @@ require 'yajl_ext'
 #
 # Ruby bindings to the excellent Yajl (Yet Another JSON Parser) ANSI C library.
 module Yajl
-  VERSION = "0.6.3"
+  VERSION = "0.6.4"
+  
+  # For compatibility, has the same signature of Yajl::Parser.parse
+  def self.load(str_or_io, options={}, read_bufsize=nil, &block)
+    Parser.parse(str_or_io, options, read_bufsize, &block)
+  end
+  
+  # For compatibility, has the same signature of Yajl::Encoder.encode
+  def self.dump(obj, *args, &block)
+    Encoder.encode(obj, args, &block)
+  end
   
   class Parser
     # A helper method for parse-and-forget use-cases
@@ -25,8 +35,8 @@ module Yajl
     # :allow_comments accepts a boolean will enable/disable checks for in-line comments in the JSON stream
     #
     # :check_utf8 accepts a boolean will enable/disable UTF8 validation for the JSON stream
-    def self.parse(io, options={}, read_bufsize=nil, &block)
-      new(options).parse(io, read_bufsize, &block)
+    def self.parse(str_or_io, options={}, read_bufsize=nil, &block)
+      new(options).parse(str_or_io, read_bufsize, &block)
     end
   end
   
@@ -52,6 +62,7 @@ module Yajl
     # If a block is passed, it will be used as (and work the same as) the +on_progress+ callback
     def self.encode(obj, *args, &block)
       # TODO: this code smells, any ideas?
+      args.flatten!
       options = {}
       io = nil
       args.each do |arg|
@@ -68,15 +79,15 @@ module Yajl
   # DEPRECATED - See Yajl::Parser and Yajl::Encoder
   module Stream
     # DEPRECATED - See Yajl::Parser
-    def self.parse(io)
-      STDERR.puts "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Parser class instead."
-      Parser.new.parse(io)
+    def self.parse(str_or_io)
+      warn "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Parser class instead."
+      Parser.new.parse(str_or_io)
     end
     
     # DEPRECATED - See Yajl::Encoder
-    def self.encode(obj, io)
-      STDERR.puts "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Encoder class instead."
-      Encoder.new.encode(obj, io)
+    def self.encode(obj, str_or_io=nil)
+      warn "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Encoder class instead."
+      Encoder.new.encode(obj, str_or_io)
     end
   end
 end

data/lib/yajl/json_gem/encoding.rb

@@ -13,6 +13,9 @@ class Object
 end
 
 module JSON
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class GeneratorError < JSONError; end unless defined?(JSON::GeneratorError)
+  
   def self.generate(obj, opts={})
     begin
       options_map = {}
@@ -21,8 +24,8 @@ module JSON
         options_map[:indent] = opts[:indent]
       end
       Yajl::Encoder.encode(obj, options_map)
-    rescue Yajl::ParseError => e
-      raise JSON::ParserError, e.message
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
     end
   end
   
@@ -32,16 +35,16 @@ module JSON
       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
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, 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
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
     end
   end
 end

data/lib/yajl/json_gem/parsing.rb

@@ -2,7 +2,8 @@
 require 'yajl' unless defined?(Yajl::Parser)
 
 module JSON
-  class ParserError < Yajl::ParseError; end
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class ParserError < JSONError; end unless defined?(JSON::ParserError)
   
   def self.default_options
     @default_options ||= {:symbolize_keys => false}

data/spec/encoding/encoding_spec.rb

@@ -11,62 +11,59 @@ describe "Yajl JSON encoder" do
   FILES = Dir[File.dirname(__FILE__)+'/../../benchmark/subjects/*.json']
   
   FILES.each do |file|
-    it "should encode #{File.basename(file)} to an IO" do
-      # we don't care about testing the stream subject as it has multiple JSON strings in it
-      if File.basename(file) != 'twitter_stream.json'
-        input = File.new(File.expand_path(file), 'r')
-        io = StringIO.new
-        encoder = Yajl::Encoder.new
-        hash = Yajl::Parser.parse(input)
-        encoder.encode(hash, io)
-        io.rewind
-        hash2 = Yajl::Parser.parse(io)
-        io.close
-        input.close
-        hash.should == hash2
-      end
-    end
-  end
-  
-  FILES.each do |file|
-    it "should encode #{File.basename(file)} and return a String" do
-      # we don't care about testing the stream subject as it has multiple JSON strings in it
-      if File.basename(file) != 'twitter_stream.json'
-        input = File.new(File.expand_path(file), 'r')
-        encoder = Yajl::Encoder.new
-        hash = Yajl::Parser.parse(input)
-        output = encoder.encode(hash)
-        hash2 = Yajl::Parser.parse(output)
-        input.close
-        hash.should == hash2
-      end
-    end
-  end
-  
-  FILES.each do |file|
-    it "should encode #{File.basename(file)} call the passed block, passing it a String" do
-      # we don't care about testing the stream subject as it has multiple JSON strings in it
-      if File.basename(file) != 'twitter_stream.json'
-        input = File.new(File.expand_path(file), 'r')
-        encoder = Yajl::Encoder.new
-        hash = Yajl::Parser.parse(input)
-        output = ''
-        encoder.encode(hash) do |json_str|
-          output << json_str
-        end
-        hash2 = Yajl::Parser.parse(output)
-        input.close
-        hash.should == hash2
-      end
-    end
-  end
+     it "should encode #{File.basename(file)} to an IO" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         io = StringIO.new
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         encoder.encode(hash, io)
+         io.rewind
+         hash2 = Yajl::Parser.parse(io)
+         io.close
+         input.close
+         hash.should == hash2
+       end
+     end
+   end
+   
+   FILES.each do |file|
+     it "should encode #{File.basename(file)} and return a String" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         output = encoder.encode(hash)
+         hash2 = Yajl::Parser.parse(output)
+         input.close
+         hash.should == hash2
+       end
+     end
+   end
+   
+   FILES.each do |file|
+     it "should encode #{File.basename(file)} call the passed block, passing it a String" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         output = ''
+         encoder.encode(hash) do |json_str|
+           output << json_str
+         end
+         hash2 = Yajl::Parser.parse(output)
+         input.close
+         hash.should == hash2
+       end
+     end
+   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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}"
-    end
-    obj = {:foo => {:id => 1234, :name => "bar"}}
+    output = "{\n \"foo\": 1234\n}"
+    obj = {:foo => 1234}
     io = StringIO.new
     encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
     encoder.encode(obj, io)
@@ -75,22 +72,16 @@ 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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}"
-    end
-    obj = {:foo => {:id => 1234, :name => "bar"}}
+    output = "{\n \"foo\": 1234\n}"
+    obj = {:foo => 1234}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
     output = encoder.encode(obj)
     output.should == output
   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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      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 = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
     io = StringIO.new
     encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
     encoder.encode(obj, io)
@@ -99,22 +90,16 @@ 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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      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 = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
     output = encoder.encode(obj)
     output.should == output
   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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      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 = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
     io = StringIO.new
     Yajl::Encoder.encode(obj, io, :pretty => true, :indent => "\t")
     io.rewind
@@ -122,21 +107,15 @@ 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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      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 = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
     output = Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t")
     output.should == output
   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}"
-    if RUBY_VERSION.include?('1.9') # FIXME
-      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 = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
     output = ''
     Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t") do |json_str|
       output = json_str
@@ -145,33 +124,25 @@ describe "Yajl JSON encoder" do
   end
   
   it "should encode multiple objects into a single stream, to an IO" do
-    pending "Find a better way to compare order of hash keys in resulting string"
     io = StringIO.new
-    obj = {:foo => "bar", :baz => 1234}
+    obj = {:foo => 1234}
     encoder = Yajl::Encoder.new
     5.times do
       encoder.encode(obj, io)
     end
     io.rewind
-    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}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}{\"foo\":\"bar\",\"baz\":1234}"
-    end
+    output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
     io.read.should == output
   end
   
   it "should encode multiple objects into a single stream, and return a String" do
-    pending "Find a better way to compare order of hash keys in resulting string"
-    obj = {:foo => "bar", :baz => 1234}
+    obj = {:foo => 1234}
     encoder = Yajl::Encoder.new
     json_output = ''
     5.times do
       json_output << encoder.encode(obj)
     end
-    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"
-    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"
-    end
+    output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
     json_output.should == output
   end
   
@@ -223,4 +194,19 @@ describe "Yajl JSON encoder" do
     s.rewind
     s.read.should eql("{\"foo\":\"bar\"}")
   end
+  
+  it "should not encode NaN" do
+    lambda {
+      Yajl::Encoder.encode(0.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+  end
+  
+  it "should not encode Infinity or -Infinity" do
+    lambda {
+      Yajl::Encoder.encode(1.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+    lambda {
+      Yajl::Encoder.encode(-1.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+  end
 end

data/spec/global/global_spec.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe "Yajl" do
+  context "dump" do
+    it "should exist as a class-method" do
+      Yajl.should respond_to(:dump)
+    end
+
+    it "should be able to encode to a string" do
+      Yajl.dump({:a => 1234}).should eql('{"a":1234}')
+    end
+    
+    it "should be able to encode to an IO" do
+      io = StringIO.new
+      Yajl.dump({:a => 1234}, io)
+      io.rewind
+      io.read.should eql('{"a":1234}') 
+    end
+    
+    it "should be able to encode with a block supplied" do
+      Yajl.dump({:a => 1234}) do |chunk|
+        chunk.should eql('{"a":1234}')
+      end
+    end
+  end
+  
+  context "load" do
+    it "should exist as a class-method" do
+      Yajl.should respond_to(:load)
+    end
+  
+    it "should be able to parse from a string" do
+      Yajl.load('{"a":1234}').should eql({"a" => 1234})
+    end
+    
+    it "should be able to parse from an IO" do
+      io = StringIO.new('{"a":1234}')
+      Yajl.load(io).should eql({"a" => 1234})
+    end
+    
+    it "should be able to parse from a string with a block supplied" do
+      Yajl.load('{"a":1234}') do |h|
+        h.should eql({"a" => 1234})
+      end
+    end
+    
+    it "should be able to parse from an IO with a block supplied" do
+      io = StringIO.new('{"a":1234}')
+      Yajl.load(io) do |h|
+        h.should eql({"a" => 1234})
+      end
+    end
+  end
+end