ox 2.12.0 → 2.13.4

data/ext/ox/hash_load.c

@@ -13,12 +13,14 @@
 #include "ruby.h"
 #include "ox.h"
 
+#define MARK_INC	256
+
 // The approach taken for the hash and has_no_attrs parsing is to push just
 // the key on to the stack and then decide what to do on the way up/out.
 
 static VALUE
 create_top(PInfo pi) {
-    volatile VALUE       top = rb_hash_new();;
+    volatile VALUE       top = rb_hash_new();
 
     helper_stack_push(&pi->helpers, 0, top, HashCode);
     pi->obj = top;
@@ -26,20 +28,61 @@ create_top(PInfo pi) {
     return top;
 }
 
+static void
+mark_value(PInfo pi, VALUE val) {
+    if (NULL == pi->marked) {
+	pi->marked = ALLOC_N(VALUE, MARK_INC);
+	pi->mark_size = MARK_INC;
+    } else if (pi->mark_size <= pi->mark_cnt) {
+	pi->mark_size += MARK_INC;
+	pi->marked = REALLOC_N(pi->marked, VALUE, pi->mark_size);
+    }
+    pi->marked[pi->mark_cnt] = val;
+    pi->mark_cnt++;
+}
+
+static bool
+marked(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
+
+	for (; pi->marked <= vp; vp--) {
+	    if (val == *vp) {
+		return true;
+	    }
+	}
+    }
+    return false;
+}
+
+static void
+unmark(PInfo pi, VALUE val) {
+    if (NULL != pi->marked) {
+	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
+	int		i;
+
+	for (i = 0; pi->marked <= vp; vp--, i++) {
+	    if (val == *vp) {
+		for (; 0 < i; i--, vp++) {
+		    *vp = *(vp + 1);
+		}
+		pi->mark_cnt--;
+		break;
+	    }
+	}
+    }
+}
+
 static void
 add_text(PInfo pi, char *text, int closed) {
     Helper		parent = helper_stack_peek(&pi->helpers);
     volatile VALUE	s = rb_str_new2(text);
     volatile VALUE	a;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
-#elif HAS_PRIVATE_ENCODING
-    if (Qnil != pi->options->rb_enc) {
-	rb_funcall(s, ox_force_encoding_id, 1, pi->options->rb_enc);
-    }
 #endif
     switch (parent->type) {
     case NoCode:
@@ -79,20 +122,16 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 		key = rb_str_new2(attrs->name);
 	    }
 	    val = rb_str_new2(attrs->value);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	    if (0 != pi->options->rb_enc) {
 		rb_enc_associate(val, pi->options->rb_enc);
 	    }
-#elif HAS_PRIVATE_ENCODING
-	    if (Qnil != pi->options->rb_enc) {
-		rb_funcall(val, ox_force_encoding_id, 1, pi->options->rb_enc);
-	    }
 #endif
 	    rb_hash_aset(h, key, val);
 	}
 	a = rb_ary_new();
 	rb_ary_push(a, h);
-	rb_obj_taint(a); // flag indicating it is a unit, kind of a hack but it works
+	mark_value(pi, a);
 	helper_stack_push(&pi->helpers, rb_intern(ename), a, ArrayCode);
     } else {
 	helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
@@ -108,15 +147,14 @@ add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 }
 
 static int
