wankel 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d39a95397c69844f5192789cd5df648a8e9a8b47
-  data.tar.gz: 62d409b5d77f50cb3747ea8bf2cc18e38fa271a0
+  metadata.gz: f6571c0e2472dab431e07ca8ee912e4a88b5319d
+  data.tar.gz: 50aeba78c777dd142181126b1fefba3480a200e1
 SHA512:
-  metadata.gz: efd5c840d75fef714ed9f3483107f3ab18938630f21f025567586496afb3f92067842e2694c79b59ff3b42d2425177a3ab1cf9c6482ddc19c635819886622976
-  data.tar.gz: be6ee04733bc4f3a02e1402fba54ec017559a258564b4da7768c77b5925b40cb800d17f5f33739dd74a62081ba84ae3446c171089df3bd1973c3f6f019e41a80
+  metadata.gz: 7d49e4dc10b8a3cccdfec412531226b5e4ccbba35a30c9b148edda091c42ef7c54aa7b368aef8930f46bd6b1fbf4214f1e29414e459d8078ae17ae7756b00433
+  data.tar.gz: 8e0a6915521e4d9c7d5d27f580324a60074fe17d3e38078b2c9225e33b188c7abe4b88668fa8021d7827e4474f4afd67ef920847d65c34c44e101daab40fdcd4

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 New Features:
 
+Major Changes:
+
+Minor Changes:
+
+Bugfixes:
+
+## 0.5.0 (December 24th, 2014)
+
+- Renaming of `Wankel::SaxEncoder` and `Wankel::SaxParser` to
+  `Wankel::StreamEncoder` and `Wankel::StreamParser`.
+
+## 0.4.0 (December 23rd, 2014)
+
+New Features:
+
 - Added `Wankel::SaxEncoder#value(VALUE)`
 - Abilitly to change the output stream of a `Wankel::SaxEncoder` during generation
   via `Wankel::SaxEncoder#output=`
@@ -10,10 +25,6 @@ Major Changes:
 
 - `Wankel::SaxEncoder#complete` changed to `Wankel::SaxEncoder#flush`
 
-Minor Changes:
-
-Bugfixes:
-
 ## 0.3.0 (August 18th, 2014)
 
 Major Changes:

data/README.md

@@ -1,18 +1,19 @@
 <a href="http://wanklerb.com">![Wankel](/logo.png)</a>
 
