brianmario-yajl-ruby 0.5.2 → 0.5.3

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.3 (Jun 7th, 2009)
+* The IO parameter for Yajl::Encode#encode is now optional, and accepts a block
+** it will return the resulting JSON string if no IO is passed to stream to
+** if a block is passed, it will call and pass it the resulting JSON string
+* Yajl::Parser#parse can now parse from a String as well as an IO
+* Added and updated lot of in-code documentation.
+** all the C code exposed to Ruby should now have comments
+* Added :symbolize_keys option to the Yajl::Parser class, which defaults to true.
+** Having this option enabled has shown around an 18% speedup in parsing time according to my benchmarks
+
 ## 0.5.2 (May 30th, 2009)
 * Added class helper methods Yajl::Encoder.encode(obj, io) and Yajl::Parser.parse(io)
  * added tests for the above

data/README.rdoc

@@ -142,8 +142,8 @@ Some ideas are:
 * a Rails plugin (http://github.com/technoweenie/yajl-rails)
 * builtin Rails 3 support?
 * Rack middleware (ideally the JSON body could be handed to the parser while it's still being received)
-* use with ohai
-* JSON API clients
+* use with ohai (http://github.com/brianmario/ohai)
+* JSON API clients (http://github.com/brianmario/crack, http://github.com/brianmario/freckle-api)
 * Patch Marshal#load and Marshal#dump to use JSON? ;)
 * etc...
 
@@ -214,4 +214,5 @@ I've had a lot of inspiration, and a lot of help. Thanks to everyone who's been
 * Tom Smith - http://github.com/rtomsmith - pointer-hacking help
 * Rick http://github.com/technoweenie - for making an ActiveSupport patch with support for this library and teasing me that it might go into Rails 3. You sure lit a fire under my ass and I got a ton of work done because of it! :)
 * The entire Github Crew - http://github.com/ - my inspiration, time spent writing this, finding Yajl, So many-MANY other things wouldn't have been possible without this awesome service. I owe you guys some whiskey at Kilowatt.
-* benburkert - http://github.com/benburkert
+* benburkert - http://github.com/benburkert
+* Aman Gupta - http://github.com/tmm1 - tons of suggestions and inspiration for the most recent features, and hopefully more to come ;)

data/VERSION.yml

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

data/benchmark/encode.rb

@@ -15,11 +15,18 @@ 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
+  io_encoder = Yajl::Encoder.new
   x.report {
-    puts "Yajl::Encoder#encode"
+    puts "Yajl::Encoder#encode (to an IO)"
     times.times {
-      encoder.encode(hash, StringIO.new)
+      io_encoder.encode(hash, StringIO.new)
+    }
+  }
+  string_encoder = Yajl::Encoder.new
+  x.report {
+    puts "Yajl::Encoder#encode (to a String)"
+    times.times {
+      output = string_encoder.encode(hash)
     }
   }
   x.report {

data/benchmark/parse.rb

@@ -15,12 +15,20 @@ json.rewind
 times = ARGV[1] ? ARGV[1].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
+  io_parser = Yajl::Parser.new
   x.report {
-    puts "Yajl::Parser#parse"
+    puts "Yajl::Parser#parse (from an IO)"
     times.times {
       json.rewind
-      parser.parse(json)
+      io_parser.parse(json)
+    }
+  }
+  string_parser = Yajl::Parser.new
+  x.report {
+    puts "Yajl::Parser#parse (from a String)"
+    times.times {
+      json.rewind
+      string_parser.parse(json.read)
     }
   }
   x.report {

data/ext/yajl_ext.c

@@ -11,6 +11,14 @@ inline void yajl_check_and_fire_callback(void * ctx) {
         if (len == 1 && wrapper->nestedArrayLevel == 0 && wrapper->nestedHashLevel == 0) {
             rb_funcall(wrapper->parse_complete_callback, intern_call, 1, rb_ary_pop(wrapper->builderStack));
         }
+    } else {
+        int len = RARRAY_LEN(wrapper->builderStack);
+        if (len == 1 && wrapper->nestedArrayLevel == 0 && wrapper->nestedHashLevel == 0) {
+            wrapper->objectsFound++;
+            if (wrapper->objectsFound > 1) {
+                rb_raise(cParseError, "%s", "Found multiple JSON objects in the stream but no block or the on_parse_complete callback was assigned to handle them.");
+            }
+        }
     }
 }
 
@@ -36,6 +44,7 @@ inline void yajl_set_static_value(void * ctx, VALUE val) {
                 rb_ary_push(wrapper->builderStack, val);
                 break;
             case T_STRING:
+            case T_SYMBOL:
                 hash = rb_ary_entry(wrapper->builderStack, len-2);
                 if (TYPE(hash) == T_HASH) {
                     rb_hash_aset(hash, lastEntry, val);
@@ -58,11 +67,13 @@ void yajl_encode_part(yajl_gen hand, VALUE obj, VALUE io) {
     const unsigned char * buffer;
     unsigned int len;
     
-    yajl_gen_get_buf(hand, &buffer, &len);
-    if (len >= WRITE_BUFSIZE) {
-        outBuff = rb_str_new((const char *)buffer, len);
-        rb_io_write(io, outBuff);
-        yajl_gen_clear(hand);
+    if (io != Qnil) {
+        yajl_gen_get_buf(hand, &buffer, &len);
+        if (len >= WRITE_BUFSIZE) {
+            outBuff = rb_str_new((const char *)buffer, len);
+            rb_io_write(io, outBuff);
+            yajl_gen_clear(hand);
+        }
     }
     
     switch (TYPE(obj)) {
@@ -126,6 +137,18 @@ void yajl_parser_wrapper_mark(void * wrapper) {
     rb_gc_mark(w->parse_complete_callback);
 }
 
+void yajl_parse_chunk(const unsigned char * chunk, unsigned int len, yajl_handle parser) {
+    yajl_status stat;
+    
+    stat = yajl_parse(parser, chunk, len);
+    
+    if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
+        unsigned char * str = yajl_get_error(parser, 1, chunk, len);
+        rb_raise(cParseError, "%s", (const char *) str);
+        yajl_free_error(parser, str);
+    }
+}
+
 // YAJL Callbacks
 static int yajl_found_null(void * ctx) {
     yajl_set_static_value(ctx, Qnil);
@@ -161,7 +184,18 @@ static int yajl_found_string(void * ctx, const unsigned char * stringVal, unsign
 }
 
 static int yajl_found_hash_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
-    yajl_set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
+    
+    if (wrapper->symbolizeKeys) {
+        char keyStr[stringLen];
+        ID key;
+        sprintf(keyStr, "%.*s", stringLen, stringVal);
+        key = rb_intern(keyStr);
+        yajl_set_static_value(ctx, ID2SYM(key));
+    } else {
+        yajl_set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
+    }
     yajl_check_and_fire_callback(ctx);
     return 1;
 }
@@ -205,14 +239,30 @@ static int yajl_found_end_array(void * ctx) {
 }
 
 
-/** Ruby Interface */
+// Ruby Interface
 
-// Yajl::Parser
+/*
+ * Document-class: Yajl::Parser
+ *
+ * This class contains methods for parsing JSON directly from an IO object.
+ * The only basic requirment currently is that the IO object respond to #read(len) and #eof?
+ * The IO is parsed until a complete JSON object has been read and a ruby object will be returned.
+ */
+ 
+/*
+ * Document-method: new
+ *
+ * call-seq: new([:allow_comments => false, :check_utf8 => false])
+ *
+ * :allow_comments will turn on/off the check for comments inside the JSON stream.
+ *
+ * :check_utf8 will validate UTF8 characters found in the JSON stream.
+ */
 static VALUE rb_yajl_parser_new(int argc, VALUE * argv, VALUE klass) {
     struct yajl_parser_wrapper * wrapper;
     yajl_parser_config cfg;
     VALUE opts, obj;
-    int allowComments = 1, checkUTF8 = 1;
+    int allowComments = 1, checkUTF8 = 1, symbolizeKeys = 1;
     
     // Scan off config vars
     if (rb_scan_args(argc, argv, "01", &opts) == 1) {
@@ -224,6 +274,9 @@ static VALUE rb_yajl_parser_new(int argc, VALUE * argv, VALUE klass) {
         if (rb_hash_aref(opts, ID2SYM(sym_check_utf8)) == Qfalse) {
             checkUTF8 = 0;
         }
+        if (rb_hash_aref(opts, ID2SYM(sym_symbolize_keys)) == Qfalse) {
+            symbolizeKeys = 0;
+        }
     }
     cfg = (yajl_parser_config){allowComments, checkUTF8};
     
@@ -231,44 +284,76 @@ static VALUE rb_yajl_parser_new(int argc, VALUE * argv, VALUE klass) {
     wrapper->parser = yajl_alloc(&callbacks, &cfg, NULL, (void *)obj);
     wrapper->nestedArrayLevel = 0;
     wrapper->nestedHashLevel = 0;
+    wrapper->objectsFound = 0;
+    wrapper->symbolizeKeys = symbolizeKeys;
     wrapper->builderStack = rb_ary_new();
     wrapper->parse_complete_callback = Qnil;
     rb_obj_call_init(obj, 0, 0);
     return obj;
 }
 
+/*
+ * Document-method: initialize
+ *
+ * call-seq: initialize([:allow_comments => false, :check_utf8 => false])
+ *
+ * :allow_comments will turn on/off the check for comments inside the JSON stream.
+ *
+ * :check_utf8 will validate UTF8 characters found in the JSON stream.
+*/
 static VALUE rb_yajl_parser_init(int argc, VALUE * argv, VALUE self) {
     return self;
 }
 
+/*
+ * Document-method: parse
+ *
+ * call-seq:
+ *  parse(input, buffer_size=8092)
+ *  parse(input, buffer_size=8092) { |obj| ... }
+ *
+ * +input+ can either be a string or an IO to parse JSON from
+ *
+ * +buffer_size+ is the size of chunk that will be parsed off the input (if it's an IO) for each loop of the parsing process.
+ * 8092 is a good balance between the different types of streams (off disk, off a socket, etc...), but this option
+ * is here so the caller can better tune their parsing depending on the type of stream being passed.
+ * A larger read buffer will perform better for files off disk, where as a smaller size may be more efficient for
+ * reading off of a socket directly.
+ *
+ * If a block was passed, it's called when an object has been parsed off the stream. This is especially
+ * usefull when parsing a stream of multiple JSON objects.
+ *
+ * NOTE: you can optionally assign the +on_parse_complete+ callback, and it will be called the same way the optional
+ * block is for this method.
+*/
 static VALUE rb_yajl_parser_parse(int argc, VALUE * argv, VALUE self) {
-    struct yajl_parser_wrapper * wrapper;
     yajl_status stat;
-    VALUE parsed, rbufsize, io;
+    struct yajl_parser_wrapper * wrapper;
+    VALUE parsed, rbufsize, input, blk;
     
     GetParser(self, wrapper);
     parsed = rb_str_new2("");
     
     // setup our parameters
-    rb_scan_args(argc, argv, "11", &io, &rbufsize);
+    rb_scan_args(argc, argv, "11&", &input, &rbufsize, &blk);
     if (NIL_P(rbufsize)) {
         rbufsize = INT2FIX(READ_BUFSIZE);
     } else {
         Check_Type(rbufsize, T_FIXNUM);
     }
+    if (!NIL_P(blk)) {
+        rb_yajl_set_complete_cb(self, blk);
+    }
     
-    // now parse from the IO
-    while (rb_funcall(io, intern_eof, 0) != Qtrue) {
-        rb_funcall(io, intern_io_read, 2, rbufsize, parsed);
-        
-        stat = yajl_parse(wrapper->parser, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
-        
-        if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-            unsigned char * str = yajl_get_error(wrapper->parser, 1, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
-            rb_raise(cParseError, "%s", (const char *) str);
-            yajl_free_error(wrapper->parser, str);
-            break;
+    if (TYPE(input) == T_STRING) {
+        yajl_parse_chunk((const unsigned char *)RSTRING_PTR(input), RSTRING_LEN(input), wrapper->parser);
+    } else if (rb_respond_to(input, intern_eof)) {
+        while (rb_funcall(input, intern_eof, 0) != Qtrue) {
+            rb_funcall(input, intern_io_read, 2, rbufsize, parsed);
+            yajl_parse_chunk((const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed), wrapper->parser);
         }
+    } else {
+        rb_raise(cParseError, "input must be a string or IO");
     }
     
     // parse any remaining buffered data
@@ -282,9 +367,19 @@ static VALUE rb_yajl_parser_parse(int argc, VALUE * argv, VALUE self) {
     return rb_ary_pop(wrapper->builderStack);
 }
 
+/*
+ * Document-method: parse_chunk
+ *
+ * call-seq: parse_chunk(string_chunk)
+ *
+ * +string_chunk+ can be a partial or full JSON string to push on the parser.
+ *
+ * This method will throw an exception if the +on_parse_complete+ callback hasn't been assigned yet.
+ * The +on_parse_complete+ callback assignment is required so the user can handle objects that have been
+ * parsed off the stream as they're found.
+ */
 static VALUE rb_yajl_parser_parse_chunk(VALUE self, VALUE chunk) {
     struct yajl_parser_wrapper * wrapper;
-    yajl_status stat;
     
     GetParser(self, wrapper);
     if (NIL_P(chunk)) {
@@ -293,12 +388,7 @@ static VALUE rb_yajl_parser_parse_chunk(VALUE self, VALUE chunk) {
     }
     
     if (wrapper->parse_complete_callback != Qnil) {
-        stat = yajl_parse(wrapper->parser, (const unsigned char *)RSTRING_PTR(chunk), RSTRING_LEN(chunk));
-        if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-            unsigned char * str = yajl_get_error(wrapper->parser, 1, (const unsigned char *)RSTRING_PTR(chunk), RSTRING_LEN(chunk));
-            rb_raise(cParseError, "%s", (const char *) str);
-            yajl_free_error(wrapper->parser, str);
-        }
+        yajl_parse_chunk((const unsigned char *)RSTRING_PTR(chunk), RSTRING_LEN(chunk), wrapper->parser);
     } else {
         rb_raise(cParseError, "The on_parse_complete callback isn't setup, parsing useless.");
     }
@@ -306,6 +396,15 @@ static VALUE rb_yajl_parser_parse_chunk(VALUE self, VALUE chunk) {
     return Qnil;
 }
 
+/*
+ * Document-method: on_parse_complete=
+ *
+ * call-seq: on_parse_complete = Proc.new { |obj| ... }
+ *
+ * This callback setter allows you to pass a Proc/lambda or any other object that response to #call.
+ *
+ * It will pass a single parameter, the ruby object built from the last parsed JSON object
+ */
 static VALUE rb_yajl_set_complete_cb(VALUE self, VALUE callback) {
     struct yajl_parser_wrapper * wrapper;
     GetParser(self, wrapper);
@@ -313,7 +412,23 @@ static VALUE rb_yajl_set_complete_cb(VALUE self, VALUE callback) {
     return Qnil;
 }
 
-// Yajl::Encoder
+/*
+ * Document-class: Yajl::Encoder
+ *
+ * This class contains methods for encoding a Ruby object into JSON, streaming it's output into an IO object.
+ * The IO object need only respond to #write(str)
+ * The JSON stream created is written to the IO in chunks, as it's being created.
+ */
+
+/*
+ * Document-method: new
+ *
+ * call-seq: new([:pretty => false[, :indent => '  ']])
+ *
+ * :pretty will enable/disable beautifying or "pretty priting" the output string.
+ *
+ * :indent is the character(s) used to indent the output string.
+ */
 static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass) {
     yajl_gen_config cfg;
     yajl_gen encoder;
@@ -342,27 +457,61 @@ static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass) {
     return obj;
 }
 
+/*
+ * Document-method: initialize
+ *
+ * call-seq: initialize([:pretty => false[, :indent => '  ']])
+ *
+ * :pretty will enable/disable beautifying or "pretty priting" the output string.
+ *
+ * :indent is the character(s) used to indent the output string.
+ */
 static VALUE rb_yajl_encoder_init(int argc, VALUE * argv, VALUE self) {
     return self;
 }
 
-static VALUE rb_yajl_encoder_encode(VALUE self, VALUE obj, VALUE io) {
+/*
+ * Document-method: encode
+ *
+ * call-seq: encode(obj[, io[, &block]])
+ *
+ * +obj+ is the Ruby object to encode to JSON
+ *
+ * +io+ is an optional IO used to stream the encoded JSON string to.
+ * If +io+ isn't specified, this method will return the resulting JSON string. If +io+ is specified, this method returns nil
+ *
+ * If an optional block is passed, it's called when encoding is complete and passed the resulting JSON string
+ *
+ * It should be noted that you can reuse an instance of this class to continue encoding multiple JSON
+ * to the same stream. Just continue calling this method, passing it the same IO object with new/different
+ * ruby objects to encode. This is how streaming is accomplished.
+ */
+static VALUE rb_yajl_encoder_encode(int argc, VALUE * argv, VALUE self) {
     yajl_gen encoder;
     const unsigned char * buffer;
     unsigned int len;
-    VALUE outBuff;
+    VALUE obj, io, blk, outBuff;
     
     GetEncoder(self, encoder);
     
+    rb_scan_args(argc, argv, "11&", &obj, &io, &blk);
+    
     // begin encode process
     yajl_encode_part(encoder, obj, io);
 
     // just make sure we output the remaining buffer
     yajl_gen_get_buf(encoder, &buffer, &len);
     outBuff = rb_str_new((const char *)buffer, len);
-    rb_io_write(io, outBuff);
     yajl_gen_clear(encoder);
-    
+    if (io != Qnil) {
+        rb_io_write(io, outBuff);
+        return Qnil;
+    } else if (blk != Qnil) {
+        rb_funcall(blk, intern_call, 1, outBuff);
+        return Qnil;
+    } else {
+        return outBuff;
+    }
     return Qnil;
 }
 
@@ -372,6 +521,7 @@ void Init_yajl_ext() {
     
     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);
     
     cParser = rb_define_class_under(mYajl, "Parser", rb_cObject);
     rb_define_singleton_method(cParser, "new", rb_yajl_parser_new, -1);
@@ -384,7 +534,7 @@ void Init_yajl_ext() {
     cEncoder = rb_define_class_under(mYajl, "Encoder", rb_cObject);
     rb_define_singleton_method(cEncoder, "new", rb_yajl_encoder_new, -1);
     rb_define_method(cEncoder, "initialize", rb_yajl_encoder_init, -1);
-    rb_define_method(cEncoder, "encode", rb_yajl_encoder_encode, 2);
+    rb_define_method(cEncoder, "encode", rb_yajl_encoder_encode, -1);
     
     intern_io_read = rb_intern("read");
     intern_eof = rb_intern("eof?");
@@ -395,4 +545,5 @@ void Init_yajl_ext() {
     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

@@ -5,9 +5,9 @@
 #define READ_BUFSIZE 8092
 #define WRITE_BUFSIZE 8092
 
-static VALUE cParseError, mYajl, cParser, cEncoder;
+static VALUE cParseError, cEncodeError, mYajl, cParser, cEncoder;
 static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s,
-          sym_allow_comments, sym_check_utf8, sym_pretty, sym_indent;
+          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));
 #define GetEncoder(obj, sval) (sval = (yajl_gen*)DATA_PTR(obj));
@@ -15,6 +15,7 @@ static ID intern_io_read, intern_eof, intern_call, intern_keys, intern_to_s,
 inline void yajl_check_and_fire_callback(void * ctx);
 inline void yajl_set_static_value(void * ctx, VALUE val);
 void yajl_encode_part(yajl_gen hand, VALUE obj, VALUE io);
+void yajl_parse_chunk(const unsigned char * chunk, unsigned int len, yajl_handle parser);
 
 static int yajl_found_null(void * ctx);
 static int yajl_found_boolean(void * ctx, int boolean);
@@ -44,6 +45,8 @@ struct yajl_parser_wrapper {
     VALUE parse_complete_callback;
     int nestedArrayLevel;
     int nestedHashLevel;
+    int objectsFound;
+    int symbolizeKeys;
     yajl_handle parser;
 };
 static void yajl_parser_wrapper_free(void * wrapper);
@@ -57,4 +60,4 @@ 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(VALUE self, VALUE obj, VALUE io);
+static VALUE rb_yajl_encoder_encode(int argc, VALUE * argv, VALUE self);

data/lib/yajl/bzip2/stream_reader.rb

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 module Yajl
   module Bzip2
-    # === Yajl::Bzip2::StreamReader
-    #
     # This is a wrapper around Bzip::Reader to allow it's #read method to adhere
     # to the IO spec, allowing for two parameters (length, and buffer)
     class StreamReader < ::Bzip2::Reader
+      
+      # A helper method to allow use similar to IO#read
       def read(len=nil, buffer=nil)
         unless buffer.nil?
           buffer.replace super(len)
@@ -14,8 +14,15 @@ module Yajl
         super(len)
       end
 
-      def self.parse(io)
-        Yajl::Parser.new.parse(new(io))
+      # Helper method for one-off parsing from a bzip2-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+        
+        Yajl::Parser.new(options).parse(new(input), buffer_size, &block)
       end
     end
   end

data/lib/yajl/bzip2/stream_writer.rb

@@ -1,8 +1,12 @@
 # encoding: UTF-8
 module Yajl
   module Bzip2
-    # === Yajl::Bzip2::StreamWriter
+    # A wrapper around the Bzip2::Writer class for easier JSON stream encoding
     class StreamWriter < ::Bzip2::Writer
+      
+      # A helper method for encoding to a bzip2-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
       def self.encode(obj, io)
         Yajl::Encoder.new.encode(obj, new(io))
       end

data/lib/yajl/deflate/stream_reader.rb

@@ -1,25 +1,36 @@
 # encoding: UTF-8
 module Yajl
   module Deflate
-    # === Yajl::Deflate::StreamReader
-    #
     # This is a wrapper around Zlib::Inflate, creating a #read method that adheres
     # to the IO spec, allowing for two parameters (length, and buffer)
     class StreamReader < ::Zlib::Inflate
+      
+      # Wrapper to the initialize method so we can set the initial IO to parse from.
       def initialize(io, options)
         @io = io
         super(options)
       end
       
+      # A helper method to allow use similar to IO#read
       def read(len=nil, buffer=nil)
         buffer.replace inflate(@io.read(len)) and return unless buffer.nil?
         inflate(@io.read(len))
       end
-      
       alias :eof? :finished?
       
-      def self.parse(io, options=nil)
-        Yajl::Parser.new.parse(new(io, options))
+      # Helper method for one-off parsing from a deflate-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+        
+        if options.is_a?(Hash)
+          Yajl::Parser.new(options).parse(new(input), buffer_size, &block)
+        elsif options.is_a?(Fixnum)
+          Yajl::Parser.new.parse(new(input, options), buffer_size, &block)
+        end
       end
     end
   end

data/lib/yajl/deflate/stream_writer.rb

@@ -1,13 +1,18 @@
 # encoding: UTF-8
 module Yajl
   module Deflate
-    # === Yajl::Deflate::StreamWriter
+    # A wrapper around the Zlib::Deflate class for easier JSON stream parsing
     class StreamWriter < ::Zlib::Deflate
+      
+      # A helper method to allow use similar to IO#write
       def write(str)
         deflate(str)
         str.size unless str.nil?
       end
       
+      # A helper method for one-off encoding to a deflate-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
       def self.encode(obj, io)
         Yajl::Encoder.new.encode(obj, new(io))
       end

data/lib/yajl/gzip/stream_reader.rb

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 module Yajl
   module Gzip
-    # === Yajl::GzipStreamReader
-    #
     # This is a wrapper around Zlib::GzipReader to allow it's #read method to adhere
     # to the IO spec, allowing for two parameters (length, and buffer)
     class StreamReader < ::Zlib::GzipReader
+      
+      # Wrapper method to allow use similar to IO#read
       def read(len=nil, buffer=nil)
         unless buffer.nil?
           buffer.replace super(len)
@@ -14,8 +14,14 @@ module Yajl
         super(len)
       end
       
-      def self.parse(io)
-        Yajl::Parser.new.parse(new(io))
+      # Helper method for one-off parsing from a gzip-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+        Yajl::Parser.new(options).parse(new(input), buffer_size, &block)
       end
     end
   end

data/lib/yajl/gzip/stream_writer.rb

@@ -1,8 +1,11 @@
 # encoding: UTF-8
 module Yajl
   module Gzip
-    # === Yajl::Gzip::StreamWriter
+    # Wraper around the Zlib::GzipWriter class
     class StreamWriter < ::Zlib::GzipWriter
+      # A helper method for one-off encoding to a gzip-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
       def self.encode(obj, io)
         Yajl::Encoder.new.encode(obj, new(io))
       end

data/lib/yajl/http_stream.rb

@@ -3,13 +3,10 @@ require 'socket' unless defined?(Socket)
 require 'yajl' unless defined?(Yajl::Parser)
 
 module Yajl
-  # == Yajl::HttpStream
-  #
   # This module is for making HTTP requests to which the response bodies (and possibly requests in the near future)
   # are streamed directly into Yajl.
   class HttpStream
-    # === Yajl::HttpStream::InvalidContentType
-    #
+    
     # This Exception is thrown when an HTTP response isn't application/json
     # and therefore cannot be parsed.
     class InvalidContentType < Exception; end
@@ -22,8 +19,7 @@ module Yajl
     # 1. a raw socket is opened to the server/host provided
     # 2. the request is made using HTTP/1.0, Accept-encoding: gzip (deflate support coming soon, too)
     # 3. the response is read until the end of the headers
-    # 4. the _socket itself_ is passed directly to Yajl, for direct parsing off the stream;
-    #    As it's being received over the wire!
+    # 4. the _socket itself_ is passed directly to Yajl, for direct parsing off the stream; As it's being received over the wire!
     def self.get(uri, opts = {}, &block)
       user_agent = opts.has_key?(['User-Agent']) ? opts['User-Agent'] : "Yajl::HttpStream #{Yajl::VERSION}"
       

data/lib/yajl.rb

@@ -13,39 +13,65 @@ require 'yajl_ext'
 #
 # Ruby bindings to the excellent Yajl (Yet Another JSON Parser) ANSI C library.
 module Yajl
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
   
-  # == Yajl::Parser
-  #
-  # This class contains methods for parsing JSON directly from an IO object.
-  # The only basic requirment currently is that the IO object respond to #read(len) and #eof?
-  # The IO is parsed until a complete JSON object has been read and a ruby object will be returned.
   class Parser
-    def self.parse(io, options={})
-      new(options).parse(io)
+    # A helper method for parse-and-forget use-cases
+    #
+    # +io+ is the stream to parse JSON from
+    #
+    # The +options+ hash allows you to set two parsing options - :allow_comments and :check_utf8
+    #
+    # :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)
     end
   end
   
-  # == Yajl::Encoder
-  #
-  # This class contains methods for encoding a Ruby object into JSON, streaming it's output into an IO object.
-  # The IO object need only respond to #write(str)
-  # The JSON stream created is written to the IO in chunks, as it's being created.
   class Encoder
-    def self.encode(obj, io, options={})
-      new(options).encode(obj, io)
+    # A helper method for encode-and-forget use-cases
+    #
+    # Examples:
+    #   Yajl::Encoder.encode(obj[, io, :pretty => true, :indent => "\t"])
+    #
+    #   output = Yajl::Encoder.encode(obj[, :pretty => true, :indent => "\t"])
+    #
+    # +obj+ is a ruby object to encode to JSON format
+    #
+    # +io+ is the optional IO stream to encode the ruby object to.
+    # If +io+ isn't passed, the resulting JSON string is returned. If +io+ is passed, nil is returned.
+    #
+    # The +options+ hash allows you to set two encoding options - :pretty and :indent
+    #
+    # :pretty accepts a boolean and will enable/disable "pretty printing" the resulting output
+    #
+    # :indent accepts a string and will be used as the indent character(s) during the pretty print process
+    def self.encode(obj, *args, &block)
+      # TODO: this code smells, any ideas?
+      options = {}
+      io = nil
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          options = arg
+        elsif arg.respond_to?(:read)
+          io = arg
+        end
+      end if args.any?
+      new(options).encode(obj, io, &block)
     end
   end
   
-  # Deprecated - See Yajl::Parser and Yajl::Encoder
+  # DEPRECATED - See Yajl::Parser and Yajl::Encoder
   module Stream
-    # Deprecated - See Yajl::Parser
+    # 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)
     end
     
-    # Deprecated - See Yajl::Encoder
+    # 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)

data/spec/encoding/encoding_spec.rb

@@ -5,28 +5,57 @@ describe "Yajl JSON encoder" do
   FILES = Dir[File.dirname(__FILE__)+'/../../benchmark/subjects/*.json']
   
   FILES.each do |file|
-    it "should encode #{File.basename(file)}" do
+    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
-        parser = Yajl::Parser.new
         encoder = Yajl::Encoder.new
-      
-        hash = parser.parse(input)
-        output = encoder.encode(hash, io)
+        hash = Yajl::Parser.parse(input)
+        encoder.encode(hash, io)
         io.rewind
-        hash2 = parser.parse(io)
-      
+        hash2 = Yajl::Parser.parse(io)
         io.close
         input.close
-      
         hash.should == hash2
       end
     end
   end
   
-  it "should encode with :pretty turned on and a single space indent" do
+  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}\n"
     if RUBY_VERSION.include?('1.9') # FIXME
       output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}\n"
@@ -39,7 +68,18 @@ describe "Yajl JSON encoder" do
     io.read.should == output
   end
   
-  it "should encode with :pretty turned on and a tab character indent" do
+  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"
+    if RUBY_VERSION.include?('1.9') # FIXME
+      output = "{\n \"foo\": {\n  \"id\": 1234,\n  \"name\": \"bar\"\n }\n}\n"
+    end
+    obj = {:foo => {:id => 1234, :name => "bar"}}
+    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}\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"
@@ -52,7 +92,18 @@ describe "Yajl JSON encoder" do
     io.read.should == output
   end
   
-  it "should encode with it's class method with :pretty and a tab character indent options set" do
+  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"
+    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"
+    end
+    obj = {:foo => {:id => 1234, :name => "bar"}}
+    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}\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"
@@ -64,7 +115,31 @@ describe "Yajl JSON encoder" do
     io.read.should == output
   end
   
-  it "should encode multiple objects into a single stream" do
+  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"
+    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"
+    end
+    obj = {:foo => {:id => 1234, :name => "bar"}}
+    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}\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"
+    end
+    obj = {:foo => {:id => 1234, :name => "bar"}}
+    output = ''
+    Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t") do |json_str|
+      output = json_str
+    end
+    output.should == output
+  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}
     encoder = Yajl::Encoder.new
@@ -72,6 +147,25 @@ describe "Yajl JSON encoder" do
       encoder.encode(obj, io)
     end
     io.rewind
-    io.read.should == "{\"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 = "{\"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
+    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}
+    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
+    json_output.should == output
   end
 end

data/spec/parsing/active_support_spec.rb

@@ -35,18 +35,34 @@ describe "ActiveSupport test cases" do
   }
   
   TESTS.each do |json, expected|
-    it "should be able to parse #{json}" do
+    it "should be able to parse #{json} as an IO" do
       lambda {
         parser = Yajl::Parser.new
         parser.parse(StringIO.new(json)).should == expected
       }.should_not raise_error(Yajl::ParseError)
     end
   end
+  
+  TESTS.each do |json, expected|
+    it "should be able to parse #{json} as a string" do
+      lambda {
+        parser = Yajl::Parser.new
+        parser.parse(json).should == expected
+      }.should_not raise_error(Yajl::ParseError)
+    end
+  end
 
-  it "should fail parsing {: 1}" do
+  it "should fail parsing {: 1} as an IO" do
     lambda {
       parser = Yajl::Parser.new
       parser.parse(StringIO.new("{: 1}"))
     }.should raise_error(Yajl::ParseError)
   end
+  
+  it "should fail parsing {: 1} as a string" do
+    lambda {
+      parser = Yajl::Parser.new
+      parser.parse("{: 1}")
+    }.should raise_error(Yajl::ParseError)
+  end
 end

data/spec/parsing/chunked_spec.rb

@@ -4,7 +4,7 @@ require 'stringio'
 
 describe "Chunked parser" do
   before(:all) do
-    @final = [{"abc" => 123}, {"def" => 456}]
+    @final = [{:abc => 123}, {:def => 456}]
   end
   
   before(:each) do
@@ -67,6 +67,32 @@ describe "Chunked parser" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
     @callback.should_receive(:call).exactly(430).times
-    @parser.parse(json)
+    lambda {
+      @parser.parse(json)
+    }.should_not raise_error(Yajl::ParseError)
+  end
+  
+  it "should parse twitter_stream.json and fire callback 430 times, with a block as the callback" do
+    path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
+    json = File.new(path, 'r')
+    @callback.should_receive(:call).exactly(0).times
+    @parser.on_parse_complete = nil
+    lambda {
+      times = 0
+      @parser.parse(json) do |hsh|
+        times += 1
+      end
+      times.should eql(430)
+    }.should_not raise_error(Yajl::ParseError)
+  end
+  
+  it "should raise a Yajl::ParseError error if multiple JSON strings were found when no on_parse_complete callback assigned" do
+    path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
+    json = File.new(path, 'r')
+    @parser.on_parse_complete = nil
+    @callback.should_receive(:call).exactly(0).times
+    lambda {
+      @parser.parse(json)
+    }.should raise_error(Yajl::ParseError)
   end
 end

data/spec/parsing/fixtures_spec.rb

@@ -8,7 +8,7 @@ describe "Parsing JSON Fixtures" do
   FAILED = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
   
   FAILED.each do |name, source|
-    it "should not be able to parse #{File.basename(name)}" do
+    it "should not be able to parse #{File.basename(name)} as an IO" do
         lambda {
           parser = Yajl::Parser.new
           parser.parse(StringIO.new(source))
@@ -16,12 +16,30 @@ describe "Parsing JSON Fixtures" do
     end
   end
   
+  FAILED.each do |name, source|
+    it "should not be able to parse #{File.basename(name)} as a string" do
+        lambda {
+          parser = Yajl::Parser.new
+          parser.parse(source)
+        }.should raise_error(Yajl::ParseError)
+    end
+  end
+  
   PASSED.each do |name, source|
-    it "should be able to parse #{File.basename(name)}" do
+    it "should be able to parse #{File.basename(name)} as an IO" do
         lambda {
           parser = Yajl::Parser.new
           parser.parse(StringIO.new(source))
         }.should_not raise_error(Yajl::ParseError)
     end
   end
+  
+  PASSED.each do |name, source|
+    it "should be able to parse #{File.basename(name)} as a string" do
+        lambda {
+          parser = Yajl::Parser.new
+          parser.parse(source)
+        }.should_not raise_error(Yajl::ParseError)
+    end
+  end
 end

data/spec/parsing/one_off_spec.rb

@@ -6,7 +6,7 @@ describe "One-off JSON examples" do
     infinity = (1.0/0)
     silence_warnings do
       parser = Yajl::Parser.new
-      parser.parse(StringIO.new('{"key": 23456789012E666}')).should == {"key" => infinity}
+      parser.parse(StringIO.new('{"key": 23456789012E666}')).should == {:key => infinity}
     end
   end
   
@@ -27,17 +27,32 @@ describe "One-off JSON examples" do
   end
   
   it "should not parse invalid UTF8 with :check_utf8 set to true" do
-    pending
-    # not sure how to write this test yet
+    pending "not sure how to write this test yet"
   end
   
   it "should parse invalid UTF8 with :check_utf8 set to false" do
-    pending
-    # not sure how to write this test yet
+    pending "not sure how to write this test yet"
   end
   
-  it "should parse using it's class method" do
+  it "should parse using it's class method, from an IO" do
     io = StringIO.new('{"key": 1234}')
-    Yajl::Parser.parse(io).should == {"key" => 1234}
+    Yajl::Parser.parse(io).should == {:key => 1234}
+  end
+  
+  it "should parse using it's class method, from an IO with string keys" do
+    parser = Yajl::Parser.new(:symbolize_keys => true)
+    parser.parse('{"key": 1234}').should == {:key => 1234}
+  end
+  
+  it "should parse using it's class method, from a string" do
+    Yajl::Parser.parse('{"key": 1234}').should == {:key => 1234}
+  end
+  
+  it "should parse using it's class method, from a string with a block" do
+    output = nil
+    Yajl::Parser.parse('{"key": 1234}') do |obj|
+      output = obj
+    end
+    output.should == {:key => 1234}
   end
 end

data/yajl-ruby.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{yajl-ruby}
-  s.version = "0.5.2"
+  s.version = "0.5.3"
 
   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-05-30}
+  s.date = %q{2009-06-07}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = [
@@ -142,7 +142,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/brianmario/yajl-ruby}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib", "ext"]
-  s.rubygems_version = %q{1.3.3}
+  s.rubygems_version = %q{1.3.4}
   s.summary = %q{Ruby C bindings to the excellent Yajl JSON stream-based parser library.}
   s.test_files = [
     "spec/encoding/encoding_spec.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: brianmario-yajl-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors: 
 - Brian Lopez
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-30 00:00:00 -07:00
+date: 2009-06-07 00:00:00 -07:00
 default_executable: 
 dependencies: []