oj 2.18.5 → 3.0.0

data/ext/oj/strict.c

@@ -1,31 +1,6 @@
 /* strict.c
  * Copyright (c) 2012, Peter Ohler
  * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <stdlib.h>
@@ -160,13 +135,14 @@ VALUE
 oj_strict_parse(int argc, VALUE *argv, VALUE self) {
     struct _ParseInfo	pi;
 
+    parse_info_init(&pi);
     pi.options = oj_default_options;
     pi.handler = Qnil;
     pi.err_class = Qnil;
     oj_set_strict_callbacks(&pi);
 
     if (T_STRING == rb_type(*argv)) {
-	return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
+	return oj_pi_parse(argc, argv, &pi, 0, 0, true);
     } else {
 	return oj_pi_sparse(argc, argv, &pi, 0);
     }
@@ -176,10 +152,11 @@ VALUE
 oj_strict_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
     struct _ParseInfo	pi;
 
+    parse_info_init(&pi);
     pi.options = oj_default_options;
     pi.handler = Qnil;
     pi.err_class = Qnil;
     oj_set_strict_callbacks(&pi);
 
-    return oj_pi_parse(argc, argv, &pi, json, len, 1);
+    return oj_pi_parse(argc, argv, &pi, json, len, true);
 }

data/ext/oj/string_writer.c

@@ -0,0 +1,480 @@
+/* strwriter.c
+ * Copyright (c) 2012, 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "dump.h"
+#include "encode.h"
+
+extern VALUE	Oj;
+
+static void
+key_check(StrWriter sw, const char *key) {
+    DumpType	type = sw->types[sw->depth];
+
+    if (0 == key && (ObjectNew == type || ObjectType == type)) {
+	rb_raise(rb_eStandardError, "Can not push onto an Object without a key.");
+    }
+}
+
+static void
+push_type(StrWriter sw, DumpType type) {
+    if (sw->types_end <= sw->types + sw->depth + 1) {
+	size_t	size = (sw->types_end - sw->types) * 2;
+
+	REALLOC_N(sw->types, char, size);
+	sw->types_end = sw->types + size;
+    }
+    sw->depth++;
+    sw->types[sw->depth] = type;
+}
+
+static void
+maybe_comma(StrWriter sw) {
+    switch (sw->types[sw->depth]) {
+    case ObjectNew:
+	sw->types[sw->depth] = ObjectType;
+	break;
+    case ArrayNew:
+	sw->types[sw->depth] = ArrayType;
+	break;
+    case ObjectType:
+    case ArrayType:
+	// Always have a few characters available in the out.buf.
+	*sw->out.cur++ = ',';
+	break;
+    }
+}
+
+// Used by stream writer also.
+void
+oj_str_writer_init(StrWriter sw) {
+    sw->opts = oj_default_options;
+    sw->depth = 0;
+    sw->types = ALLOC_N(char, 256);
+    sw->types_end = sw->types + 256;
+    *sw->types = '\0';
+    sw->keyWritten = 0;
+
+    sw->out.buf = ALLOC_N(char, 4096);
+    sw->out.end = sw->out.buf + 4086;
+    sw->out.allocated = 1;
+    sw->out.cur = sw->out.buf;
+    *sw->out.cur = '\0';
+    sw->out.circ_cnt = 0;
+    sw->out.hash_cnt = 0;
+    sw->out.opts = &sw->opts;
+    sw->out.indent = sw->opts.indent;
+    sw->out.depth = 0;
+}
+
+void
+oj_str_writer_push_key(StrWriter sw, const char *key) {
+    DumpType	type = sw->types[sw->depth];
+    long	size;
+
+    if (sw->keyWritten) {
+	rb_raise(rb_eStandardError, "Can not push more than one key before pushing a non-key.");
+    }
+    if (ObjectNew != type && ObjectType != type) {
+	rb_raise(rb_eStandardError, "Can only push a key onto an Object.");
+    }
+    size = sw->depth * sw->out.indent + 3;
+    assure_size(&sw->out, size);
+    maybe_comma(sw);
+    if (0 < sw->depth) {
+	fill_indent(&sw->out, sw->depth);
+    }
+    oj_dump_cstr(key, strlen(key), 0, 0, &sw->out);
+    *sw->out.cur++ = ':';
+    sw->keyWritten = 1;
+}
+
+void
+oj_str_writer_push_object(StrWriter sw, const char *key) {
+    if (sw->keyWritten) {
+	sw->keyWritten = 0;
+	assure_size(&sw->out, 1);
+    } else {
+	long	size;
+
+	key_check(sw, key);
+	size = sw->depth * sw->out.indent + 3;
+	assure_size(&sw->out, size);
+	maybe_comma(sw);
+	if (0 < sw->depth) {
+	    fill_indent(&sw->out, sw->depth);
+	}
+	if (0 != key) {
+	    oj_dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	    *sw->out.cur++ = ':';
+	}
+    }
+    *sw->out.cur++ = '{';
+    push_type(sw, ObjectNew);
+}
+
+void
+oj_str_writer_push_array(StrWriter sw, const char *key) {
+    if (sw->keyWritten) {
+	sw->keyWritten = 0;
+	assure_size(&sw->out, 1);
+    } else {
+	long	size;
+
+	key_check(sw, key);
+	size = sw->depth * sw->out.indent + 3;
+	assure_size(&sw->out, size);
+	maybe_comma(sw);
+	if (0 < sw->depth) {
+	    fill_indent(&sw->out, sw->depth);
+	}
+	if (0 != key) {
+	    oj_dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	    *sw->out.cur++ = ':';
+	}
+    }
+    *sw->out.cur++ = '[';
+    push_type(sw, ArrayNew);
+}
+
+void
+oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
+    if (sw->keyWritten) {
+	sw->keyWritten = 0;
+    } else {
+	long	size;
+
+	key_check(sw, key);
+	size = sw->depth * sw->out.indent + 3;
+	assure_size(&sw->out, size);
+	maybe_comma(sw);
+	if (0 < sw->depth) {
+	    fill_indent(&sw->out, sw->depth);
+	}
+	if (0 != key) {
+	    oj_dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	    *sw->out.cur++ = ':';
+	}
+    }
+    oj_dump_comp_val(val, sw->depth, &sw->out, 0, 0, true);
+}
+
+void
+oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
+    if (sw->keyWritten) {
+	sw->keyWritten = 0;
+    } else {
+	long	size;
+
+	key_check(sw, key);
+	size = sw->depth * sw->out.indent + 3;
+	assure_size(&sw->out, size);
+	maybe_comma(sw);
+	if (0 < sw->depth) {
+	    fill_indent(&sw->out, sw->depth);
+	}
+	if (0 != key) {
+	    oj_dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	    *sw->out.cur++ = ':';
+	}
+    }
+    oj_dump_raw(json, strlen(json), &sw->out);
+}
+
+void
+oj_str_writer_pop(StrWriter sw) {
+    long	size;
+    DumpType	type = sw->types[sw->depth];
+
+    if (sw->keyWritten) {
+	sw->keyWritten = 0;
+	rb_raise(rb_eStandardError, "Can not pop after writing a key but no value.");
+    }
+    sw->depth--;
+    if (0 > sw->depth) {
+	rb_raise(rb_eStandardError, "Can not pop with no open array or object.");
+    }
+    size = sw->depth * sw->out.indent + 2;
+    assure_size(&sw->out, size);
+    fill_indent(&sw->out, sw->depth);
+    switch (type) {
+    case ObjectNew:
+    case ObjectType:
+	*sw->out.cur++ = '}';
+	break;
+    case ArrayNew:
+    case ArrayType:
+	*sw->out.cur++ = ']';
+	break;
+    }
+    if (0 == sw->depth && 0 <= sw->out.indent) {
+	*sw->out.cur++ = '\n';
+    }
+}
+
+void
+oj_str_writer_pop_all(StrWriter sw) {
+    while (0 < sw->depth) {
+	oj_str_writer_pop(sw);
+    }
+}
+
+static void
+str_writer_free(void *ptr) {
+    StrWriter	sw;
+
+    if (0 == ptr) {
+	return;
+    }
+    sw = (StrWriter)ptr;
+    xfree(sw->out.buf);
+    xfree(sw->types);
+    xfree(ptr);
+}
+
+/* Document-method: new
+ * call-seq: new(io, options)
+ *
+ * Creates a new StringWriter.
+ * - *io* [_IO_] stream to write to
+ * - *options* [_Hash_] formating options
+ */
+static VALUE
+str_writer_new(int argc, VALUE *argv, VALUE self) {
+    StrWriter	sw = ALLOC(struct _StrWriter);
+    
+    oj_str_writer_init(sw);
+    if (1 == argc) {
+	oj_parse_options(argv[0], &sw->opts);
+    }
+    sw->out.indent = sw->opts.indent;
+
+    return Data_Wrap_Struct(oj_string_writer_class, 0, str_writer_free, sw);
+}
+
+/* Document-method: push_key
+ * call-seq: push_key(key)
+ *
+ * Pushes a key onto the JSON document. The key will be used for the next push
+ * if currently in a JSON object and ignored otherwise. If a key is provided on
+ * the next push then that new key will be ignored.
+ * - *key* [_String_] the key pending for the next push
+ */
+static VALUE
+str_writer_push_key(VALUE self, VALUE key) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+
+    rb_check_type(key, T_STRING);
+    oj_str_writer_push_key(sw, StringValuePtr(key));
+
+    return Qnil;
+}
+
+/* Document-method: push_object
+ * call-seq: push_object(key=nil)
+ *
+ * Pushes an object onto the JSON document. Future pushes will be to this object
+ * until a pop() is called.
+ * - *key* [_String_] the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_object(int argc, VALUE *argv, VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_object(sw, 0);
+	break;
+    case 1:
+	if (Qnil == argv[0]) {
+	    oj_str_writer_push_object(sw, 0);
+	} else {
+	    rb_check_type(argv[0], T_STRING);
+	    oj_str_writer_push_object(sw, StringValuePtr(argv[0]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    if (rb_block_given_p()) {
+	rb_yield(Qnil);
+	oj_str_writer_pop(sw);
+    }
+    return Qnil;
+}
+
+/* Document-method: push_array
+ * call-seq: push_array(key=nil)
+ *
+ * Pushes an array onto the JSON document. Future pushes will be to this object
+ * until a pop() is called.
+ * - *key* [_String_] the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_array(int argc, VALUE *argv, VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_array(sw, 0);
+	break;
+    case 1:
+	if (Qnil == argv[0]) {
+	    oj_str_writer_push_array(sw, 0);
+	} else {
+	    rb_check_type(argv[0], T_STRING);
+	    oj_str_writer_push_array(sw, StringValuePtr(argv[0]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    if (rb_block_given_p()) {
+	rb_yield(Qnil);
+	oj_str_writer_pop(sw);
+    }
+    return Qnil;
+}
+
+/* Document-method: push_value
+ * call-seq: push_value(value, key=nil)
+ *
+ * Pushes a value onto the JSON document.
+ * - *value* [_Object_] value to add to the JSON document
+ * - *key* [_String_] the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_value(int argc, VALUE *argv, VALUE self) {
+    switch (argc) {
+    case 1:
+	oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
+	break;
+    case 2:
+	if (Qnil == argv[1]) {
+	    oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
+	} else {
+	    rb_check_type(argv[1], T_STRING);
+	    oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'.");
+	break;
+    }
+    return Qnil;
+}
+
+/* Document-method: push_json
+ * call-seq: push_json(value, key=nil)
+ *
+ * Pushes a string onto the JSON document. The String must be a valid JSON
+ * encoded string. No additional checking is done to verify the validity of the
+ * string.
+ * - *value* [_Object_] value to add to the JSON document
+ * - *key* [_String_] the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_json(int argc, VALUE *argv, VALUE self) {
+    rb_check_type(argv[0], T_STRING);
+    switch (argc) {
+    case 1:
+	oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
+	break;
+    case 2:
+	if (Qnil == argv[1]) {
+	    oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
+	} else {
+	    rb_check_type(argv[1], T_STRING);
+	    oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'.");
+	break;
+    }
+    return Qnil;
+}
+/* Document-method: pop
+ * call-seq: pop()
+ *
+ * Pops up a level in the JSON document closing the array or object that is
+ * currently open.
+ */
+static VALUE
+str_writer_pop(VALUE self) {
+    oj_str_writer_pop((StrWriter)DATA_PTR(self));
+    return Qnil;
+}
+
+/* Document-method: pop_all
+ * call-seq: pop_all()
+ *
+ * Pops all level in the JSON document closing all the array or object that is
+ * currently open.
+ */
+static VALUE
+str_writer_pop_all(VALUE self) {
+    oj_str_writer_pop_all((StrWriter)DATA_PTR(self));
+
+    return Qnil;
+}
+
+/* Document-method: reset
+ * call-seq: reset()
+ *
+ * Reset the writer back to the empty state.
+ */
+static VALUE
+str_writer_reset(VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+
+    sw->depth = 0;
+    *sw->types = '\0';
+    sw->keyWritten = 0;
+    sw->out.cur = sw->out.buf;
+    *sw->out.cur = '\0';
+
+    return Qnil;
+}
+
+/* Document-method: to_s
+ * call-seq: to_s()
+ *
+ * Returns the JSON document string in what ever state the construction is at.
+ *
+ * *return* [_String_]
+ */
+static VALUE
+str_writer_to_s(VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+    VALUE	rstr = rb_str_new(sw->out.buf, sw->out.cur - sw->out.buf);
+
+    return oj_encode(rstr);
+}
+
+/* Document-class: Oj::StringWriter
+ * 
+ * Supports building a JSON document one element at a time. Build the document
+ * by pushing values into the document. Pushing an array or an object will
+ * create that element in the JSON document and subsequent pushes will add the
+ * elements to that array or object until a pop() is called. When complete
+ * calling to_s() will return the JSON document. Note tha calling to_s() before
+ * construction is complete will return the document in it's current state.
+ */
+void
+oj_string_writer_init() {
+    oj_string_writer_class = rb_define_class_under(Oj, "StringWriter", rb_cObject);
+    rb_define_module_function(oj_string_writer_class, "new", str_writer_new, -1);
+    rb_define_method(oj_string_writer_class, "push_key", str_writer_push_key, 1);
+    rb_define_method(oj_string_writer_class, "push_object", str_writer_push_object, -1);
+    rb_define_method(oj_string_writer_class, "push_array", str_writer_push_array, -1);
+    rb_define_method(oj_string_writer_class, "push_value", str_writer_push_value, -1);
+    rb_define_method(oj_string_writer_class, "push_json", str_writer_push_json, -1);
+    rb_define_method(oj_string_writer_class, "pop", str_writer_pop, 0);
+    rb_define_method(oj_string_writer_class, "pop_all", str_writer_pop_all, 0);
+    rb_define_method(oj_string_writer_class, "reset", str_writer_reset, 0);
+    rb_define_method(oj_string_writer_class, "to_s", str_writer_to_s, 0);
+}