oj 1.0.6 → 1.1.0

data/ext/oj/load.c

@@ -75,6 +75,7 @@ static VALUE	read_false(ParseInfo pi);
 static VALUE	read_nil(ParseInfo pi);
 static void	next_non_white(ParseInfo pi);
 static char*	read_quoted_value(ParseInfo pi);
+static void	skip_comment(ParseInfo pi);
 
 
 /* This XML parser is a single pass, destructive, callback parser. It is a
@@ -100,6 +101,9 @@ next_non_white(ParseInfo pi) {
 	case '\n':
 	case '\r':
 	    break;
+	case '/':
+	    skip_comment(pi);
+	    break;
 	default:
 	    return;
 	}
@@ -275,6 +279,36 @@ circ_array_get(CircArray ca, unsigned long id) {
     return obj;
 }
 
+static void
+skip_comment(ParseInfo pi) {
+    pi->s++; // skip first /
+    if ('*' == *pi->s) {
+	pi->s++;
+	for (; '\0' != *pi->s; pi->s++) {
+	    if ('*' == *pi->s && '/' == *(pi->s + 1)) {
+		pi->s++;
+		return;
+	    } else if ('\0' == *pi->s) {
+		raise_error("comment not terminated", pi->str, pi->s);
+	    }
+	}
+    } else if ('/' == *pi->s) {
+	for (; 1; pi->s++) {
+	    switch (*pi->s) {
+	    case '\n':
+	    case '\r':
+	    case '\f':
+	    case '\0':
+		return;
+	    default:
+		break;
+	    }
+	}
+    } else {
+	raise_error("invalid comment", pi->str, pi->s);
+    }
+}
+
 static VALUE
 read_next(ParseInfo pi, int hint) {
     VALUE	obj;
@@ -307,7 +341,10 @@ read_next(ParseInfo pi, int hint) {
 	} else {
 	    obj = read_num(pi);
 	}
-    break;
+	break;
+    case 'I':
+	obj = read_num(pi);
+	break;
     case 't':
 	obj = read_true(pi);
 	break;
@@ -641,6 +678,17 @@ read_num(ParseInfo pi) {
     } else if ('+' == *pi->s) {
 	pi->s++;
     }
+    if ('I' == *pi->s) {
+	if (0 != strncmp("Infinity", pi->s, 8)) {
+	    raise_error("number or other value", pi->str, pi->s);
+	}
+	pi->s += 8;
+	if (neg) {
+	    return rb_float_new(-INFINITY);
+	} else {
+	    return rb_float_new(INFINITY);
+	}
+    }
     for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
 	n = n * 10 + (*pi->s - '0');
 	if (NUM_MAX <= n) {

data/ext/oj/oj.c

@@ -33,9 +33,15 @@
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
 
 #include "oj.h"
 
+// maximum to allocate on the stack, arbitrary limit
+#define SMALL_XML	65536
+
 typedef struct _YesNoOpt {
     VALUE       sym;
     char        *attr;
@@ -47,6 +53,7 @@ VALUE    Oj = Qnil;
 
 ID	oj_as_json_id;
 ID	oj_at_id;
+ID	oj_fileno_id;
 ID	oj_instance_variables_id;
 ID	oj_json_create_id;
 ID	oj_read_id;
@@ -57,6 +64,7 @@ ID	oj_to_sym_id;
 ID	oj_tv_nsec_id;
 ID	oj_tv_sec_id;
 ID	oj_tv_usec_id;
+ID	oj_write_id;
 
 VALUE	oj_bag_class;
 VALUE	oj_date_class;
@@ -78,19 +86,33 @@ static VALUE	object_sym;
 static VALUE	strict_sym;
 static VALUE	symbol_keys_sym;
 
+static VALUE	array_nl_sym;
+static VALUE	create_additions_sym;
+static VALUE	object_nl_sym;
+static VALUE	space_before_sym;
+static VALUE	space_sym;
+static VALUE	symbolize_names_sym;
+
+static VALUE	mimic = Qnil;
+static VALUE	keep = Qnil;
+
 Cache   oj_class_cache = 0;
 Cache   oj_attr_cache = 0;
 
 struct _Options	oj_default_options = {
-    { '\0' },		// encoding
+    //    { '\0' },		// encoding
+    "UTF-8",		// encoding
     0,			// indent
     No,			// circular
     Yes,		// auto_define
     No,			// sym_key
     No,			// ascii_only
     ObjectMode,		// mode
+    0,			// dump_opts
 };
 
+static VALUE	define_mimic_json(VALUE self);
+
 /* call-seq: default_options() => Hash
  *
  * Returns the default load and dump options as a Hash. The options are
@@ -257,42 +279,20 @@ parse_options(VALUE ropts, Options copts) {
  }
 
 static VALUE
-load(char *json, int argc, VALUE *argv, VALUE self) {
-    VALUE		obj;
-    struct _Options	options = oj_default_options;
-
-    if (1 == argc) {
-	parse_options(*argv, &options);
-    }
-    obj = oj_parse(json, &options);
-    //free(json);
-
-    return obj;
-}
-
-/* call-seq: load(json, options) => Hash, Array, String, Fixnum, Float, true, false, or nil
- *
- * Parses a JSON document String into a Hash, Array, String, Fixnum, Float,
- * true, false, or nil. Raises an exception if the JSON is malformed or the
- * classes specified are not valid.
- * @param [String] json JSON String
- * @param [Hash] options load options (same as default_options)
- */
-static VALUE
-load_str(int argc, VALUE *argv, VALUE self) {
+load_with_opts(VALUE input, Options copts) {
     char        *json;
     size_t	len;
-    VALUE	input;
-    
-    if (1 > argc) {
-	rb_raise(rb_eArgError, "Wrong number of arguments to load().\n");
-    }
-    input = *argv;
+    VALUE	obj;
+
     if (rb_type(input) == T_STRING) {
 	// the json string gets modified so make a copy of it
-	len = RSTRING_LEN(*argv) + 1;
-	json = ALLOCA_N(char, len);
-	strcpy(json, StringValuePtr(*argv));
+	len = RSTRING_LEN(input) + 1;
+	if (SMALL_XML < len) {
+	    json = ALLOC_N(char, len);
+	} else {
+	    json = ALLOCA_N(char, len);
+	}
+	strcpy(json, StringValuePtr(input));
     } else {
 	VALUE	clas = rb_obj_class(input);
 	VALUE	s;
@@ -300,21 +300,66 @@ load_str(int argc, VALUE *argv, VALUE self) {
 	if (oj_stringio_class == clas) {
 	    s = rb_funcall2(input, oj_string_id, 0, 0);
 	    len = RSTRING_LEN(s) + 1;
-	    json = ALLOCA_N(char, len);
+	    if (SMALL_XML < len) {
+		json = ALLOC_N(char, len);
+	    } else {
+		json = ALLOCA_N(char, len);
+	    }
 	    strcpy(json, StringValuePtr(s));
-
-	    // TBD else responds to fileno
-
+	} else if (rb_respond_to(input, oj_fileno_id) && Qnil != (s = rb_funcall(input, oj_fileno_id, 0))) {
+	    int		fd = FIX2INT(s);
+	    ssize_t	cnt;
+
+	    len = lseek(fd, 0, SEEK_END);
+	    lseek(fd, 0, SEEK_SET);
+	    if (SMALL_XML < len) {
+		json = ALLOC_N(char, len + 1);
+	    } else {
+		json = ALLOCA_N(char, len + 1);
+	    }
+	    if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
+		rb_raise(rb_eIOError, "failed to read from IO Object.\n");
+	    }
+	    json[len] = '\0';
 	} else if (rb_respond_to(input, oj_read_id)) {
 	    s = rb_funcall2(input, oj_read_id, 0, 0);
 	    len = RSTRING_LEN(s) + 1;
-	    json = ALLOCA_N(char, len);
+	    if (SMALL_XML < len) {
+		json = ALLOC_N(char, len);
+	    } else {
+		json = ALLOCA_N(char, len);
+	    }
 	    strcpy(json, StringValuePtr(s));
 	} else {
 	    rb_raise(rb_eArgError, "load() expected a String or IO Object.\n");
 	}
     }
-    return load(json, argc - 1, argv + 1, self);
+    obj = oj_parse(json, copts);
+    if (SMALL_XML < len) {
+	xfree(json);
+    }
+    return obj;
+}
+
+/* call-seq: load(json, options) => Hash, Array, String, Fixnum, Float, true, false, or nil
+ *
+ * Parses a JSON document String into a Hash, Array, String, Fixnum, Float,
+ * true, false, or nil. Raises an exception if the JSON is malformed or the
+ * classes specified are not valid.
+ * @param [String] json JSON String
+ * @param [Hash] options load options (same as default_options)
+ */
+static VALUE
+load(int argc, VALUE *argv, VALUE self) {
+    struct _Options	options = oj_default_options;
+
+    if (1 > argc) {
+	rb_raise(rb_eArgError, "Wrong number of arguments to load().\n");
+    }
+    if (2 <= argc) {
+	parse_options(argv[1], &options);
+    }
+    return load_with_opts(*argv, &options);
 }
 
 static VALUE
@@ -323,7 +368,9 @@ load_file(int argc, VALUE *argv, VALUE self) {
     char                *json;
     FILE                *f;
     unsigned long       len;
-    
+    VALUE		obj;
+    struct _Options	options = oj_default_options;
+
     Check_Type(*argv, T_STRING);
     path = StringValuePtr(*argv);
     if (0 == (f = fopen(path, "r"))) {
@@ -331,9 +378,10 @@ load_file(int argc, VALUE *argv, VALUE self) {
     }
     fseek(f, 0, SEEK_END);
     len = ftell(f);
-    if (0 == (json = ALLOCA_N(char, len + 1))) {
-        fclose(f);
-        rb_raise(rb_eNoMemError, "Could not allocate memory for %ld byte file.\n", len);
+    if (SMALL_XML < len) {
+	json = ALLOC_N(char, len + 1);
+    } else {
+	json = ALLOCA_N(char, len + 1);
     }
     fseek(f, 0, SEEK_SET);
     if (len != fread(json, 1, len, f)) {
@@ -342,8 +390,14 @@ load_file(int argc, VALUE *argv, VALUE self) {
     }
     fclose(f);
     json[len] = '\0';
-
-    return load(json, argc - 1, argv + 1, self);
+    if (2 <= argc) {
+	parse_options(argv[1], &options);
+    }
+    obj = oj_parse(json, &options);
+    if (SMALL_XML < len) {
+	xfree(json);
+    }
+    return obj;
 }
 
 /* call-seq: dump(obj, options) => json-string
@@ -365,7 +419,7 @@ dump(int argc, VALUE *argv, VALUE self) {
         rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(json);
-#ifdef ENCODING_INLINE_MAX
+#ifdef HAVE_RUBY_ENCODING_H
     if ('\0' != *copts.encoding) {
         rb_enc_associate(rstr, rb_enc_find(copts.encoding));
     }
@@ -398,9 +452,264 @@ to_file(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
-void Init_oj() {
-    VALUE       keep = Qnil;
+// Mimic JSON section
+
+static VALUE
+mimic_dump(int argc, VALUE *argv, VALUE self) {
+    char                *json;
+    struct _Options     copts = oj_default_options;
+    VALUE               rstr;
+    
+    if (0 == (json = oj_write_obj_to_str(*argv, &copts))) {
+        rb_raise(rb_eNoMemError, "Not enough memory.\n");
+    }
+    rstr = rb_str_new2(json);
+#ifdef ENCODING_INLINE_MAX
+    if ('\0' != *copts.encoding) {
+	rb_enc_associate(rstr, rb_enc_find(copts.encoding));
+    }
+#endif
+    if (2 <= argc && Qnil != argv[1]) {
+	VALUE	io = argv[1];
+	VALUE	args[1];
+
+	*args = rstr;
+	rb_funcall2(io, oj_write_id, 1, args);
+	rstr = io;
+    }
+    xfree(json);
+
+    return rstr;
+}
+
+// This is the signature for the hash_foreach callback also.
+static int
+mimic_walk(VALUE key, VALUE obj, VALUE proc) {
+    VALUE	args[1];
+
+    switch (rb_type(obj)) {
+    case T_HASH:
+	rb_hash_foreach(obj, mimic_walk, proc);
+	break;
+    case T_ARRAY:
+	{
+	    VALUE	*np = RARRAY_PTR(obj);
+	    size_t	cnt = RARRAY_LEN(obj);
+	
+	    for (; 0 < cnt; cnt--, np++) {
+		mimic_walk(Qnil, *np, proc);
+	    }
+	    break;
+	}
+    default:
+	break;
+    }
+    *args = obj;
+    if (Qnil == proc) {
+	rb_yield_values2(1, args);
+    } else {
+	rb_proc_call_with_block(proc, 1, args, Qnil);
+    }
+    return ST_CONTINUE;
+}
+
+static VALUE
+mimic_load(int argc, VALUE *argv, VALUE self) {
+    VALUE	obj = load(1, argv, self);
+
+    if (2 <= argc && Qnil != argv[1]) {
+	mimic_walk(Qnil, obj, argv[1]);
+    }
+    return obj;
+}
+
+static VALUE
+mimic_dump_load(int argc, VALUE *argv, VALUE self) {
+    if (1 > argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)\n");
+    } else if (T_STRING == rb_type(*argv)) {
+	return mimic_load(argc, argv, self);
+    } else {
+	return mimic_dump(argc, argv, self);
+    }
+}
 
+static VALUE
+mimic_generate_core(int argc, VALUE *argv, Options copts) {
+    char                *json;
+    VALUE               rstr;
+    
+    if (2 == argc && Qnil != argv[1]) {
+	struct _DumpOpts	dump_opts;
+	VALUE			ropts = argv[1];
+        VALUE   		v;
+
+	memset(&dump_opts, 0, sizeof(dump_opts)); // may not be needed
+	if (T_HASH != rb_type(ropts)) {
+	    rb_raise(rb_eArgError, "options must be a hash.\n");
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, indent_sym))) {
+	    rb_check_type(v, T_STRING);
+	    if (0 == copts->dump_opts) {
+		copts->dump_opts = &dump_opts;
+	    }
+	    copts->dump_opts->indent = StringValuePtr(v);
+	    copts->dump_opts->indent_size = (uint8_t)strlen(copts->dump_opts->indent);
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, space_sym))) {
+	    rb_check_type(v, T_STRING);
+	    if (0 == copts->dump_opts) {
+		copts->dump_opts = &dump_opts;
+	    }
+	    copts->dump_opts->after_sep = StringValuePtr(v);
+	    copts->dump_opts->after_size = (uint8_t)strlen(copts->dump_opts->after_sep);
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, space_before_sym))) {
+	    rb_check_type(v, T_STRING);
+	    if (0 == copts->dump_opts) {
+		copts->dump_opts = &dump_opts;
+	    }
+	    copts->dump_opts->before_sep = StringValuePtr(v);
+	    copts->dump_opts->before_size = (uint8_t)strlen(copts->dump_opts->before_sep);
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, object_nl_sym))) {
+	    rb_check_type(v, T_STRING);
+	    if (0 == copts->dump_opts) {
+		copts->dump_opts = &dump_opts;
+	    }
+	    copts->dump_opts->hash_nl = StringValuePtr(v);
+	    copts->dump_opts->hash_size = (uint8_t)strlen(copts->dump_opts->hash_nl);
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, array_nl_sym))) {
+	    rb_check_type(v, T_STRING);
+	    if (0 == copts->dump_opts) {
+		copts->dump_opts = &dump_opts;
+	    }
+	    copts->dump_opts->array_nl = StringValuePtr(v);
+	    copts->dump_opts->array_size = (uint8_t)strlen(copts->dump_opts->array_nl);
+	}
+	// :allow_nan is not supported as Oj always allows_nan
+	// :max_nesting is always set to 100
+    }
+    if (0 == (json = oj_write_obj_to_str(*argv, copts))) {
+        rb_raise(rb_eNoMemError, "Not enough memory.\n");
+    }
+    rstr = rb_str_new2(json);
+#ifdef ENCODING_INLINE_MAX
+    if ('\0' != *copts->encoding) {
+        rb_enc_associate(rstr, rb_enc_find(copts->encoding));
+    }
+#endif
+    xfree(json);
+
+    return rstr;
+}
+
+static VALUE
+mimic_generate(int argc, VALUE *argv, VALUE self) {
+    struct _Options     copts = oj_default_options;
+
+    return mimic_generate_core(argc, argv, &copts);
+}
+
+static VALUE
+mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
+    struct _Options     copts = oj_default_options;
+    struct _DumpOpts	dump_opts;
+    
+    dump_opts.indent = "  ";
+    dump_opts.indent_size = (uint8_t)strlen(dump_opts.indent);
+    dump_opts.before_sep = " ";
+    dump_opts.before_size = (uint8_t)strlen(dump_opts.before_sep);
+    dump_opts.after_sep = " ";
+    dump_opts.after_size = (uint8_t)strlen(dump_opts.after_sep);
+    dump_opts.hash_nl = "\n";
+    dump_opts.hash_size = (uint8_t)strlen(dump_opts.hash_nl);
+    dump_opts.array_nl = "\n";
+    dump_opts.array_size = (uint8_t)strlen(dump_opts.array_nl);
+    copts.dump_opts = &dump_opts;
+
+    return mimic_generate_core(argc, argv, &copts);
+}
+
+static VALUE
+mimic_parse(int argc, VALUE *argv, VALUE self) {
+    struct _Options	options = oj_default_options;
+
+    if (1 > argc) {
+	rb_raise(rb_eArgError, "Wrong number of arguments to load().\n");
+    }
+    if (2 <= argc && Qnil != argv[1]) {
+	VALUE	ropts = argv[1];
+        VALUE   v;
+
+	if (T_HASH != rb_type(ropts)) {
+	    rb_raise(rb_eArgError, "options must be a hash.\n");
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts, symbolize_names_sym))) {
+	    options.sym_key = (Qtrue == v) ? Yes : No;
+	}
+        if (Qnil != (v = rb_hash_lookup(ropts,  create_additions_sym))) {
+	    options.mode = (Qtrue == v) ? CompatMode : StrictMode;
+	}
+	// :allow_nan is not supported as Oj always allows_nan
+	// :max_nesting is always set to 100
+	// :object_class is always Hash
+	// :array_class is always Array
+    }
+    return load_with_opts(*argv, &options);
+}
+
+static VALUE
+mimic_recurse_proc(VALUE self, VALUE obj) {
+    rb_need_block();
+    mimic_walk(Qnil, obj, Qnil);
+
+    return Qnil;
+}
+
+static VALUE
+no_op1(VALUE self, VALUE obj) {
+    return Qnil;
+}
+
+static VALUE
+define_mimic_json(VALUE self) {
+    if (Qnil == mimic) {
+	VALUE	ext;
+
+	mimic = rb_define_module("JSON");
+	ext = rb_define_module_under(mimic, "Ext");
+	rb_define_class_under(ext, "Parser", rb_cObject);
+	rb_define_class_under(ext, "Generator", rb_cObject);
+
+	rb_define_module_function(mimic, "parser=", no_op1, 1);
+	rb_define_module_function(mimic, "generator=", no_op1, 1);
+
+	rb_define_module_function(mimic, "dump", mimic_dump, -1);
+	rb_define_module_function(mimic, "load", mimic_load, -1);
+	rb_define_module_function(mimic, "restore", mimic_load, -1);
+	rb_define_module_function(mimic, "recurse_proc", mimic_recurse_proc, 1);
+	rb_define_module_function(mimic, "[]", mimic_dump_load, -1);
+	rb_define_module_function(mimic, "generate", mimic_generate, -1);
+	rb_define_module_function(mimic, "fast_generate", mimic_generate, -1);
+	rb_define_module_function(mimic, "pretty_generate", mimic_pretty_generate, -1);
+	rb_define_module_function(mimic, "parse", mimic_parse, -1);
+	rb_define_module_function(mimic, "parse!", mimic_parse, -1);
+
+	array_nl_sym = ID2SYM(rb_intern("array_nl"));	rb_ary_push(keep, array_nl_sym);
+	create_additions_sym = ID2SYM(rb_intern("create_additions"));	rb_ary_push(keep, create_additions_sym);
+	object_nl_sym = ID2SYM(rb_intern("object_nl"));	rb_ary_push(keep, object_nl_sym);
+	space_before_sym = ID2SYM(rb_intern("space_before"));	rb_ary_push(keep, space_before_sym);
+	space_sym = ID2SYM(rb_intern("space"));	rb_ary_push(keep, space_sym);
+	symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));	rb_ary_push(keep, symbolize_names_sym);
+
+	oj_default_options.mode = CompatMode;
+    }
+    return mimic;
+}
+
+void Init_oj() {
     Oj = rb_define_module("Oj");
     keep = rb_cv_get(Oj, "@@keep"); // needed to stop GC from deleting and reusing VALUEs
 
@@ -411,13 +720,15 @@ void Init_oj() {
     rb_define_module_function(Oj, "default_options", get_def_opts, 0);
     rb_define_module_function(Oj, "default_options=", set_def_opts, 1);
 
-    rb_define_module_function(Oj, "load", load_str, -1);
+    rb_define_module_function(Oj, "mimic_JSON", define_mimic_json, 0);
+    rb_define_module_function(Oj, "load", load, -1);
     rb_define_module_function(Oj, "load_file", load_file, -1);
     rb_define_module_function(Oj, "dump", dump, -1);
     rb_define_module_function(Oj, "to_file", to_file, -1);
 
     oj_as_json_id = rb_intern("as_json");
     oj_at_id = rb_intern("at");
+    oj_fileno_id = rb_intern("fileno");
     oj_instance_variables_id = rb_intern("instance_variables");
     oj_json_create_id = rb_intern("json_create");
     oj_read_id = rb_intern("read");
@@ -428,6 +739,7 @@ void Init_oj() {
     oj_tv_nsec_id = rb_intern("tv_nsec");
     oj_tv_sec_id = rb_intern("tv_sec");
     oj_tv_usec_id = rb_intern("tv_usec");
+    oj_write_id = rb_intern("write");
 
     oj_bag_class = rb_const_get_at(Oj, rb_intern("Bag"));
     oj_struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));