yaji 0.2.3-x86-mingw32 → 0.3.0-x86-mingw32

data/HISTORY.markdown

@@ -1,3 +1,8 @@
+=== 0.3.0 / 2012-04-18
+
+* Allow to specify filter at parser initialization
+* Implement feeding of the input on the fly
+
 === 0.2.3 / 2012-04-10
 
 * Add build for Windows

data/ext/yaji/parser_ext.c

@@ -156,6 +156,8 @@ static int yaji_end_array(void *ctx)
 	return STATUS_CONTINUE;
 }
 
+static VALUE rb_yaji_each_iter(VALUE chunk, VALUE* params_p);
+
 static VALUE rb_yaji_parser_parse_chunk(VALUE chunk, VALUE self)
 {
 	yajl_status rc;
@@ -175,7 +177,16 @@ static VALUE rb_yaji_parser_parse_chunk(VALUE chunk, VALUE self)
 		RERAISE_PARSER_ERROR(p);
 	}
 	for (i=0; i<RARRAY_LEN(p->events); i++) {
-		rb_funcall(p->parser_cb, id_call, 1, RARRAY_PTR(p->events)[i]);
+		if (NIL_P(p->input)) {
+			VALUE params[4];
+			params[0] = p->on_object_cb;
+			params[1] = p->object_stack;
+			params[2] = p->filter;
+			params[3] = p->with_path ? Qtrue : Qfalse;
+			rb_yaji_each_iter(RARRAY_PTR(p->events)[i], params);
+		} else {
+			rb_funcall(p->parser_cb, id_call, 1, RARRAY_PTR(p->events)[i]);
+		}
 	}
 	return rb_funcall(chunk, id_bytesize, 0, NULL);
 }
@@ -190,18 +201,27 @@ static VALUE rb_yaji_parser_new(int argc, VALUE *argv, VALUE klass)
 	p->config.allowComments = 1;
 	p->config.checkUTF8 = 1;
 	p->symbolize_keys = 0;
+	p->with_path = 0;
+	p->filter = Qnil;
 	p->rbufsize = Qnil;
 	p->input = Qnil;
 	p->parser_cb = Qnil;
+	p->on_object_cb = Qnil;
 
-	rb_scan_args(argc, argv, "11", &p->input, &opts);
-	if (TYPE(p->input) == T_STRING) {
-		p->input = rb_class_new_instance(1, &p->input, c_stringio);
-	} else if (rb_respond_to(p->input, id_perform) && rb_respond_to(p->input, id_on_body)) {
-		rb_block_call(p->input, id_on_body, 0, NULL, rb_yaji_parser_parse_chunk, obj);
-	} else if (!rb_respond_to(p->input, id_read)) {
-		rb_raise(c_parse_error, "input must be a String or IO or "
-				"something responding to #perform and #on_body e.g. Curl::Easy");
+	rb_scan_args(argc, argv, "02", &p->input, &opts);
+	if (NIL_P(opts) && TYPE(p->input) == T_HASH) {
+		opts = p->input;
+		p->input = Qnil;
+	}
+	if (!NIL_P(p->input)) {
+		if (TYPE(p->input) == T_STRING) {
+			p->input = rb_class_new_instance(1, &p->input, c_stringio);
+		} else if (rb_respond_to(p->input, id_perform) && rb_respond_to(p->input, id_on_body)) {
+			rb_block_call(p->input, id_on_body, 0, NULL, rb_yaji_parser_parse_chunk, obj);
+		} else if (!rb_respond_to(p->input, id_read)) {
+			rb_raise(c_parse_error, "input must be a String or IO or "
+				 "something responding to #perform and #on_body e.g. Curl::Easy");
+		}
 	}
 	if (!NIL_P(opts)) {
 		Check_Type(opts, T_HASH);
@@ -215,12 +235,20 @@ static VALUE rb_yaji_parser_new(int argc, VALUE *argv, VALUE klass)
 			p->symbolize_keys = 1;
 		}
 		p->rbufsize = rb_hash_aref(opts, sym_read_buffer_size);
+		if (rb_hash_aref(opts, sym_with_path) == Qtrue) {
+			p->with_path = 1;
+		}
+		p->filter = rb_hash_aref(opts, sym_filter);
 	}
 	if (NIL_P(p->rbufsize)) {
 		p->rbufsize = INT2FIX(READ_BUFSIZE);
 	} else {
 		Check_Type(p->rbufsize, T_FIXNUM);
 	}