-[![Circle CI](https://circleci.com/gh/malomalo/wankel/tree/master.svg?style=svg)](https://circleci.com/gh/malomalo/wankel/tree/master)
+
+Wankel [![Build Status](https://travis-ci.org/malomalo/wankel.svg?branch=master)](https://travis-ci.org/malomalo/wankel)
+--------
 
 **Wankel** is a Ruby gem that provides C bindings to the
 [YAJL 2](http://lloyd.github.io/yajl/) C Library.
 
 Wankel provides gerneral parsing and encoding to and from
-[JSON](http://json.org/), but also a SAX style parser and encoder for streaming
-parsing and generation.
+[JSON](http://json.org/), but also a streaming parser and encoder.
 
 Features
 --------
 
-* SAX style JSON parsing and encoding
+* Streaming JSON parsing and encoding
 * JSON parsing and encoding directly to and from an IO stream (file, socket, etc)
   or String.
 * Parse and encode *multiple* JSON objects to and from streams or strings
@@ -53,10 +54,10 @@ Wankel.encode({"key" => "value"})
 # => '{"key":"value"}'
 ```
 
-#### Sax Parser Example
+#### Streaming Parser Example
 
 ```ruby
-class SimpleParser < Wankel::SaxParser
+class SimpleParser < Wankel::StreamParser
   def on_array_start
     puts "Array start"
   end
@@ -72,11 +73,11 @@ parser.parse('["string1", null, "string2"]')
 # => "string2"
 ```
 
-#### Sax Encoder Example
+#### Streaming Encoder Example
 
 ```ruby
 output = StringIO.new
-encoder = Wankel::SaxEncoder.new(output)
+encoder = Wankel::StreamEncoder.new(output)
 encoder.map_open
 encoder.string("key")
 encoder.number(123)

data/ext/wankel/wankel.c

@@ -44,7 +44,7 @@ void Init_wankel() {
     
     c_wankelParser = Init_wankel_parser();
     c_wankelEncoder = Init_wankel_encoder();
-    Init_wankel_sax_parser();
-    Init_wankel_sax_encoder();
+    Init_wankel_stream_parser();
+    Init_wankel_stream_encoder();
     Init_yajl_helpers();
 }

data/ext/wankel/wankel.h

@@ -8,8 +8,8 @@
 
 #include "wankel_parser.h"
 #include "wankel_encoder.h"
-#include "wankel_sax_parser.h"
-#include "wankel_sax_encoder.h"
+#include "wankel_stream_parser.h"
+#include "wankel_stream_encoder.h"
 #include "yajl_helpers.h"
 
 void Init_wankel();

data/ext/wankel/wankel_encoder.c

@@ -1,4 +1,4 @@
-// TODO: i should use the Wankel::SaxEncoder?
+// TODO: i should use the Wankel::StreamEncoder?
 #include "wankel_encoder.h"
 
 static VALUE c_wankel, c_wankelEncoder, e_encodeError;

data/ext/wankel/{wankel_sax_encoder.c → wankel_stream_encoder.c}

@@ -1,4 +1,4 @@
-#include "wankel_sax_encoder.h"
+#include "wankel_stream_encoder.h"
 
 typedef struct {
     yajl_gen g;
@@ -6,22 +6,22 @@ typedef struct {
 	int write_buffer_size;
 } wankel_encoder;
 
-static VALUE wankelSaxEncoder_initialize(int argc, VALUE * argv, VALUE self);
-static VALUE wankelSaxEncoder_number(VALUE self, VALUE number);
-static VALUE wankelSaxEncoder_string(VALUE self, VALUE string);
-static VALUE wankelSaxEncoder_null(VALUE self);
-static VALUE wankelSaxEncoder_boolean(VALUE self, VALUE b);
-static VALUE wankelSaxEncoder_map_open(VALUE self);
-static VALUE wankelSaxEncoder_map_close(VALUE self);
-static VALUE wankelSaxEncoder_array_open(VALUE self);
-static VALUE wankelSaxEncoder_array_close(VALUE self);
-static VALUE wankelSaxEncoder_flush(VALUE self);
-static void wankelSaxEncoder_write_buffer(wankel_encoder * p);
-static VALUE wankel_sax_encoder_alloc(VALUE klass);
-static void wankel_sax_encoder_free(void * handle);
-static void wankel_sax_encoder_mark(void * handle);
-
-static VALUE c_wankel, c_wankelSaxEncoder, e_encodeError;
+static VALUE wankelStreamEncoder_initialize(int argc, VALUE * argv, VALUE self);
+static VALUE wankelStreamEncoder_number(VALUE self, VALUE number);
+static VALUE wankelStreamEncoder_string(VALUE self, VALUE string);
+static VALUE wankelStreamEncoder_null(VALUE self);
+static VALUE wankelStreamEncoder_boolean(VALUE self, VALUE b);
+static VALUE wankelStreamEncoder_map_open(VALUE self);
+static VALUE wankelStreamEncoder_map_close(VALUE self);
+static VALUE wankelStreamEncoder_array_open(VALUE self);
+static VALUE wankelStreamEncoder_array_close(VALUE self);
+static VALUE wankelStreamEncoder_flush(VALUE self);
+static void wankelStreamEncoder_write_buffer(wankel_encoder * p);
+static VALUE wankel_stream_encoder_alloc(VALUE klass);
+static void wankel_stream_encoder_free(void * handle);
+static void wankel_stream_encoder_mark(void * handle);
+
+static VALUE c_wankel, c_wankelStreamEncoder, e_encodeError;
 
 static ID intern_to_s, intern_keys, intern_io_write, intern_to_json, intern_clone, intern_merge, intern_DEFAULTS;
 
@@ -47,7 +47,7 @@ static ID sym_beautify, sym_indent_string, sym_validate_utf8, sym_escape_solidus
  *                   it in the iterest of saving bytes. Setting this flag will
  *                   cause YAJL to always escape '/' in generated JSON strings.
  */
-static VALUE wankelSaxEncoder_initialize(int argc, VALUE * argv, VALUE self) {
+static VALUE wankelStreamEncoder_initialize(int argc, VALUE * argv, VALUE self) {
     VALUE defaults = rb_const_get(c_wankel, intern_DEFAULTS);
     VALUE io, options;
 	wankel_encoder * p;
@@ -80,7 +80,7 @@ static VALUE wankelSaxEncoder_initialize(int argc, VALUE * argv, VALUE self) {
     return self;
 }
 
-static VALUE wankelSaxEncoder_change_io(VALUE self, VALUE io) {
+static VALUE wankelStreamEncoder_change_io(VALUE self, VALUE io) {
     wankel_encoder * p;
     
     if (!rb_respond_to(io, intern_io_write)) {
@@ -89,13 +89,13 @@ static VALUE wankelSaxEncoder_change_io(VALUE self, VALUE io) {
 
     Data_Get_Struct(self, wankel_encoder, p);
         
-    wankelSaxEncoder_flush(self);
+    wankelStreamEncoder_flush(self);
     p->output = io;
     
     return Qnil;
 }
 
-static VALUE wankelSaxEncoder_number(VALUE self, VALUE number) {
+static VALUE wankelStreamEncoder_number(VALUE self, VALUE number) {
     size_t len;
     const char * cptr;
 	wankel_encoder * p;
@@ -113,12 +113,12 @@ static VALUE wankelSaxEncoder_number(VALUE self, VALUE number) {
     status = yajl_gen_number(p->g, cptr, len);
 	yajl_helper_check_gen_status(status);
 
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_string(VALUE self, VALUE string) {
+static VALUE wankelStreamEncoder_string(VALUE self, VALUE string) {
     size_t len;
     const char * cptr;
 	wankel_encoder * p;
@@ -133,12 +133,12 @@ static VALUE wankelSaxEncoder_string(VALUE self, VALUE string) {
     status = yajl_gen_string(p->g, (const unsigned char *)cptr, len);
 	yajl_helper_check_gen_status(status);
 
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_null(VALUE self) {
+static VALUE wankelStreamEncoder_null(VALUE self) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -146,12 +146,12 @@ static VALUE wankelSaxEncoder_null(VALUE self) {
     status = yajl_gen_null(p->g);
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_boolean(VALUE self, VALUE b) {
+static VALUE wankelStreamEncoder_boolean(VALUE self, VALUE b) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -159,12 +159,12 @@ static VALUE wankelSaxEncoder_boolean(VALUE self, VALUE b) {
 	status = yajl_gen_bool(p->g, RTEST(b));
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_map_open(VALUE self) {
+static VALUE wankelStreamEncoder_map_open(VALUE self) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -172,12 +172,12 @@ static VALUE wankelSaxEncoder_map_open(VALUE self) {
     status = yajl_gen_map_open(p->g);
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_map_close(VALUE self) {
+static VALUE wankelStreamEncoder_map_close(VALUE self) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -185,12 +185,12 @@ static VALUE wankelSaxEncoder_map_close(VALUE self) {
     status = yajl_gen_map_close(p->g);
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_array_open(VALUE self) {
+static VALUE wankelStreamEncoder_array_open(VALUE self) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -198,12 +198,12 @@ static VALUE wankelSaxEncoder_array_open(VALUE self) {
     status = yajl_gen_array_open(p->g);
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_array_close(VALUE self) {
+static VALUE wankelStreamEncoder_array_close(VALUE self) {
 	wankel_encoder * p;
 	yajl_gen_status status;
     Data_Get_Struct(self, wankel_encoder, p);
@@ -211,12 +211,12 @@ static VALUE wankelSaxEncoder_array_close(VALUE self) {
     status = yajl_gen_array_close(p->g);
 	yajl_helper_check_gen_status(status);
 	
-	wankelSaxEncoder_write_buffer(p);
+	wankelStreamEncoder_write_buffer(p);
 	
 	return Qnil;
 }
 
-static VALUE wankelSaxEncoder_flush(VALUE self) {
+static VALUE wankelStreamEncoder_flush(VALUE self) {
     size_t len;
 	VALUE rbBuffer;
 	wankel_encoder * p;
@@ -235,7 +235,7 @@ static VALUE wankelSaxEncoder_flush(VALUE self) {
 	return Qnil;
 }
 
-void wankelSaxEncoder_write_buffer(wankel_encoder * p) {
+void wankelStreamEncoder_write_buffer(wankel_encoder * p) {
 	VALUE rbBuffer;
     yajl_gen_status status;
     const unsigned char * buffer;
@@ -252,23 +252,23 @@ void wankelSaxEncoder_write_buffer(wankel_encoder * p) {
 	}
 }
 
-void Init_wankel_sax_encoder() {
+void Init_wankel_stream_encoder() {
     c_wankel = rb_const_get(rb_cObject, rb_intern("Wankel"));
-    c_wankelSaxEncoder = rb_define_class_under(c_wankel, "SaxEncoder", rb_cObject);
+    c_wankelStreamEncoder = rb_define_class_under(c_wankel, "StreamEncoder", rb_cObject);
     e_encodeError = rb_const_get(c_wankel, rb_intern("EncodeError"));
 
-	rb_define_alloc_func(c_wankelSaxEncoder, wankel_sax_encoder_alloc);
-    rb_define_method(c_wankelSaxEncoder, "initialize", wankelSaxEncoder_initialize, -1);
-    rb_define_method(c_wankelSaxEncoder, "number", wankelSaxEncoder_number, 1);
-    rb_define_method(c_wankelSaxEncoder, "string", wankelSaxEncoder_string, 1);
-    rb_define_method(c_wankelSaxEncoder, "null", wankelSaxEncoder_null, 0);
-    rb_define_method(c_wankelSaxEncoder, "boolean", wankelSaxEncoder_boolean, 1);
-    rb_define_method(c_wankelSaxEncoder, "map_open", wankelSaxEncoder_map_open, 0);
-    rb_define_method(c_wankelSaxEncoder, "map_close", wankelSaxEncoder_map_close, 0);
-    rb_define_method(c_wankelSaxEncoder, "array_open", wankelSaxEncoder_array_open, 0);
-    rb_define_method(c_wankelSaxEncoder, "array_close", wankelSaxEncoder_array_close, 0);
-    rb_define_method(c_wankelSaxEncoder, "flush", wankelSaxEncoder_flush, 0);
-    rb_define_method(c_wankelSaxEncoder, "output=", wankelSaxEncoder_change_io, 1);
+	rb_define_alloc_func(c_wankelStreamEncoder, wankel_stream_encoder_alloc);
+    rb_define_method(c_wankelStreamEncoder, "initialize", wankelStreamEncoder_initialize, -1);
+    rb_define_method(c_wankelStreamEncoder, "number", wankelStreamEncoder_number, 1);
+    rb_define_method(c_wankelStreamEncoder, "string", wankelStreamEncoder_string, 1);
+    rb_define_method(c_wankelStreamEncoder, "null", wankelStreamEncoder_null, 0);
+    rb_define_method(c_wankelStreamEncoder, "boolean", wankelStreamEncoder_boolean, 1);
+    rb_define_method(c_wankelStreamEncoder, "map_open", wankelStreamEncoder_map_open, 0);
+    rb_define_method(c_wankelStreamEncoder, "map_close", wankelStreamEncoder_map_close, 0);
+    rb_define_method(c_wankelStreamEncoder, "array_open", wankelStreamEncoder_array_open, 0);
+    rb_define_method(c_wankelStreamEncoder, "array_close", wankelStreamEncoder_array_close, 0);
+    rb_define_method(c_wankelStreamEncoder, "flush", wankelStreamEncoder_flush, 0);
+    rb_define_method(c_wankelStreamEncoder, "output=", wankelStreamEncoder_change_io, 1);
 
     
 	intern_to_s = rb_intern("to_s");
@@ -285,22 +285,22 @@ void Init_wankel_sax_encoder() {
 }
 
 // Ruby GC ===================================================================
-static VALUE wankel_sax_encoder_alloc(VALUE klass) {
+static VALUE wankel_stream_encoder_alloc(VALUE klass) {
 	VALUE self;
     wankel_encoder * p;
-	self = Data_Make_Struct(klass, wankel_encoder, wankel_sax_encoder_mark, wankel_sax_encoder_free, p);
+	self = Data_Make_Struct(klass, wankel_encoder, wankel_stream_encoder_mark, wankel_stream_encoder_free, p);
 	p->g = 0;
 	return self;
 }
 
-static void wankel_sax_encoder_free(void * handle) {
+static void wankel_stream_encoder_free(void * handle) {
     wankel_encoder * p = handle;
 	if (p->g){
 		yajl_gen_free(p->g);
 	}
 }
 
-static void wankel_sax_encoder_mark(void * handle) {
+static void wankel_stream_encoder_mark(void * handle) {
     wankel_encoder * p = handle;
     rb_gc_mark(p->output);
 }

data/ext/wankel/{wankel_sax_encoder.h → wankel_stream_encoder.h}

@@ -1,5 +1,5 @@
-#ifndef WANKEL_SAX_ENCODER
-#define WANKEL_SAX_ENCODER
+#ifndef WANKEL_STREAM_ENCODER
+#define WANKEL_STREAM_ENCODER
 
 #include <ruby.h>
 #include <ruby/encoding.h>
@@ -8,6 +8,6 @@
 
 #include "yajl_helpers.h"
 
-void Init_wankel_sax_encoder();
+void Init_wankel_stream_encoder();
 
 #endif

data/ext/wankel/{wankel_sax_parser.c → wankel_stream_parser.c}

@@ -1,6 +1,6 @@
-#include "wankel_sax_parser.h"
+#include "wankel_stream_parser.h"
 
-static VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self);
+static VALUE stream_parser_initialize(int argc, VALUE * argv, VALUE self);
 
 static ID  sym_read_buffer_size, sym_symbolize_keys;
 
@@ -10,30 +10,30 @@ static ID  intern_on_null, intern_on_boolean, intern_on_integer,
     intern_on_double, intern_on_string, intern_on_map_start, intern_on_map_key,
     intern_on_map_end, intern_on_array_start, intern_on_array_end;
 	
-static VALUE c_wankel, c_wankelParser, c_saxParser, e_parseError, e_encodeError;
+static VALUE c_wankel, c_wankelParser, c_streamParser, e_parseError, e_encodeError;
 		   
 // Callbacks =================================================================
-yajl_callbacks sax_parser_callbacks(VALUE self);
-int sax_parser_callback_on_null(void *ctx);
-int sax_parser_callback_on_boolean(void *ctx, int boolVal);
-int sax_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen);
-int sax_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen);
-int sax_parser_callback_on_map_start(void *ctx);
-int sax_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen);
-int sax_parser_callback_on_map_end(void *ctx);
-int sax_parser_callback_on_array_start(void *ctx);
-int sax_parser_callback_on_array_end(void *ctx);
+yajl_callbacks stream_parser_callbacks(VALUE self);
+int stream_parser_callback_on_null(void *ctx);
+int stream_parser_callback_on_boolean(void *ctx, int boolVal);
+int stream_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen);
+int stream_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen);
+int stream_parser_callback_on_map_start(void *ctx);
+int stream_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen);
+int stream_parser_callback_on_map_end(void *ctx);
+int stream_parser_callback_on_array_start(void *ctx);
+int stream_parser_callback_on_array_end(void *ctx);
 
 // Ruby GC ===================================================================
-VALUE sax_parser_alloc(VALUE);
-//void sax_parser_mark(void *);
-void sax_parser_free(void * parser);
+VALUE stream_parser_alloc(VALUE);
+//void stream_parser_mark(void *);
+void stream_parser_free(void * parser);
 
-VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self) {
+VALUE stream_parser_initialize(int argc, VALUE * argv, VALUE self) {
     VALUE defaults = rb_const_get(c_wankel, intern_DEFAULTS);
     VALUE klass = rb_funcall(self, rb_intern("class"), 0);
     VALUE options, rbufsize;
-    sax_parser * p;
+    stream_parser * p;
 
     rb_scan_args(argc, argv, "01", &options);
     if (rb_const_defined(klass, intern_DEFAULTS)) { 
@@ -47,8 +47,8 @@ VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self) {
     }
     options = rb_iv_get(self, "@options");
 
-    Data_Get_Struct(self, sax_parser, p);
-    p->callbacks = sax_parser_callbacks(self);
+    Data_Get_Struct(self, stream_parser, p);
+    p->callbacks = stream_parser_callbacks(self);
     p->alloc_funcs.malloc = yajl_helper_malloc;
     p->alloc_funcs.realloc = yajl_helper_realloc;
     p->alloc_funcs.free = yajl_helper_free;
@@ -69,13 +69,13 @@ VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self) {
     return self;
 }
 
-static VALUE sax_parser_parse(int argc, VALUE * argv, VALUE self) {
+static VALUE stream_parser_parse(int argc, VALUE * argv, VALUE self) {
     const char * cptr;
     size_t len;
     yajl_status status;
-    sax_parser * p;
+    stream_parser * p;
     VALUE input;
-    Data_Get_Struct(self, sax_parser, p);
+    Data_Get_Struct(self, stream_parser, p);
 	
     rb_scan_args(argc, argv, "10", &input);
     if (TYPE(input) == T_STRING) {
@@ -101,12 +101,12 @@ static VALUE sax_parser_parse(int argc, VALUE * argv, VALUE self) {
     return Qnil;
 }
 
-static VALUE sax_parser_write(VALUE self, VALUE input) {
+static VALUE stream_parser_write(VALUE self, VALUE input) {
     const char * cptr;
     size_t len;
     yajl_status status;
-    sax_parser * p;
-    Data_Get_Struct(self, sax_parser, p);
+    stream_parser * p;
+    Data_Get_Struct(self, stream_parser, p);
     
     Check_Type(input, T_STRING);
     cptr = RSTRING_PTR(input);
@@ -117,10 +117,10 @@ static VALUE sax_parser_write(VALUE self, VALUE input) {
     return Qnil;
 }
 
-static VALUE sax_parser_complete(VALUE self) {
+static VALUE stream_parser_complete(VALUE self) {
     yajl_status status;
-    sax_parser * p;
-    Data_Get_Struct(self, sax_parser, p);
+    stream_parser * p;
+    Data_Get_Struct(self, stream_parser, p);
     
 
     status = yajl_complete_parse(p->h);
@@ -129,20 +129,20 @@ static VALUE sax_parser_complete(VALUE self) {
     return Qnil;
 }
 
-void Init_wankel_sax_parser() {
+void Init_wankel_stream_parser() {
     c_wankel = rb_const_get(rb_cObject, rb_intern("Wankel"));
     c_wankelParser = rb_const_get(c_wankel, rb_intern("Parser"));
-    c_saxParser = rb_define_class_under(c_wankel, "SaxParser", rb_cObject);
+    c_streamParser = rb_define_class_under(c_wankel, "StreamParser", rb_cObject);
     e_parseError = rb_const_get(c_wankel, rb_intern("ParseError"));
     e_encodeError = rb_const_get(c_wankel, rb_intern("EncodeError"));
     
-    rb_define_alloc_func(c_saxParser, sax_parser_alloc);
-    rb_define_method(c_saxParser, "initialize", sax_parser_initialize, -1);
-    rb_define_method(c_saxParser, "parse", sax_parser_parse, -1);
-    rb_define_method(c_saxParser, "write", sax_parser_write, 1);
-    rb_define_method(c_saxParser, "complete", sax_parser_complete, 0);
+    rb_define_alloc_func(c_streamParser, stream_parser_alloc);
+    rb_define_method(c_streamParser, "initialize", stream_parser_initialize, -1);
+    rb_define_method(c_streamParser, "parse", stream_parser_parse, -1);
+    rb_define_method(c_streamParser, "write", stream_parser_write, 1);
+    rb_define_method(c_streamParser, "complete", stream_parser_complete, 0);
     
-    rb_define_alias(c_saxParser, "<<", "write");
+    rb_define_alias(c_streamParser, "<<", "write");
     
     intern_merge = rb_intern("merge");
     intern_clone = rb_intern("clone");
@@ -164,52 +164,52 @@ void Init_wankel_sax_parser() {
 }
 
 // Callbacks =================================================================
-yajl_callbacks sax_parser_callbacks(VALUE self) {
+yajl_callbacks stream_parser_callbacks(VALUE self) {
     yajl_callbacks callbacks = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 
     if(rb_respond_to(self, intern_on_null)) {
-        callbacks.yajl_null = sax_parser_callback_on_null;
+        callbacks.yajl_null = stream_parser_callback_on_null;
     }
     if(rb_respond_to(self, intern_on_boolean)) {
-        callbacks.yajl_boolean = sax_parser_callback_on_boolean;
+        callbacks.yajl_boolean = stream_parser_callback_on_boolean;
     }
     if(rb_respond_to(self, intern_on_integer) || rb_respond_to(self, intern_on_double)) {
-        callbacks.yajl_number = sax_parser_callback_on_number;
+        callbacks.yajl_number = stream_parser_callback_on_number;
     }
     if(rb_respond_to(self, intern_on_string)) {
-        callbacks.yajl_string = sax_parser_callback_on_string;
+        callbacks.yajl_string = stream_parser_callback_on_string;
     }
 
     if(rb_respond_to(self, intern_on_map_start)) {
-        callbacks.yajl_start_map = sax_parser_callback_on_map_start;
+        callbacks.yajl_start_map = stream_parser_callback_on_map_start;
     }
     if(rb_respond_to(self, intern_on_map_key)) {
-        callbacks.yajl_map_key = sax_parser_callback_on_map_key;
+        callbacks.yajl_map_key = stream_parser_callback_on_map_key;
     }
     if(rb_respond_to(self, intern_on_map_end)) {
-        callbacks.yajl_end_map = sax_parser_callback_on_map_end;
+        callbacks.yajl_end_map = stream_parser_callback_on_map_end;
      }
     if(rb_respond_to(self, intern_on_array_start)) {
-        callbacks.yajl_start_array = sax_parser_callback_on_array_start;
+        callbacks.yajl_start_array = stream_parser_callback_on_array_start;
     }
     if(rb_respond_to(self, intern_on_array_end)) {
-        callbacks.yajl_end_array = sax_parser_callback_on_array_end;
+        callbacks.yajl_end_array = stream_parser_callback_on_array_end;
     }
 
     return callbacks;
 }
 
-int sax_parser_callback_on_null(void *ctx) {
+int stream_parser_callback_on_null(void *ctx) {
     rb_funcall((VALUE)ctx, intern_on_null, 0);
     return 1;
 }
 
-int sax_parser_callback_on_boolean(void *ctx, int boolVal) {
+int stream_parser_callback_on_boolean(void *ctx, int boolVal) {
     rb_funcall((VALUE)ctx, intern_on_boolean, 1, (boolVal ? Qtrue : Qfalse));
     return 1;
 }
 
-int sax_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen) {
+int stream_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen) {
 	char buf[numberLen+1];
 	buf[numberLen] = 0;
 	memcpy(buf, numberVal, numberLen);
@@ -227,38 +227,38 @@ int sax_parser_callback_on_number(void *ctx, const char * numberVal, size_t numb
 	return 1;
 }
 
-int sax_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen) {
+int stream_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen) {
     rb_funcall((VALUE)ctx, intern_on_string, 1, rb_str_new((const char *) stringVal, stringLen));
     return 1;
 }
-int sax_parser_callback_on_map_start(void *ctx) {
+int stream_parser_callback_on_map_start(void *ctx) {
     rb_funcall((VALUE)ctx, intern_on_map_start, 0);
     return 1;
 }
-int sax_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen) {
+int stream_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen) {
     rb_funcall((VALUE)ctx, intern_on_map_key, 1, rb_str_new((const char *)key, keyLen));
     return 1;
 }
-int sax_parser_callback_on_map_end(void *ctx) {
+int stream_parser_callback_on_map_end(void *ctx) {
     rb_funcall((VALUE)ctx, intern_on_map_end, 0);
     return 1;
 }
-int sax_parser_callback_on_array_start(void *ctx) {
+int stream_parser_callback_on_array_start(void *ctx) {
     rb_funcall((VALUE)ctx, intern_on_array_start, 0);
     return 1;
 }
-int sax_parser_callback_on_array_end(void *ctx) {
+int stream_parser_callback_on_array_end(void *ctx) {
     rb_funcall((VALUE)ctx, intern_on_array_end, 0);
     return 1;
 }
 
 // Ruby GC ===================================================================
-VALUE sax_parser_alloc(VALUE klass) {
-    sax_parser * p;
-    return Data_Make_Struct(klass, sax_parser, 0, sax_parser_free, p);
+VALUE stream_parser_alloc(VALUE klass) {
+    stream_parser * p;
+    return Data_Make_Struct(klass, stream_parser, 0, stream_parser_free, p);
 }
 
-void sax_parser_free(void * handle) {
-    sax_parser * p = handle;
+void stream_parser_free(void * handle) {
+    stream_parser * p = handle;
 	yajl_free(p->h);
 }

data/ext/wankel/{wankel_sax_parser.h → wankel_stream_parser.h}

@@ -1,5 +1,5 @@
-#ifndef WANKEL_SAX_PARSER
-#define WANKEL_SAX_PARSER
+#ifndef WANKEL_STREAM_PARSER
+#define WANKEL_STREAM_PARSER
 
 #include <ruby.h>
 #include <ruby/encoding.h>
@@ -9,7 +9,7 @@
 #include "wankel.h"
 #include "yajl_helpers.h"
 
-void Init_wankel_sax_parser();
+void Init_wankel_stream_parser();
 
 typedef struct {
     yajl_handle h;
@@ -17,7 +17,7 @@ typedef struct {
     yajl_alloc_funcs alloc_funcs;
     int symbolize_keys;
     VALUE rbufsize;
-} sax_parser;
+} stream_parser;
 
 
 #endif

data/lib/wankel.rb

@@ -18,7 +18,7 @@ class Wankel
     }
 end
 
-class Wankel::SaxEncoder
+class Wankel::StreamEncoder
   
   def value(val)
     case val

data/test/encoding/sax_encoder_test.rb

@@ -1,11 +1,11 @@
 require 'test_helper'
 require 'stringio'
 
-class Wankel::SaxEncoderTest < Minitest::Test
+class Wankel::StreamEncoderTest < Minitest::Test
   
   def setup
     @output = StringIO.new
-    @encoder = Wankel::SaxEncoder.new(@output)
+    @encoder = Wankel::StreamEncoder.new(@output)
   end
   
   def assert_output(value)
@@ -13,12 +13,12 @@ class Wankel::SaxEncoderTest < Minitest::Test
   end
   
   test 'default inherited from Wankel' do
-      encoder = Wankel::SaxEncoder.new(StringIO.new)
+      encoder = Wankel::StreamEncoder.new(StringIO.new)
       assert_equal(Wankel::DEFAULTS, encoder.instance_variable_get("@options"))
   end
   
   test 'default options merged with options inherited from Wankel && Class' do
-      encoder = Wankel::SaxEncoder.new(StringIO.new, :hello => true, :metoo => false)
+      encoder = Wankel::StreamEncoder.new(StringIO.new, :hello => true, :metoo => false)
       assert_equal(Wankel::DEFAULTS.merge({:hello => true, :metoo => false}), encoder.instance_variable_get("@options"))
   end
 
@@ -146,7 +146,7 @@ class Wankel::SaxEncoderTest < Minitest::Test
     output = StringIO.new
     
     # Set large write_buffer_size to test flush
-    encoder = Wankel::SaxEncoder.new(output, :write_buffer_size => 1_000_000)
+    encoder = Wankel::StreamEncoder.new(output, :write_buffer_size => 1_000_000)
     encoder.value({key: "value"})
     
     assert_equal("", output.string)
@@ -159,7 +159,7 @@ class Wankel::SaxEncoderTest < Minitest::Test
     output2 = StringIO.new
     
     # Set large write_buffer_size to test flush
-    encoder = Wankel::SaxEncoder.new(output1, :write_buffer_size => 1_000_000)
+    encoder = Wankel::StreamEncoder.new(output1, :write_buffer_size => 1_000_000)
     encoder.map_open
     encoder.string("key")
     encoder.string("value")

data/test/parsing/sax_parser_test.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 require 'test_helper'
 
-class TestParser < Wankel::SaxParser
+class TestParser < Wankel::StreamParser
   def on_map_start
   end
   def on_map_end
@@ -24,7 +24,7 @@ class TestParser < Wankel::SaxParser
   end
 end
 
-class Wankel::SaxParserTest < Minitest::Test
+class Wankel::StreamParserTest < Minitest::Test
   
   test 'default inherited from Wankel' do
       parser = TestParser.new
@@ -32,7 +32,7 @@ class Wankel::SaxParserTest < Minitest::Test
   end
   
   test 'default inherited from Wankel && Class' do
-      class TestParser2 < Wankel::SaxParser
+      class TestParser2 < Wankel::StreamParser
         DEFAULTS = {:hello => true}
       end
       
@@ -41,7 +41,7 @@ class Wankel::SaxParserTest < Minitest::Test
   end
   
   test 'default options merged with options inherited from Wankel && Class' do
-      class TestParser3 < Wankel::SaxParser
+      class TestParser3 < Wankel::StreamParser
         DEFAULTS = {:hello => true}
       end
       

data/wankel.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
   s.name        = 'wankel'
-  s.version     = '0.4.0'
+  s.version     = '0.5.0'
   s.licenses    = ['MIT']
   s.authors     = ['Jon Bracy']
   s.email       = ['jonbracy@gmail.com']
   s.homepage    = 'http://wankelrb.com'
-  s.summary     = 'SAX based JSON parser and encoder'
+  s.summary     = 'Streaming JSON parser and encoder'
   s.description = 'A JSON parser that enables streaming parsing and encoding of JSON'
   
   s.files = `git ls-files`.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wankel
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jon Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-23 00:00:00.000000000 Z
+date: 2014-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -93,10 +93,10 @@ files:
 - ext/wankel/wankel_encoder.h
 - ext/wankel/wankel_parser.c
 - ext/wankel/wankel_parser.h
-- ext/wankel/wankel_sax_encoder.c
-- ext/wankel/wankel_sax_encoder.h
-- ext/wankel/wankel_sax_parser.c
-- ext/wankel/wankel_sax_parser.h
+- ext/wankel/wankel_stream_encoder.c
+- ext/wankel/wankel_stream_encoder.h
+- ext/wankel/wankel_stream_parser.c
+- ext/wankel/wankel_stream_parser.h
 - ext/wankel/yajl_helpers.c
 - ext/wankel/yajl_helpers.h
 - lib/wankel.rb
@@ -192,7 +192,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: SAX based JSON parser and encoder
+summary: Streaming JSON parser and encoder
 test_files:
 - test/encoding/encoding_test.rb
 - test/encoding/sax_encoder_test.rb