oj 2.18.5 → 3.0.0

data/ext/oj/scp.c

@@ -1,31 +1,6 @@
 /* scp.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>
@@ -187,7 +162,9 @@ oj_sc_parse(int argc, VALUE *argv, VALUE self) {
     struct _ParseInfo	pi;
     VALUE		input = argv[1];
 
+    parse_info_init(&pi);
     pi.err_class = Qnil;
+    pi.max_depth = 0;
     pi.options = oj_default_options;
     if (3 == argc) {
 	oj_parse_options(argv[2], &pi.options);
@@ -237,6 +214,7 @@ oj_sc_parse(int argc, VALUE *argv, VALUE self) {
 	pi.add_value = noop_add_value;
 	pi.expect_value = 0;
     }
+    pi.has_callbacks = true;
 
     if (T_STRING == rb_type(input)) {
 	return oj_pi_parse(argc - 1, argv + 1, &pi, 0, 0, 1);

data/ext/oj/sparse.c

@@ -35,6 +35,7 @@
 #include <math.h>
 
 #include "oj.h"
+#include "encode.h"
 #include "parse.h"
 #include "buf.h"
 #include "hash.h" // for oj_strndup()
@@ -252,6 +253,17 @@ read_escaped_str(ParseInfo pi) {
 	    case '"':	buf_append(&buf, '"');	break;
 	    case '/':	buf_append(&buf, '/');	break;
 	    case '\\':	buf_append(&buf, '\\');	break;
+	    case '\'':
+		// The json gem claims this is not an error despite the
+		// ECMA-404 indicating it is not valid.
+		if (CompatMode == pi->options.mode) {
+		    buf_append(&buf, '\'');
+		} else {
+		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
+		    buf_cleanup(&buf);
+		    return;
+		}
+		break;
 	    case 'u':
 		if (0 == (code = read_hex(pi)) && err_has(&pi->err)) {
 		    buf_cleanup(&buf);
@@ -428,15 +440,22 @@ read_num(ParseInfo pi) {
 	c = reader_get(&pi->rd);
     }
     if ('I' == c) {
-	if (0 != reader_expect(&pi->rd, "nfinity")) {
+	if (No == pi->options.allow_nan) {
+	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+	    return;
+	} else if (0 != reader_expect(&pi->rd, "nfinity")) {
 	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
 	    return;
 	}
 	ni.infinity = 1;
     } else {
 	int	dec_cnt = 0;
+	bool	zero1 = false;
 
 	for (; '0' <= c && c <= '9'; c = reader_get(&pi->rd)) {
+	    if (0 == ni.i && '0' == c) {
+		zero1 = true;
+	    }
 	    if (0 < ni.i) {
 		dec_cnt++;
 	    }
@@ -445,6 +464,13 @@ read_num(ParseInfo pi) {
 	    } else {
 		int	d = (c - '0');
 
+		if (0 < d) {
+		    if (zero1 && CompatMode == pi->options.mode) {
+			oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
+			return;
+		    }
+		    zero1 = false;
+		}
 		ni.i = ni.i * 10 + d;
 		if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
 		    ni.big = 1;
@@ -453,6 +479,9 @@ read_num(ParseInfo pi) {
 	}
 	if ('.' == c) {
 	    c = reader_get(&pi->rd);
+	    if (c < '0' || '9' < c) {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
+	    }
 	    for (; '0' <= c && c <= '9'; c = reader_get(&pi->rd)) {
 		int	d = (c - '0');
 
@@ -616,9 +645,17 @@ void
 oj_sparse2(ParseInfo pi) {
     int		first = 1;
     char	c;
+    long	start = 0;
 
     err_init(&pi->err);
     while (1) {
+	if (0 < pi->max_depth && pi->max_depth <= pi->stack.tail - pi->stack.head - 1) {
+	    VALUE	err_clas = oj_get_json_err_class("NestingError");
+	    
+	    oj_set_error_at(pi, err_clas, __FILE__, __LINE__, "Too deeply nested.");
+	    pi->err_class = err_clas;
+	    return;
+	}
 	c = reader_next_non_white(&pi->rd);
 	if (!first && '\0' != c) {
 	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected characters after the JSON document");
@@ -657,12 +694,25 @@ oj_sparse2(ParseInfo pi) {
 	case '7':
 	case '8':
 	case '9':
-	case 'I':
 	    reader_backup(&pi->rd);
 	    read_num(pi);
 	    break;
+	case 'I':
+	    if (Yes == pi->options.allow_nan) {
+		reader_backup(&pi->rd);
+		read_num(pi);
+	    } else {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
+		return;
+	    }
+	    break;
 	case 'N':
-	    read_nan(pi);
+	    if (Yes == pi->options.allow_nan) {
+		read_nan(pi);
+	    } else {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
+		return;
+	    }
 	    break;
 	case 't':
 	    read_true(pi);
@@ -719,23 +769,28 @@ oj_sparse2(ParseInfo pi) {
 	}
 	if (stack_empty(&pi->stack)) {
 	    if (Qundef != pi->proc) {
+		VALUE	args[3];
+		long	len = pi->rd.pos - start;
+
+		*args = stack_head_val(&pi->stack);
+		args[1] = LONG2NUM(start);
+		args[2] = LONG2NUM(len);
+
 		if (Qnil == pi->proc) {
-		    rb_yield(stack_head_val(&pi->stack));
+		    rb_yield_values2(3, args);
 		} else {
 #if HAS_PROC_WITH_BLOCK
-		    VALUE	args[1];
-
-		    *args = stack_head_val(&pi->stack);
-		    rb_proc_call_with_block(pi->proc, 1, args, Qnil);
+		    rb_proc_call_with_block(pi->proc, 3, args, Qnil);
 #else
 		    oj_set_error_at(pi, rb_eNotImpError, __FILE__, __LINE__,
 				    "Calling a Proc with a block not supported in this version. Use func() {|x| } syntax instead.");
 		    return;
 #endif
 		}
-	    } else {
+	    } else if (!pi->has_callbacks) {
 		first = 0;
 	    }
+	    start = pi->rd.pos;
 	}
     }
 }
@@ -758,11 +813,19 @@ oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd) {
 	rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
     }
     input = argv[0];
-    if (2 == argc) {
-	oj_parse_options(argv[1], &pi->options);
+    if (2 <= argc) {
+	if (T_HASH == rb_type(argv[1])) {
+	    oj_parse_options(argv[1], &pi->options);
+	} else if (3 <= argc && T_HASH == rb_type(argv[2])) {
+	    oj_parse_options(argv[2], &pi->options);
+	}
     }
-    if (Qnil == input && Yes == pi->options.nilnil) {
-	return Qnil;
+    if (Qnil == input) {
+	if (Yes == pi->options.nilnil) {
+	    return Qnil;
+	} else {
+	    rb_raise(rb_eTypeError, "Nil is not a valid JSON source.");
+	}
     }
     if (rb_block_given_p()) {
 	pi->proc = Qnil;
@@ -829,6 +892,19 @@ oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd) {
 	if (Qnil != pi->err_class) {
 	    pi->err.clas = pi->err_class;
 	}
+	if (CompatMode == pi->options.mode) {
+	    // The json gem requires the error message be UTF-8 encoded. In
+	    // additional the complete JSON source should be returned but that
+	    // is not possible without stored all the bytes read and reading
+	    // the remaining bytes on the stream. Both seem like a very bad
+	    // idea.
+	    VALUE	args[] = { oj_encode(rb_str_new2(pi->err.msg)) };
+
+	    rb_exc_raise(rb_class_new_instance(1, args, pi->err.clas));
+	} else {
+	    oj_err_raise(&pi->err);
+	}
+
 	oj_err_raise(&pi->err);
     }
     return result;

data/ext/oj/stream_writer.c

@@ -0,0 +1,301 @@
+/* stream_writer.c
+ * Copyright (c) 2012, 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <errno.h>
+
+#include <ruby.h>
+
+#include "oj.h"
+
+extern VALUE	Oj;
+
+static void
+stream_writer_free(void *ptr) {
+    StreamWriter	sw;
+
+    if (0 == ptr) {
+	return;
+    }
+    sw = (StreamWriter)ptr;
+    xfree(sw->sw.out.buf);
+    xfree(sw->sw.types);
+    xfree(ptr);
+}
+
+static void
+stream_writer_write(StreamWriter sw) {
+    ssize_t	size = sw->sw.out.cur - sw->sw.out.buf;
+
+    switch (sw->type) {
+    case STRING_IO:
+	rb_funcall(sw->stream, oj_write_id, 1, rb_str_new(sw->sw.out.buf, size));
+	break;
+    case STREAM_IO:
+	rb_funcall(sw->stream, oj_write_id, 1, rb_str_new(sw->sw.out.buf, size));
+	break;
+    case FILE_IO:
+	if (size != write(sw->fd, sw->sw.out.buf, size)) {
+	    rb_raise(rb_eIOError, "Write failed. [_%d_:%s]\n", errno, strerror(errno));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "expected an IO Object.");
+    }
+}
+
+static void
+stream_writer_reset_buf(StreamWriter sw) {
+    sw->sw.out.cur = sw->sw.out.buf;
+    *sw->sw.out.cur = '\0';
+}
+
+/* Document-method: new
+ * call-seq: new(io, options)
+ *
+ * Creates a new StreamWriter.
+ * - *io* [_IO_] stream to write to
+ * - *options* [_Hash_] formating options
+ */
+static VALUE
+stream_writer_new(int argc, VALUE *argv, VALUE self) {
+    StreamWriterType	type = STREAM_IO;
+    int			fd = 0;
+    VALUE		stream = argv[0];
+    VALUE		clas = rb_obj_class(stream);
+    StreamWriter	sw;
+#if !IS_WINDOWS
+    VALUE		s;
+#endif
+    
+    if (oj_stringio_class == clas) {
+	type = STRING_IO;
+#if !IS_WINDOWS
+    } else if (rb_respond_to(stream, oj_fileno_id) &&
+	       Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
+	       0 != (fd = FIX2INT(s))) {
+	type = FILE_IO;
+#endif
+    } else if (rb_respond_to(stream, oj_write_id)) {
+	type = STREAM_IO;
+    } else {
+	rb_raise(rb_eArgError, "expected an IO Object.");
+    }
+    sw = ALLOC(struct _StreamWriter);
+    oj_str_writer_init(&sw->sw);
+    if (2 == argc) {
+	oj_parse_options(argv[1], &sw->sw.opts);
+    }
+    sw->sw.out.indent = sw->sw.opts.indent;
+    sw->stream = stream;
+    sw->type = type;
+    sw->fd = fd;
+
+    return Data_Wrap_Struct(oj_stream_writer_class, 0, stream_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
+stream_writer_push_key(VALUE self, VALUE key) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    rb_check_type(key, T_STRING);
+    stream_writer_reset_buf(sw);
+    oj_str_writer_push_key(&sw->sw, StringValuePtr(key));
+    stream_writer_write(sw);
+    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
+stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    stream_writer_reset_buf(sw);
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_object(&sw->sw, 0);
+	break;
+    case 1:
+	if (Qnil == argv[0]) {
+	    oj_str_writer_push_object(&sw->sw, 0);
+	} else {
+	    rb_check_type(argv[0], T_STRING);
+	    oj_str_writer_push_object(&sw->sw, StringValuePtr(argv[0]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    stream_writer_write(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
+stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    stream_writer_reset_buf(sw);
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_array(&sw->sw, 0);
+	break;
+    case 1:
+	if (Qnil == argv[0]) {
+	    oj_str_writer_push_array(&sw->sw, 0);
+	} else {
+	    rb_check_type(argv[0], T_STRING);
+	    oj_str_writer_push_array(&sw->sw, StringValuePtr(argv[0]));
+	}
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    stream_writer_write(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
+stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    stream_writer_reset_buf(sw);
+    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;
+    }
+    stream_writer_write(sw);
+    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
+stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    rb_check_type(argv[0], T_STRING);
+    stream_writer_reset_buf(sw);
+    switch (argc) {
+    case 1:
+	oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
+	break;
+    case 2:
+	if (Qnil == argv[0]) {
+	    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;
+    }
+    stream_writer_write(sw);
+    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
+stream_writer_pop(VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    stream_writer_reset_buf(sw);
+    oj_str_writer_pop(&sw->sw);
+    stream_writer_write(sw);
+    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
+stream_writer_pop_all(VALUE self) {
+    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+
+    stream_writer_reset_buf(sw);
+    oj_str_writer_pop_all(&sw->sw);
+    stream_writer_write(sw);
+
+    return Qnil;
+}
+
+/* Document-class: Oj::StreamWriter
+ * 
+ * Supports building a JSON document one element at a time. Build the IO stream
+ * 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.
+ */
+void
+oj_stream_writer_init() {
+    oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
+    rb_define_module_function(oj_stream_writer_class, "new", stream_writer_new, -1);
+    rb_define_method(oj_stream_writer_class, "push_key", stream_writer_push_key, 1);
+    rb_define_method(oj_stream_writer_class, "push_object", stream_writer_push_object, -1);
+    rb_define_method(oj_stream_writer_class, "push_array", stream_writer_push_array, -1);
+    rb_define_method(oj_stream_writer_class, "push_value", stream_writer_push_value, -1);
+    rb_define_method(oj_stream_writer_class, "push_json", stream_writer_push_json, -1);
+    rb_define_method(oj_stream_writer_class, "pop", stream_writer_pop, 0);
+    rb_define_method(oj_stream_writer_class, "pop_all", stream_writer_pop_all, 0);
+}
+
+