oj 0.6.0 → 0.7.0

data/ext/oj/load.c

@@ -36,6 +36,10 @@
 #include "ruby.h"
 #include "oj.h"
 
+enum {
+    TIME_HINT = 0x0100,
+};
+
 typedef struct _ParseInfo {
     char	*str;		/* buffer being read from */
     char	*s;		/* current position in buffer */
@@ -47,11 +51,13 @@ typedef struct _ParseInfo {
     Options	options;
 } *ParseInfo;
 
-static VALUE	read_next(ParseInfo pi);
+static VALUE	classname2class(const char *name, ParseInfo pi);
+static VALUE	read_next(ParseInfo pi, int hint);
 static VALUE	read_obj(ParseInfo pi);
 static VALUE	read_array(ParseInfo pi);
-static VALUE	read_str(ParseInfo pi);
+static VALUE	read_str(ParseInfo pi, int hint);
 static VALUE	read_num(ParseInfo pi);
+static VALUE	read_time(ParseInfo pi);
 static VALUE	read_true(ParseInfo pi);
 static VALUE	read_false(ParseInfo pi);
 static VALUE	read_nil(ParseInfo pi);
@@ -105,6 +111,86 @@ next_white(ParseInfo pi) {
     }
 }
 
+inline static VALUE
+resolve_classname(VALUE mod, const char *class_name, int create) {
+    VALUE       clas;
+    ID          ci = rb_intern(class_name);
+
+    if (rb_const_defined_at(mod, ci) || !create) {
+	clas = rb_const_get_at(mod, ci);
+    } else {
+	//clas = rb_define_class_under(mod, class_name, oj_bag_clas);
+	clas = rb_const_get_at(mod, ci); // TBD temp
+    }
+    return clas;
+}
+
+inline static VALUE
+classname2obj(const char *name, ParseInfo pi) {
+    VALUE   clas = classname2class(name, pi);
+    
+    if (Qundef == clas) {
+        return Qnil;
+    } else {
+        return rb_obj_alloc(clas);
+    }
+}
+
+static VALUE
+classname2class(const char *name, ParseInfo pi) {
+    VALUE       clas;
+    int		create = 0; // TBD from options
+            
+#if 1
+    VALUE       *slot;
+
+    if (Qundef == (clas = oj_cache_get(oj_class_cache, name, &slot))) {
+        char            class_name[1024];
+        char            *s;
+        const char      *n = name;
+
+        clas = rb_cObject;
+        for (s = class_name; '\0' != *n; n++) {
+            if (':' == *n) {
+                *s = '\0';
+                n++;
+                if (Qundef == (clas = resolve_classname(clas, class_name, create))) {
+                    return Qundef;
+                }
+                s = class_name;
+            } else {
+                *s++ = *n;
+            }
+        }
+        *s = '\0';
+        if (Qundef != (clas = resolve_classname(clas, class_name, create))) {
+            *slot = clas;
+        }
+    }
+#else
+    char            class_name[1024];
+    char            *s;
+    const char      *n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; '\0' != *n; n++) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    if (Qundef == (clas = resolve_classname(clas, class_name, create))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+    clas = resolve_classname(clas, class_name, create);
+#endif
+    return clas;
+}
+
 VALUE
 oj_parse(char *json, Options options) {
     VALUE		obj;
@@ -122,7 +208,7 @@ oj_parse(char *json, Options options) {
     pi.encoding = 0;
 #endif
     pi.options = options;
-    if (Qundef == (obj = read_next(&pi))) {
+    if (Qundef == (obj = read_next(&pi, 0))) {
 	raise_error("no object read", pi.str, pi.s);
     }
     next_non_white(&pi);	// skip white space
@@ -133,7 +219,7 @@ oj_parse(char *json, Options options) {
 }
 
 static VALUE
-read_next(ParseInfo pi) {
+read_next(ParseInfo pi, int hint) {
     VALUE	obj;
 
     next_non_white(pi);	// skip white space
@@ -145,7 +231,7 @@ read_next(ParseInfo pi) {
 	obj = read_array(pi);
 	break;
     case '"':
-	obj = read_str(pi);
+	obj = read_str(pi, hint);
 	break;
     case '+':
     case '-':
@@ -159,7 +245,11 @@ read_next(ParseInfo pi) {
     case '7':
     case '8':
     case '9':
-	obj = read_num(pi);
+	if (TIME_HINT == hint) {
+	    obj = read_time(pi);
+	} else {
+	    obj = read_num(pi);
+	}
     break;
     case 't':
 	obj = read_true(pi);
@@ -185,6 +275,8 @@ read_obj(ParseInfo pi) {
     VALUE	obj = Qundef;
     VALUE	key = Qundef;
     VALUE	val = Qundef;
+    const char	*ks;
+    int		obj_type = T_NONE;
     
     pi->s++;
     next_non_white(pi);
@@ -194,7 +286,10 @@ read_obj(ParseInfo pi) {
     }
     while (1) {
 	next_non_white(pi);
-	if ('"' != *pi->s || Qundef == (key = read_str(pi))) {
+	ks = 0;
+	key = Qundef;
+	val = Qundef;
+	if ('"' != *pi->s || Qundef == (key = read_str(pi, 0))) {
 	    raise_error("unexpected character", pi->str, pi->s);
 	}
 	next_non_white(pi);
@@ -203,13 +298,80 @@ read_obj(ParseInfo pi) {
 	} else {
 	    raise_error("invalid format, expected :", pi->str, pi->s);
 	}
-	if (Qundef == (val = read_next(pi))) {
-	    raise_error("unexpected character", pi->str, pi->s);
+	if (T_STRING == rb_type(key)) {
+	    ks = StringValuePtr(key);
+	} else {
+	    ks = 0;
 	}
-	if (Qundef == obj) {
-	    obj = rb_hash_new();
+	if (0 != ks && Qundef == obj && ObjectMode == pi->options->mode) {
+	    if ('^' == *ks && '\0' == ks[2]) { // special directions
+		switch (ks[1]) {
+		case 't': // Time
+		    obj = read_next(pi, TIME_HINT); // raises if can not convert to Time
+		    key = Qundef;
+		    break;
+		case 'c': // Class
+		    obj = read_next(pi, T_CLASS);
+		    key = Qundef;
+		    break;
+		case 's': // Symbol
+		    obj = read_next(pi, T_SYMBOL);
+		    key = Qundef;
+		    break;
+		case 'o': // Object
+		    obj = read_next(pi, T_OBJECT);
+		    obj_type = T_OBJECT;
+		    key = Qundef;
+		    break;
+		case 'i': // Id for circular reference
+		    // TBD
+		default:
+		    // handle later
+		    break;
+		}
+	    }
+	}
+	if (Qundef != key) {
+	    if (Qundef == val && Qundef == (val = read_next(pi, 0))) {
+		raise_error("unexpected character", pi->str, pi->s);
+	    }
+	    if (ObjectMode == pi->options->mode &&
+		0 != ks && '^' == *ks && '#' == ks[1] &&
+		(T_NONE == obj_type || T_HASH == obj_type) &&
+		rb_type(val) == T_ARRAY && 2 == RARRAY_LEN(val)) {  // Hash entry
+		VALUE	*np = RARRAY_PTR(val);
+
+		key = *np;
+		val = *(np + 1);
+	    }
+	    if (Qundef == obj) {
+		obj = rb_hash_new();
+		obj_type = T_HASH;
+	    }
+	    if (T_OBJECT == obj_type) {
+		VALUE       *slot;
+		ID          var_id;
+
+		if (Qundef == (var_id = oj_cache_get(oj_attr_cache, ks, &slot))) {
+		    char	attr[1024];
+
+		    if ('~' == *ks) {
+			strncpy(attr, ks + 1, sizeof(attr) - 1);
+		    } else {
+			*attr = '@';
+			strncpy(attr + 1, ks, sizeof(attr) - 2);
+		    }
+		    attr[sizeof(attr) - 1] = '\0';
+		    var_id = rb_intern(attr);
+		    *slot = var_id;
+		}
+		rb_ivar_set(obj, var_id, val);
+	    } else if (T_HASH == obj_type) {
+		rb_hash_aset(obj, key, val);
+	    } else {
+		raise_error("invalid Object format, too many Hash entries.", pi->str, pi->s);
+	    }
 	}
-	rb_hash_aset(obj, key, val);
 	next_non_white(pi);
 	if ('}' == *pi->s) {
 	    pi->s++;
@@ -217,6 +379,7 @@ read_obj(ParseInfo pi) {
 	} else if (',' == *pi->s) {
 	    pi->s++;
 	} else {
+	    //printf("*** '%s'\n", pi->s);
 	    raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
 	}
     }
@@ -235,7 +398,7 @@ read_array(ParseInfo pi) {
 	return a;
     }
     while (1) {
-	if (Qundef == (e = read_next(pi))) {
+	if (Qundef == (e = read_next(pi, 0))) {
 	    raise_error("unexpected character", pi->str, pi->s);
 	}
         rb_ary_push(a, e);
@@ -253,16 +416,75 @@ read_array(ParseInfo pi) {
 }
 
 static VALUE
-read_str(ParseInfo pi) {
+read_str(ParseInfo pi, int hint) {
     char	*text = read_quoted_value(pi);
-    VALUE	s = rb_str_new2(text);
+    VALUE	obj;
 
-#ifdef HAVE_RUBY_ENCODING_H
-    if (0 != pi->encoding) {
-        rb_enc_associate(s, pi->encoding);
+    if (ObjectMode != pi->options->mode) {
+	hint = T_STRING;
     }
+    switch (hint) {
+    case T_CLASS:
+	obj = classname2class(text, pi);
+	break;
+    case T_OBJECT:
+	obj = classname2obj(text, pi);
+	break;
+    case T_STRING:
+	obj = rb_str_new2(text);
+#ifdef HAVE_RUBY_ENCODING_H
+	if (0 != pi->encoding) {
+	    rb_enc_associate(obj, pi->encoding);
+	}
+#endif
+	break;
+    case T_SYMBOL:
+#ifdef HAVE_RUBY_ENCODING_H
+	if (0 != pi->encoding) {
+	    obj = rb_str_new2(text);
+	    rb_enc_associate(obj, pi->encoding);
+	    obj = rb_funcall(obj, oj_to_sym_id, 0);
+	} else {
+	    obj = ID2SYM(rb_intern(text));
+	}
+#else
+	obj = ID2SYM(rb_intern(text));
 #endif
-    return s;
+	break;
+    case 0:
+    default:
+	if (':' == *text) {
+	    if (':' == text[1]) { // escaped :, it s string
+		obj = rb_str_new2(text + 1);
+#ifdef HAVE_RUBY_ENCODING_H
+		if (0 != pi->encoding) {
+		    rb_enc_associate(obj, pi->encoding);
+		}
+#endif
+	    } else { // Symbol
+#ifdef HAVE_RUBY_ENCODING_H
+		if (0 != pi->encoding) {
+		    obj = rb_str_new2(text + 1);
+		    rb_enc_associate(obj, pi->encoding);
+		    obj = rb_funcall(obj, oj_to_sym_id, 0);
+		} else {
+		    obj = ID2SYM(rb_intern(text + 1));
+		}
+#else
+		obj = ID2SYM(rb_intern(text + 1));
+#endif
+	    }
+	} else {
+	    obj = rb_str_new2(text);
+#ifdef HAVE_RUBY_ENCODING_H
+	    if (0 != pi->encoding) {
+		rb_enc_associate(obj, pi->encoding);
+	    }
+#endif
+	}
+	break;
+    }
+    return obj;
 }
 
 #ifdef RUBINIUS
@@ -344,6 +566,27 @@ read_num(ParseInfo pi) {
     }
 }
 
+static VALUE
+read_time(ParseInfo pi) {
+    VALUE       args[2];
+    long        v = 0;
+    long        v2 = 0;
+
+    for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+	v = v * 10 + (*pi->s - '0');
+    }
+    if ('.' == *pi->s) {
+	pi->s++;
+	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+	    v2 = v2 * 10 + (*pi->s - '0');
+	}
+    }
+    args[0] = LONG2NUM(v);
+    args[1] = LONG2NUM(v2);
+
+    return rb_funcall2(oj_time_class, oj_at_id, 2, args);
+}
+
 static VALUE
 read_true(ParseInfo pi) {
     pi->s++;

data/ext/oj/oj.c

@@ -45,12 +45,17 @@ void Init_oj();
 
 VALUE    Oj = Qnil;
 
+ID	oj_at_id;
 ID	oj_instance_variables_id;
 ID	oj_to_hash_id;
 ID	oj_to_json_id;
+ID	oj_to_sym_id;
+ID	oj_tv_nsec_id;
 ID	oj_tv_sec_id;
 ID	oj_tv_usec_id;
 
+VALUE	oj_time_class;
+
 static VALUE	circular_sym;
 static VALUE	compat_sym;
 static VALUE	encoding_sym;
@@ -60,6 +65,9 @@ static VALUE	null_sym;
 static VALUE	object_sym;
 static VALUE	strict_sym;
 
+Cache   oj_class_cache = 0;
+Cache   oj_attr_cache = 0;
+
 static struct _Options  default_options = {
     { '\0' },		// encoding
     0,			// indent
@@ -312,6 +320,29 @@ dump(int argc, VALUE *argv, VALUE self) {
     return rstr;
 }
 
+
+/* call-seq: to_file(file_path, obj, options)
+ *
+ * Dumps an Object to the specified file.
+ * @param [String] file_path file path to write the JSON document to
+ * @param [Object] obj Object to serialize as an JSON document String
+ * @param [Hash] options formating options
+ * @param [Fixnum] :indent format expected
+ * @param [true|false] :circular allow circular references, default: false
+ */
+static VALUE
+to_file(int argc, VALUE *argv, VALUE self) {
+    struct _Options     copts = default_options;
+    
+    if (3 == argc) {
+        parse_options(argv[2], &copts);
+    }
+    Check_Type(*argv, T_STRING);
+    oj_write_obj_to_file(argv[1], StringValuePtr(*argv), &copts);
+
+    return Qnil;
+}
+
 void Init_oj() {
     VALUE       keep = Qnil;
 
@@ -324,13 +355,19 @@ void Init_oj() {
     rb_define_module_function(Oj, "load", load_str, -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_at_id = rb_intern("at");
     oj_instance_variables_id = rb_intern("instance_variables");
     oj_to_hash_id = rb_intern("to_hash");
     oj_to_json_id = rb_intern("to_json");
+    oj_to_sym_id = rb_intern("to_sym");
+    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_time_class = rb_const_get(rb_cObject, rb_intern("Time"));
+
     circular_sym = ID2SYM(rb_intern("circular"));	rb_ary_push(keep, circular_sym);
     compat_sym = ID2SYM(rb_intern("compat"));		rb_ary_push(keep, compat_sym);
     encoding_sym = ID2SYM(rb_intern("encoding"));	rb_ary_push(keep, encoding_sym);
@@ -341,6 +378,9 @@ void Init_oj() {
     strict_sym = ID2SYM(rb_intern("strict"));		rb_ary_push(keep, strict_sym);
 
     default_options.mode = ObjectMode;
+
+    oj_cache_new(&oj_class_cache);
+    oj_cache_new(&oj_attr_cache);
 }
 
 void