+	p->object_stack = rb_ary_new();
+	p->path = rb_ary_new();
+	rb_ary_push(p->path, rb_str_new("", 0));
+	p->path_str = rb_str_new("", 0);
 	p->handle = yajl_alloc(&yaji_callbacks, &p->config, NULL, (void *)obj);
 	rb_obj_call_init(obj, 0, 0);
 	return obj;
@@ -229,8 +257,22 @@ static VALUE rb_yaji_parser_new(int argc, VALUE *argv, VALUE klass)
 static VALUE rb_yaji_parser_init(int argc, VALUE *argv, VALUE self)
 {
 	return self;
+	(void)argc;
+	(void)argv;
 }
 
+static VALUE rb_yaji_parser_write(VALUE self, VALUE val)
+{
+	yaji_parser* p = (yaji_parser*) DATA_PTR(self);
+
+	if (NIL_P(p->on_object_cb)) {
+		rb_raise(rb_eArgError, "#on_object callback required");
+	}
+	if (!NIL_P(val)) {
+		Check_Type(val, T_STRING);
+	}
+	return rb_yaji_parser_parse_chunk(val, self);
+}
 
 static VALUE rb_yaji_parser_parse(int argc, VALUE* argv, VALUE self)
 {
@@ -238,12 +280,12 @@ static VALUE rb_yaji_parser_parse(int argc, VALUE* argv, VALUE self)
 	yaji_parser* p = (yaji_parser*) DATA_PTR(self);
 	int i;
 
+	if (NIL_P(p->input)) {
+		rb_raise(rb_eArgError, "input object required to use #parse method");
+	}
 	rb_scan_args(argc, argv, "00&", &p->parser_cb);
 	RETURN_ENUMERATOR(self, argc, argv);
 
-	p->path = rb_ary_new();
-	rb_ary_push(p->path, rb_str_new("", 0));
-	p->path_str = rb_str_new("", 0);
 	p->chunk = Qnil;
 
 	if (rb_respond_to(p->input, id_perform)) {
@@ -270,20 +312,20 @@ static VALUE rb_yaji_parser_parse(int argc, VALUE* argv, VALUE self)
 	return Qnil;
 }
 
-static int rb_yaji_str_start_with(VALUE str, VALUE query)
+static int rb_yaji_str_start_with(VALUE str, VALUE filter)
 {
 	int i;
 	const char *ptr = RSTRING_PTR(str);
-	int len = RSTRING_LEN(str);
+	long len = RSTRING_LEN(str);
 	VALUE entry;
 
-	switch(TYPE(query)) {
+	switch(TYPE(filter)) {
 	case T_STRING:
-		return RSTRING_LEN(query) <= len && memcmp(RSTRING_PTR(query), ptr, RSTRING_LEN(query)) == 0;
+		return RSTRING_LEN(filter) <= len && memcmp(RSTRING_PTR(filter), ptr, RSTRING_LEN(filter)) == 0;
 		break;
 	case T_ARRAY:
-		for (i=0; i<RARRAY_LEN(query); i++) {
-			entry = RARRAY_PTR(query)[i];
+		for (i=0; i<RARRAY_LEN(filter); i++) {
+			entry = RARRAY_PTR(filter)[i];
 			if (RSTRING_LEN(entry) <= len && memcmp(RSTRING_PTR(entry), ptr, RSTRING_LEN(entry)) == 0) {
 				return 1;
 			}
@@ -301,11 +343,11 @@ static VALUE rb_yaji_each_iter(VALUE chunk, VALUE* params_p)
 	VALUE value = rb_ary_shift(chunk);
 	VALUE proc = params[0];
 	VALUE stack = params[1];
-	VALUE query = params[2];
+	VALUE filter = params[2];
 	VALUE with_path = params[3];
 	VALUE last_entry, object, container, key, hash;
 
-	if (NIL_P(query) || rb_yaji_str_start_with(path, query)) {
+	if (NIL_P(filter) || rb_yaji_str_start_with(path, filter)) {
 		if (event == sym_hash_key) {
 			rb_ary_push(stack, value);
 		} else if (event == sym_start_hash || event == sym_start_array) {
@@ -356,17 +398,29 @@ static VALUE rb_yaji_each_iter(VALUE chunk, VALUE* params_p)
 
 static VALUE rb_yaji_parser_each(int argc, VALUE* argv, VALUE self)
 {
-	VALUE query, proc, options, params[4];
+	VALUE filter, proc, options, params[4];
+	yaji_parser* p = (yaji_parser*) DATA_PTR(self);
+
+	if (NIL_P(p->input)) {
+		rb_raise(rb_eArgError, "input object required to use #each method");
+	}
 	RETURN_ENUMERATOR(self, argc, argv);
-	rb_scan_args(argc, argv, "02&", &query, &options, &proc);
+	rb_scan_args(argc, argv, "02&", &filter, &options, &proc);
 	params[0] = proc;	    // callback
 	params[1] = rb_ary_new();   // stack
-	params[2] = query;
+	if (NIL_P(filter)) {
+		params[2] = p->filter;
+	} else {
+		params[2] = filter;
+	}
+	params[3] = p->with_path ? Qtrue : Qfalse;
 	if (options != Qnil) {
+		VALUE arg;
 		Check_Type(options, T_HASH);
-		params[3] = rb_hash_aref(options, sym_with_path);
-	} else {
-		params[3] = Qnil;
+		arg = rb_hash_aref(options, sym_with_path);
+		if (!NIL_P(arg)) {
+			params[3] = arg;
+		}
 	}
 	rb_block_call(self, id_parse, 0, NULL, rb_yaji_each_iter, (VALUE)params);
 	return Qnil;
@@ -383,6 +437,16 @@ static void rb_yaji_parser_free(void *parser)
 	}
 }
 
+static VALUE rb_yaji_parser_on_object(VALUE self)
+{
+	yaji_parser *p = DATA_PTR(self);
+
+	if (rb_block_given_p()) {
+		p->on_object_cb = rb_block_proc();
+	}
+	return p->on_object_cb;
+}
+
 static void rb_yaji_parser_mark(void *parser)
 {
 	yaji_parser* p = parser;
@@ -409,6 +473,9 @@ void Init_parser_ext() {
 	rb_define_method(c_yaji_parser, "initialize", rb_yaji_parser_init, -1);
 	rb_define_method(c_yaji_parser, "parse", rb_yaji_parser_parse, -1);
 	rb_define_method(c_yaji_parser, "each", rb_yaji_parser_each, -1);
+	rb_define_method(c_yaji_parser, "on_object", rb_yaji_parser_on_object, 0);
+	rb_define_method(c_yaji_parser, "write", rb_yaji_parser_write, 1);
+	rb_define_alias(c_yaji_parser, "<<", "write");
 
 	id_call = rb_intern("call");
 	id_read = rb_intern("read");
@@ -423,6 +490,7 @@ void Init_parser_ext() {
 	sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
 	sym_read_buffer_size = ID2SYM(rb_intern("read_buffer_size"));
 	sym_with_path = ID2SYM(rb_intern("with_path"));
+	sym_filter = ID2SYM(rb_intern("filter"));
 	sym_null = ID2SYM(rb_intern("null"));
 	sym_boolean = ID2SYM(rb_intern("boolean"));
 	sym_number = ID2SYM(rb_intern("number"));

data/ext/yaji/parser_ext.h

@@ -45,7 +45,7 @@ static ID id_call, id_read, id_parse, id_perform, id_on_body, id_bytesize, id_st
 static ID sym_allow_comments, sym_check_utf8, sym_symbolize_keys, sym_with_path,
 	  sym_read_buffer_size, sym_null, sym_boolean, sym_number, sym_string,
 	  sym_hash_key, sym_start_hash, sym_end_hash, sym_start_array,
-	  sym_end_array;
+	  sym_end_array, sym_filter;
 
 static int yaji_null(void *ctx);
 static int yaji_boolean(void *ctx, int val);
@@ -74,6 +74,7 @@ static yajl_callbacks yaji_callbacks = {
 typedef struct {
 	int symbolize_keys;
 	int key_in_use;
+	int with_path;
 	VALUE input;
 	VALUE rbufsize;
 	VALUE events;
@@ -81,6 +82,9 @@ typedef struct {
 	VALUE path_str;
 	VALUE parser_cb;
 	VALUE chunk;
+	VALUE filter;
+	VALUE on_object_cb;
+	VALUE object_stack;
 	yajl_handle handle;
 	yajl_parser_config config;
 } yaji_parser;

data/lib/yaji/version.rb

@@ -18,5 +18,5 @@
 #
 
 module YAJI
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/test/test_parser.rb

@@ -196,7 +196,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_equal expected, objects
   end
 
-  def test_it_optionally_yeilds_object_path
+  def test_it_optionally_yields_object_path
     parser = YAJI::Parser.new(toys_json_str)
     objects = []
     parser.each(["/total_rows", "/rows/"], :with_path => true) do |o|
@@ -216,6 +216,28 @@ class TestParser < MiniTest::Unit::TestCase
     assert_equal expected, objects
   end
 
+  def test_it_allows_to_specify_filter_and_options_at_initialization
+    parser = YAJI::Parser.new(toys_json_str,
+                              :filter => ["/total_rows", "/rows/"],
+                              :with_path => true)
+    objects = []
+    parser.each do |o|
+      objects << o
+    end
+    expected = [["/total_rows", 2],
+                ["/rows/", {
+                  "id" => "buzz",
+                  "props" => { "humanoid"=> true, "armed"=> true },
+                  "movies" => [1,2,3]
+                }],
+                ["/rows/", {
+                  "id" => "barbie",
+                  "props" => { "humanoid"=> true, "armed"=> false },
+                  "movies" => [2,3]
+                }]]
+    assert_equal expected, objects
+  end
+
   def test_it_doesnt_raise_exception_on_empty_input
     YAJI::Parser.new("").parse
     YAJI::Parser.new("  ").parse
@@ -223,9 +245,82 @@ class TestParser < MiniTest::Unit::TestCase
     YAJI::Parser.new(" \n\n ").parse
   end
 
+  def test_it_allows_to_create_parser_without_input
+    YAJI::Parser.new
+    YAJI::Parser.new(:filter => 'test')
+    YAJI::Parser.new(:with_path => true)
+  end
+
+  def test_it_raises_argument_error_for_parser_without_input
+    parser = YAJI::Parser.new
+    assert_raises(ArgumentError) do
+      parser.parse
+    end
+    assert_raises(ArgumentError) do
+      parser.each{|x| }
+    end
+  end
+
+  def test_it_raises_argument_error_on_write_without_callback_set_up
+    parser = YAJI::Parser.new
+    assert_raises(ArgumentError) do
+      parser.write('{"hello":"world"}')
+    end
+  end
+
+  def test_it_allows_to_feed_the_data_on_the_fly
+    parser = YAJI::Parser.new(:filter => '/rows/')
+
+    objects = []
+    parser.on_object do |obj|
+      objects << obj
+    end
+
+    parser.write(<<-JSON)
+      {
+        "total_rows": 2,
+        "rows": [
+          {
+    JSON
+    parser.write(<<-JSON)
+            "id": "buzz",
+            "props": {
+              "humanoid": true,
+              "armed": true
+            },
+            "movies": [1,2,3]
+          },
+    JSON
+    data = <<-JSON
+          {
+            "id": "barbie",
+            "props": {
+              "humanoid": true,
+              "armed": false
+            },
+            "movies": [2,3]
+          }
+        ]
+      }
+    JSON
+    parser << data
+
+    expected = [{
+                  "id" => "buzz",
+                  "props" => { "humanoid"=> true, "armed"=> true },
+                  "movies" => [1,2,3]
+                },
+                {
+                  "id" => "barbie",
+                  "props" => { "humanoid"=> true, "armed"=> false },
+                  "movies" => [2,3]
+                }]
+    assert_equal expected, objects
+  end
+
   def test_it_parses_chunked_data
     generator = Generator.new(['{"total_rows":', '0,"offset":0,"rows":[]', '}'])
-    iter = YAJI::Parser.new(generator).each(["total_rows", "rows/", "errors/"], :with_path => true)
+    iter = YAJI::Parser.new(generator).each(["total_rows", "/rows/", "/errors/"], :with_path => true)
     begin
       loop do
         iter.next
@@ -236,7 +331,7 @@ class TestParser < MiniTest::Unit::TestCase
 
   def test_it_skips_empty_chunks
     generator = Generator.new(['{"total_rows":', '0,"offset":0,"rows":[]', '}', '', nil])
-    iter = YAJI::Parser.new(generator).each(["total_rows", "rows/", "errors/"], :with_path => true)
+    iter = YAJI::Parser.new(generator).each(["total_rows", "/rows/", "/errors/"], :with_path => true)
     begin
       loop do
         iter.next

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaji
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: x86-mingw32
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-10 00:00:00.000000000Z
+date: 2012-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -152,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1814389335541304246
+      hash: -2453557434810599764
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -161,10 +161,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1814389335541304246
+      hash: -2453557434810599764
 requirements: []
 rubyforge_project: yaji
-rubygems_version: 1.8.18
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Yet another JSON iterator