-untaint_hash_cb(VALUE key, VALUE value, VALUE x) {
-    if (Qtrue == rb_obj_tainted(value)) {
-	rb_obj_untaint(value);
-    }
+umark_hash_cb(VALUE key, VALUE value, VALUE x) {
+    unmark((PInfo)x, value);
+
     return ST_CONTINUE;
 }
 
 static void
-end_element_core(PInfo pi, const char *ename, bool check_taint) {
+end_element_core(PInfo pi, const char *ename, bool check_marked) {
     Helper		e = helper_stack_pop(&pi->helpers);
     Helper		parent = helper_stack_peek(&pi->helpers);
     volatile VALUE	pobj = parent->obj;
@@ -161,8 +199,8 @@ end_element_core(PInfo pi, const char *ename, bool check_taint) {
     if (Qundef == found) {
 	rb_hash_aset(pobj, key, e->obj);
     } else if (RUBY_T_ARRAY == rb_type(found)) {
-	if (check_taint && Qtrue == rb_obj_tainted(found)) {
-	    rb_obj_untaint(found);
+	if (check_marked && marked(pi, found)) {
+	    unmark(pi, found);
 	    a = rb_ary_new();
 	    rb_ary_push(a, found);
 	    rb_ary_push(a, e->obj);
@@ -171,16 +209,16 @@ end_element_core(PInfo pi, const char *ename, bool check_taint) {
 	    rb_ary_push(found, e->obj);
 	}
     } else { // something there other than an array
-	if (check_taint && Qtrue == rb_obj_tainted(e->obj)) {
-	    rb_obj_untaint(e->obj);
+	if (check_marked && marked(pi, e->obj)) {
+	    unmark(pi, e->obj);
 	}
 	a = rb_ary_new();
 	rb_ary_push(a, found);
 	rb_ary_push(a, e->obj);
 	rb_hash_aset(pobj, key, a);
     }
-    if (check_taint && RUBY_T_HASH == rb_type(e->obj)) {
-	rb_hash_foreach(e->obj, untaint_hash_cb, Qnil);
+    if (check_marked && NULL != pi->marked && RUBY_T_HASH == rb_type(e->obj)) {
+	rb_hash_foreach(e->obj, umark_hash_cb, (VALUE)pi);
     }
 }
 
@@ -196,9 +234,7 @@ end_element_no_attrs(PInfo pi, const char *ename) {
 
 static void
 finish(PInfo pi) {
-    if (Qnil != pi->obj && RUBY_T_HASH == rb_type(pi->obj)) {
-	rb_hash_foreach(pi->obj, untaint_hash_cb, Qnil);
-    }
+    xfree(pi->marked);
 }
 
 struct _parseCallbacks   _ox_hash_callbacks = {

data/ext/ox/obj_load.c

@@ -11,6 +11,9 @@
 #include <time.h>
 
 #include "ruby.h"
+#if HAVE_RB_ENC_ASSOCIATE
+#include "ruby/encoding.h"
+#endif
 #include "base64.h"
 #include "ox.h"
 
@@ -143,7 +146,6 @@ classname2obj(const char *name, PInfo pi, VALUE base_class) {
     }
 }
 
-#if HAS_RSTRUCT
 inline static VALUE
 structname2obj(const char *name) {
     VALUE	ost;
@@ -159,16 +161,12 @@ structname2obj(const char *name) {
 	}
     }
     ost = rb_const_get(ox_struct_class, rb_intern(s));
-    /* use encoding as the indicator for Ruby 1.8.7 or 1.9.x */
-#if HAS_ENCODING_SUPPORT
-    return rb_struct_alloc_noinit(ost);
-#elif HAS_PRIVATE_ENCODING
+#if HAVE_RB_STRUCT_ALLOC_NOINIT
     return rb_struct_alloc_noinit(ost);
 #else
     return rb_struct_new(ost);
 #endif
 }
-#endif
 
 inline static VALUE
 parse_ulong(const char *s, PInfo pi) {
@@ -239,6 +237,7 @@ static ID
 get_var_sym_from_attrs(Attr a, void *encoding) {
     for (; 0 != a->name; a++) {
 	if ('a' == *a->name && '\0' == *(a->name + 1)) {
+	    name2var(a->value, encoding);
 	    return name2var(a->value, encoding);
 	}
     }
@@ -255,7 +254,6 @@ get_obj_from_attrs(Attr a, PInfo pi, VALUE base_class) {
     return Qundef;
 }
 
-#if HAS_RSTRUCT
 static VALUE
 get_struct_from_attrs(Attr a) {
     for (; 0 != a->name; a++) {
@@ -265,7 +263,6 @@ get_struct_from_attrs(Attr a) {
     }
     return Qundef;
 }
-#endif
 
 static VALUE
 get_class_from_attrs(Attr a, PInfo pi, VALUE base_class) {
@@ -363,7 +360,7 @@ parse_regexp(const char *text) {
     int		options = 0;
 
     te = text + strlen(text) - 1;
-#if HAS_ONIG
+#ifdef ONIG_OPTION_IGNORECASE
     for (; text < te && '/' != *te; te--) {
 	switch (*te) {
 	case 'i':	options |= ONIG_OPTION_IGNORECASE;	break;
@@ -379,18 +376,12 @@ parse_regexp(const char *text) {
 static void
 instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     if (0 == strcmp("xml", target)) {
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
 	for (; 0 != attrs->name; attrs++) {
 	    if (0 == strcmp("encoding", attrs->name)) {
 		pi->options->rb_enc = rb_enc_find(attrs->value);
 	    }
 	}
-#elif HAS_PRIVATE_ENCODING
-	for (; 0 != attrs->name; attrs++) {
-	    if (0 == strcmp("encoding", attrs->name)) {
-		pi->options->rb_enc = rb_str_new2(attrs->value);
-	    }
-	}
 #endif
     }
 }
@@ -417,14 +408,10 @@ add_text(PInfo pi, char *text, int closed) {
     case NoCode:
     case StringCode:
 	h->obj = rb_str_new2(text);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	if (0 != pi->options->rb_enc) {
 	    rb_enc_associate(h->obj, pi->options->rb_enc);
 	}
-#elif HAS_PRIVATE_ENCODING
-	if (Qnil != pi->options->rb_enc) {
-	    rb_funcall(h->obj, ox_force_encoding_id, 1, pi->options->rb_enc);
-	}
 #endif
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, h->obj, (unsigned long)pi->id);
@@ -494,14 +481,10 @@ add_text(PInfo pi, char *text, int closed) {
 
 	from_base64(text, (uchar*)str);
 	v = rb_str_new(str, str_size);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 	if (0 != pi->options->rb_enc) {
 	    rb_enc_associate(v, pi->options->rb_enc);
 	}
-#elif HAS_PRIVATE_ENCODING
-	if (0 != pi->options->rb_enc) {
-	    rb_funcall(v, ox_force_encoding_id, 1, pi->options->rb_enc);
-	}
 #endif
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, v, (unsigned long)h->obj);
@@ -542,11 +525,7 @@ add_text(PInfo pi, char *text, int closed) {
 	h->obj = rb_cstr_to_inum(text, 10, 1);
 	break;
     case BigDecimalCode:
-#if HAS_BIGDECIMAL
 	h->obj = rb_funcall(rb_cObject, ox_bigdecimal_id, 1, rb_str_new2(text));
-#else
-	h->obj = Qnil;
-#endif
 	break;
     default:
 	h->obj = Qnil;
@@ -670,15 +649,10 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
 	}
 	break;
     case StructCode:
-#if HAS_RSTRUCT
 	h->obj = get_struct_from_attrs(attrs);
 	if (0 != pi->circ_array) {
 	    circ_array_set(pi->circ_array, h->obj, get_id_from_attrs(pi, attrs));
 	}
-#else
-	set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-	return;
-#endif
 	break;
     case ClassCode:
 	if (Qundef == (h->obj = get_class_from_attrs(attrs, pi, ox_bag_clas))) {
@@ -742,31 +716,29 @@ end_element(PInfo pi, const char *ename) {
 	    case ExceptionCode:
 	    case ObjectCode:
 		if (Qnil != ph->obj) {
-		    if (0 == h->var) {
+		    if (0 == h->var || NULL == rb_id2name(h->var )) {
 			set_error(&pi->err, "Invalid element for object mode", pi->str, pi->s);
 			return;
 		    }
+		    if (RUBY_T_OBJECT != rb_type(ph->obj)) {
+			set_error(&pi->err, "Corrupt object encoding", pi->str, pi->s);
+			return;
+		    }
 		    rb_ivar_set(ph->obj, h->var, h->obj);
 		}
 		break;
 	    case StructCode:
-#if HAS_RSTRUCT
 		if (0 == h->var) {
 		    set_error(&pi->err, "Invalid element for object mode", pi->str, pi->s);
 		    return;
 		}
 		rb_struct_aset(ph->obj, h->var, h->obj);
-#else
-		set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-		return;
-#endif
 		break;
 	    case HashCode:
 		// put back h
 		helper_stack_push(&pi->helpers, h->var, h->obj, KeyCode);
 		break;
 	    case RangeCode:
-#if HAS_RSTRUCT
 		if (ox_beg_id == h->var) {
 		    RSTRUCT_SET(ph->obj, 0, h->obj);
 		} else if (ox_end_id == h->var) {
@@ -777,10 +749,6 @@ end_element(PInfo pi, const char *ename) {
 		    set_error(&pi->err, "Invalid range attribute", pi->str, pi->s);
 		    return;
 		}
-#else
-		set_error(&pi->err, "Ruby structs not supported with this verion of Ruby", pi->str, pi->s);
-		return;
-#endif
 		break;
 	    case KeyCode:
 		{

data/ext/ox/ox.c

@@ -154,10 +154,8 @@ static VALUE 	element_key_mod_sym;
 static ID	encoding_id;
 static ID	has_key_id;
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
 rb_encoding	*ox_utf8_encoding = 0;
-#elif HAS_PRIVATE_ENCODING
-VALUE		ox_utf8_encoding = Qnil;
 #else
 void		*ox_utf8_encoding = 0;
 #endif
@@ -186,11 +184,7 @@ struct _options	 ox_default_options = {
     NULL,		// html_hints
     Qnil,		// attr_key_mod;
     Qnil,		// element_key_mod;
-#if HAS_PRIVATE_ENCODING
-    Qnil		// rb_enc
-#else
     0			// rb_enc
-#endif
 };
 
 extern ParseCallbacks	ox_obj_callbacks;
@@ -470,11 +464,8 @@ set_def_opts(VALUE self, VALUE opts) {
     } else {
 	Check_Type(v, T_STRING);
 	strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
 	ox_default_options.rb_enc = rb_enc_find(ox_default_options.encoding);
-#elif HAS_PRIVATE_ENCODING
-	ox_default_options.rb_enc = rb_str_new2(ox_default_options.encoding);
-	rb_gc_register_address(&ox_default_options.rb_enc);
 #endif
     }
 
@@ -674,14 +665,14 @@ to_obj(VALUE self, VALUE ruby_xml) {
 	xml = ALLOCA_N(char, len);
     }
     memcpy(xml, x, len);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_disable();
 #endif
     obj = ox_parse(xml, len - 1, ox_obj_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
 	xfree(xml);
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     RB_GC_GUARD(obj);
     rb_gc_enable();
 #endif
@@ -848,7 +839,7 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
 	    options.margin_len = strlen(options.margin);
 	}
     }
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     if ('\0' == *options.encoding) {
 	if (Qnil != encoding) {
 	    options.rb_enc = rb_enc_from_index(rb_enc_get_index(encoding));
@@ -858,26 +849,15 @@ load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, E
     } else if (0 == options.rb_enc) {
 	options.rb_enc = rb_enc_find(options.encoding);
     }
-#elif HAS_PRIVATE_ENCODING
-    if ('\0' == *options.encoding) {
-	if (Qnil != encoding) {
-	    options.rb_enc = encoding;
-	} else {
-	    options.rb_enc = Qnil;
-	}
-    } else if (0 == options.rb_enc) {
-	options.rb_enc = rb_str_new2(options.encoding);
-	rb_gc_register_address(&options.rb_enc);
-    }
 #endif
     xml = defuse_bom(xml, &options);
     switch (options.mode) {
     case ObjMode:
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	rb_gc_disable();
 #endif
 	obj = ox_parse(xml, len, ox_obj_callbacks, 0, &options, err);
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
 	RB_GC_GUARD(obj);
 	rb_gc_enable();
 #endif
@@ -946,14 +926,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
     } else {
 	xml = ALLOCA_N(char, len);
     }
-#if HAS_ENCODING_SUPPORT
-#ifdef MACRUBY_RUBY
-    encoding = rb_funcall(*argv, encoding_id, 0);
-#else
+#if HAVE_RB_OBJ_ENCODING
     encoding = rb_obj_encoding(*argv);
-#endif
-#elif HAS_PRIVATE_ENCODING
-    encoding = rb_funcall(*argv, encoding_id, 0);
 #else
     encoding = Qnil;
 #endif
@@ -1319,21 +1293,38 @@ dump(int argc, VALUE *argv, VALUE self) {
 	rb_raise(rb_eNoMemError, "Not enough memory.\n");
     }
     rstr = rb_str_new2(xml);
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_ASSOCIATE
     if ('\0' != *copts.encoding) {
 	rb_enc_associate(rstr, rb_enc_find(copts.encoding));
     }
-#elif HAS_PRIVATE_ENCODING
-    if ('\0' != *copts.encoding) {
-	rb_funcall(rstr, ox_force_encoding_id, 1, rb_str_new2(copts.encoding));
-    }
 #endif
     xfree(xml);
 
     return rstr;
 }
 
-/* call-seq: to_file(file_path, obj, options)
+/* call-seq: to_xml(obj, options) => xml-string
+ *
+ * Dumps an Object (obj) to a string.
+ * - +obj+ [Object] Object to serialize as an XML document String
+ * - +options+ [Hash] formating options
+ *   - *:indent* [Fixnum] format expected
+ *   - *:no_empty* [true|false] if true don't output empty elements
+ *   - *:xsd_date* [true|false] use XSD date format if true, default: false
+ *   - *:circular* [true|false] allow circular references, default: false
+ *   - *:strict|:tolerant]* [ :effort effort to use when an undumpable object (e.g., IO) is encountered, default: :strict
+ *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
+ *     - _:tolerant_ - replaces undumplable objects with nil
+ *
+ * Note that an indent of less than zero will result in a tight one line output
+ * unless the text in the XML fields contain new line characters.
+ */
+static VALUE
+to_xml(int argc, VALUE *argv, VALUE self) {
+    return dump(argc, argv, self);
+}
+
+/* call-seq: to_file(file_path, obj, options) => Object
  *
  * Dumps an Object to the specified file.
  * - +file_path+ [String] file path to write the XML document to
@@ -1392,7 +1383,7 @@ void Init_ox() {
     rb_define_module_function(Ox, "sax_parse", sax_parse, -1);
     rb_define_module_function(Ox, "sax_html", sax_html, -1);
 
-    rb_define_module_function(Ox, "to_xml", dump, -1);
+    rb_define_module_function(Ox, "to_xml", to_xml, -1);
     rb_define_module_function(Ox, "dump", dump, -1);
 
     rb_define_module_function(Ox, "load_file", load_file, -1);
@@ -1555,11 +1546,8 @@ void Init_ox() {
     rb_define _module_function(Ox, "cache8_test", cache8_test, 0);
 #endif
 
-#if HAS_ENCODING_SUPPORT
+#if HAVE_RB_ENC_FIND
     ox_utf8_encoding = rb_enc_find("UTF-8");
-#elif HAS_PRIVATE_ENCODING
-    ox_utf8_encoding = rb_str_new2("UTF-8");
-    rb_gc_register_address(&ox_utf8_encoding);
 #endif
 }
 
@@ -1580,7 +1568,7 @@ _ox_raise_error(const char *msg, const char *xml, const char *current, const cha
 	    xline++;
 	}
     }
-#if HAS_GC_GUARD
+#ifdef RB_GC_GUARD
     rb_gc_enable();
 #endif
     rb_raise(ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);