ox 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a200a69cf6325bb5b0609452e4075b30ad3c432b
-  data.tar.gz: 96f8028076776533ae56dd098b970fbbd9937a6e
+  metadata.gz: 75309ac947bc1f273ca4f6f65096f8fd114bf4ab
+  data.tar.gz: 481e35498618a38fde11809e04abf896024ab43f
 SHA512:
-  metadata.gz: cc2eb452d9d428d943c46ab4a412374f1ca97f127684c654008880ca7bc9415df11551c199a030953b23f4e957a3b1a81750207f4aeb5814da10d836b1f399d2
-  data.tar.gz: bb36e32b2dc96a17b1c56f96ade6eab40ad349e0e14ffff0726f5e36992ac4df3c1eeaf4df2b52eb513a13c4bac42bed34e12657b206e707f9121aeb48e17354
+  metadata.gz: 3fa20f3ffd22f25b93984ac9f89948a76f90b6398e085980b7295ed634e0e1baf4399c43e2612821da8f47dd2ea8c0da01ae9712923f7042ab646ac7c463c406
+  data.tar.gz: d2769754eea05431e2e0b6be87bc0bed35992d28ab0b159d967a2198dcaa44489d538f48d96de1a4d8152f2a72ad2d5563b580a2f9064281ef876eb55d9fb5d3

data/CHANGELOG.md

@@ -1,4 +1,11 @@
 
+## 2.7.0 - August 18, 2017
+
+  - Two new load modes added, :hash and :hash_no_attrs. Both load an XML
+    document to create a Hash populated with core Ruby objects.
+
+  - Worked around Ruby API change for RSTRUCT_LEN so Ruby 2.4.2 does not crash.
+
 ## 2.6.0 - August 9, 2017
 
   - The Element#each() method was added to allow iteration over Element nodes conditionally.

data/ext/ox/builder.c

@@ -104,13 +104,13 @@ append_indent(Builder b) {
 }
 
 static void
-append_string(Builder b, const char *str, size_t size, const char *table) {
+append_string(Builder b, const char *str, size_t size, const char *table, bool strip_invalid_chars) {
     size_t	xsize = xml_str_len((const unsigned char*)str, size, table);
 
     if (size == xsize) {
 	const char	*s = str;
 	const char	*end = str + size;
-	
+
 	buf_append_string(&b->buf, str, size);
 	b->col += size;
         s = strchr(s, '\n');
@@ -126,7 +126,7 @@ append_string(Builder b, const char *str, size_t size, const char *table) {
 	char	*bp = buf;
 	int	i = size;
 	int	fcnt;
-	
+
 	for (; '\0' != *str && 0 < i; i--, str++) {
 	    if ('1' == (fcnt = table[(unsigned char)*str])) {
 		if (end <= bp) {
@@ -166,7 +166,9 @@ append_string(Builder b, const char *str, size_t size, const char *table) {
 		    break;
 		default:
 		    // Must be one of the invalid characters.
-		    rb_raise(rb_eSyntaxError, "'\\#x%02x' is not a valid XML character.", *str);
+		    if (!strip_invalid_chars) {
+			rb_raise(rb_eSyntaxError, "'\\#x%02x' is not a valid XML character.", *str);
+		    }
 		    break;
 		}
 	    }
@@ -182,7 +184,7 @@ static void
 append_sym_str(Builder b, VALUE v) {
     const char	*s;
     int		len;
-    
+
     switch (rb_type(v)) {
     case T_STRING:
 	s = StringValuePtr(v);
@@ -196,14 +198,14 @@ append_sym_str(Builder b, VALUE v) {
 	rb_raise(ox_arg_error_class, "expected a Symbol or String");
 	break;
     }
-    append_string(b, s, len, xml_element_chars);
+    append_string(b, s, len, xml_element_chars, false);
 }
 
 static void
 i_am_a_child(Builder b, bool is_text) {
     if (0 <= b->depth) {
 	Element	e = &b->stack[b->depth];
-	
+
 	if (!e->has_child) {
 	    e->has_child = true;
 	    buf_append(&b->buf, '>');
@@ -226,11 +228,11 @@ append_attr(VALUE key, VALUE value, Builder b) {
     b->col += 2;
     b->pos += 2;
     Check_Type(value, T_STRING);
-    append_string(b, StringValuePtr(value), (int)RSTRING_LEN(value), xml_attr_chars);
+    append_string(b, StringValuePtr(value), (int)RSTRING_LEN(value), xml_attr_chars, false);
     buf_append(&b->buf, '"');
     b->col++;
     b->pos++;
-    
+
     return ST_CONTINUE;
 }
 
@@ -250,7 +252,7 @@ builder_free(void *ptr) {
     Builder	b;
     Element	e;
     int		d;
-    
+
     if (0 == ptr) {
 	return;
     }
@@ -349,7 +351,7 @@ builder_new(int argc, VALUE *argv, VALUE self) {
     Builder	b = ALLOC(struct _Builder);
     int		indent = ox_default_options.indent;
     long	buf_size = 0;
-    
+
     if (1 == argc) {
 	volatile VALUE	v;
 
@@ -380,7 +382,7 @@ builder_new(int argc, VALUE *argv, VALUE self) {
 
     if (rb_block_given_p()) {
 	volatile VALUE	rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
-	
+
 	rb_yield(rb);
 	bclose(b);
 
@@ -405,7 +407,7 @@ builder_file(int argc, VALUE *argv, VALUE self) {
     int		indent = ox_default_options.indent;
     long	buf_size = 0;
     FILE	*f;
-    
+
     if (1 > argc) {
 	rb_raise(ox_arg_error_class, "missing filename");
     }
@@ -468,7 +470,7 @@ builder_io(int argc, VALUE *argv, VALUE self) {
     long		buf_size = 0;
     int			fd;
     volatile VALUE	v;
-    
+
     if (1 > argc) {
 	rb_raise(ox_arg_error_class, "missing IO object");
     }
@@ -534,14 +536,14 @@ builder_instruct(int argc, VALUE *argv, VALUE self) {
 	b->pos += 7;
     } else {
 	volatile VALUE	v;
-	
+
 	buf_append_string(&b->buf, "<?", 2);
 	b->col += 2;
 	b->pos += 2;
 	append_sym_str(b, *argv);
 	if (1 < argc && rb_cHash == rb_obj_class(argv[1])) {
 	    int	len;
-		
+
 	    if (Qnil != (v = rb_hash_lookup(argv[1], ox_version_sym))) {
 		if (rb_cString != rb_obj_class(v)) {
 		    rb_raise(ox_parse_error_class, ":version must be a Symbol.\n");
@@ -637,7 +639,7 @@ builder_element(int argc, VALUE *argv, VALUE self) {
     buf_append(&b->buf, '<');
     b->col++;
     b->pos++;
-    append_string(b, e->name, len, xml_element_chars);
+    append_string(b, e->name, len, xml_element_chars, false);
     if (1 < argc) {
 	rb_hash_foreach(argv[1], append_attr, (VALUE)b);
     }
@@ -657,18 +659,18 @@ builder_element(int argc, VALUE *argv, VALUE self) {
 static VALUE
 builder_comment(VALUE self, VALUE text) {
     Builder	b = (Builder)DATA_PTR(self);
-    
+
     rb_check_type(text, T_STRING);
     i_am_a_child(b, false);
     append_indent(b);
     buf_append_string(&b->buf, "<!-- ", 5);
     b->col += 5;
     b->pos += 5;
-    append_string(b, StringValuePtr(text), RSTRING_LEN(text), xml_element_chars);
+    append_string(b, StringValuePtr(text), RSTRING_LEN(text), xml_element_chars, false);
     buf_append_string(&b->buf, " --/> ", 5);
     b->col += 5;
     b->pos += 5;
-	
+
     return Qnil;
 }
 
@@ -687,7 +689,7 @@ builder_doctype(VALUE self, VALUE text) {
     buf_append_string(&b->buf, "<!DOCTYPE ", 10);
     b->col += 10;
     b->pos += 10;
-    append_string(b, StringValuePtr(text), RSTRING_LEN(text), xml_element_chars);
+    append_string(b, StringValuePtr(text), RSTRING_LEN(text), xml_element_chars, false);
     buf_append(&b->buf, '>');
     b->col++;
     b->pos++;
@@ -699,17 +701,29 @@ builder_doctype(VALUE self, VALUE text) {
  *
  * Adds a text element to the XML string being formed.
  * - +text+ - (String) contents of the text field
+ * - +strip_invalid_chars+ - [true|false] strips any characters invalid for XML, defaults to false
  */
 static VALUE
-builder_text(VALUE self, VALUE text) {
+builder_text(int argc, VALUE *argv, VALUE self) {
     Builder		b = (Builder)DATA_PTR(self);
-    volatile VALUE	v = text;
+    volatile VALUE	v;
+    volatile VALUE	strip_invalid_chars;
+
+    if ((0 == argc) || (argc > 2)) {
+	rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1..2)", argc);
+    }
+    v = argv[0];
+    if (2 == argc) {
+	strip_invalid_chars = argv[1];
+    } else {
+	strip_invalid_chars = Qfalse;
+    }
 
     if (T_STRING != rb_type(v)) {
 	v = rb_funcall(v, ox_to_s_id, 0);
     }
     i_am_a_child(b, true);
-    append_string(b, StringValuePtr(v), RSTRING_LEN(v), xml_element_chars);
+    append_string(b, StringValuePtr(v), RSTRING_LEN(v), xml_element_chars, RTEST(strip_invalid_chars));
 
     return Qnil;
 }
@@ -865,7 +879,7 @@ void ox_init_builder(VALUE ox) {
     rb_define_method(builder_class, "comment", builder_comment, 1);
     rb_define_method(builder_class, "doctype", builder_doctype, 1);
     rb_define_method(builder_class, "element", builder_element, -1);
-    rb_define_method(builder_class, "text", builder_text, 1);
+    rb_define_method(builder_class, "text", builder_text, -1);
     rb_define_method(builder_class, "cdata", builder_cdata, 1);
     rb_define_method(builder_class, "raw", builder_raw, 1);
     rb_define_method(builder_class, "pop", builder_pop, 0);

data/ext/ox/dump.c

@@ -826,12 +826,11 @@ dump_obj(ID aid, VALUE obj, int depth, Out out) {
 	    int		d2 = depth + 1;
 #if UNIFY_FIXNUM_AND_BIGNUM
 		long i;
-		long cnt = NUM2LONG(RSTRUCT_LEN(obj));
+		long cnt = NUM2LONG(rb_struct_size(obj));
 #else // UNIFY_FIXNUM_AND_INTEGER
 		int   i;
 		int   cnt = (int)RSTRUCT_LEN(obj);
 #endif // UNIFY_FIXNUM_AND_INTEGER
-	    
 	    e.type = StructCode;
 	    e.clas.str = rb_class2name(clas);
 	    e.clas.len = strlen(e.clas.str);

data/ext/ox/err.c

@@ -17,7 +17,7 @@ ox_err_set(Err e, VALUE clas, const char *format, ...) {
     va_end(ap);
 }
 
-void
+_Noreturn void
 ox_err_raise(Err e) {
     rb_raise(e->clas, "%s", e->msg);
 }

data/ext/ox/gen_load.c

@@ -34,6 +34,7 @@ struct _ParseCallbacks   _ox_gen_callbacks = {
     add_text,
     add_element,
     end_element,
+    NULL,
 };
 
 ParseCallbacks   ox_gen_callbacks = &_ox_gen_callbacks;
@@ -46,6 +47,7 @@ struct _ParseCallbacks   _ox_limited_callbacks = {
     add_text,
     add_element,
     end_element,
+    NULL,
 };
 
 ParseCallbacks   ox_limited_callbacks = &_ox_limited_callbacks;
@@ -58,6 +60,7 @@ struct _ParseCallbacks   _ox_nomode_callbacks = {
     add_text,
     add_element,
     end_element,
+    NULL,
 };
 
 ParseCallbacks   ox_nomode_callbacks = &_ox_nomode_callbacks;

data/ext/ox/hash_load.c

@@ -0,0 +1,224 @@
+/* hash_load.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "ruby.h"
+#include "ox.h"
+
+// 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();;
+
+    helper_stack_push(&pi->helpers, 0, top, HashCode);
+    pi->obj = top;
+
+    return top;
+}
+
+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 (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:
+	parent->obj = s;
+	parent->type = StringCode;
+	break;
+    case ArrayCode:
+	rb_ary_push(parent->obj, s);
+	break;
+    default:
+	a = rb_ary_new();
+	rb_ary_push(a, parent->obj);
+	rb_ary_push(a, s);
+	parent->obj = a;
+	parent->type = ArrayCode;
+	break;
+    }
+}
+
+static void
+add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+    if (helper_stack_empty(&pi->helpers)) {
+	create_top(pi);
+    }
+    if (NULL != attrs && NULL != attrs->name) {
+	volatile VALUE	h = rb_hash_new();
+        volatile VALUE	key;
+	volatile VALUE	val;
+	volatile VALUE	a;
+	
+        for (; 0 != attrs->name; attrs++) {
+	    if (Yes == pi->options->sym_keys) {
+		key = rb_id2sym(rb_intern(attrs->name));
+	    } else {
+		key = rb_str_new2(attrs->name);
+	    }
+	    val = rb_str_new2(attrs->value);
+#if HAS_ENCODING_SUPPORT
+	    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
+	helper_stack_push(&pi->helpers, rb_intern(ename), a, ArrayCode);
+    } else {
+	helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
+    }
+}
+
+static void
+add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+    if (helper_stack_empty(&pi->helpers)) {
+	create_top(pi);
+    }
+    helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
+}
+
+static int
+untaint_hash_cb(VALUE key, VALUE value, VALUE x) {
+    if (Qtrue == rb_obj_tainted(value)) {
+	rb_obj_untaint(value);
+    }
+    return ST_CONTINUE;
+}
+
+static void
+end_element_core(PInfo pi, const char *ename, bool check_taint) {
+    Helper		e = helper_stack_pop(&pi->helpers);
+    Helper		parent = helper_stack_peek(&pi->helpers);
+    volatile VALUE	pobj = parent->obj;
+    volatile VALUE	found = Qundef;
+    volatile VALUE	key;
+    volatile VALUE	a;
+
+    if (NoCode == e->type) {
+	e->obj = Qnil;
+    }
+    if (Yes == pi->options->sym_keys) {
+	key = rb_id2sym(e->var);
+    } else {
+	key = rb_id2str(e->var);
+    }
+    // Make sure the parent is a Hash. If not set then make a Hash. If an
+    // Array or non-Hash then append to array or create and append.
+    switch (parent->type) {
+    case NoCode:
+	pobj = rb_hash_new();
+	parent->obj = pobj;
+	parent->type = HashCode;
+	break;
+    case ArrayCode:
+	pobj = rb_hash_new();
+	rb_ary_push(parent->obj, pobj);
+	break;
+    case HashCode:
+	found = rb_hash_lookup2(parent->obj, key, Qundef);
+	break;
+    default:
+	a = rb_ary_new();
+	rb_ary_push(a, parent->obj);
+	pobj = rb_hash_new();
+	rb_ary_push(a, pobj);
+	parent->obj = a;
+	parent->type = ArrayCode;
+	break;
+    }
+    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);
+	    a = rb_ary_new();
+	    rb_ary_push(a, found);
+	    rb_ary_push(a, e->obj);
+	    rb_hash_aset(pobj, key, a);
+	} else {
+	    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);
+	}
+	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);
+    }
+}
+
+static void
+end_element(PInfo pi, const char *ename) {
+    end_element_core(pi, ename, true);
+}
+
+static void
+end_element_no_attrs(PInfo pi, const char *ename) {
+    end_element_core(pi, ename, false);
+}
+
+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);
+    }
+}
+
+struct _ParseCallbacks   _ox_hash_callbacks = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    add_text,
+    add_element,
+    end_element,
+    finish,
+};
+
+ParseCallbacks   ox_hash_callbacks = &_ox_hash_callbacks;
+
+struct _ParseCallbacks   _ox_hash_no_attrs_callbacks = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    add_text,
+    add_element_no_attrs,
+    end_element_no_attrs,
+    NULL,
+};
+
+ParseCallbacks   ox_hash_no_attrs_callbacks = &_ox_hash_no_attrs_callbacks;

data/ext/ox/obj_load.c

@@ -46,6 +46,7 @@ struct _ParseCallbacks	 _ox_obj_callbacks = {
     add_text,
     add_element,
     end_element,
+    NULL,
 };
 
 ParseCallbacks	 ox_obj_callbacks = &_ox_obj_callbacks;

data/ext/ox/ox.c

@@ -115,6 +115,8 @@ static VALUE	circular_sym;
 static VALUE	convert_special_sym;
 static VALUE	effort_sym;
 static VALUE	generic_sym;
+static VALUE	hash_no_attrs_sym;
+static VALUE	hash_sym;
 static VALUE	inactive_sym;
 static VALUE	invalid_replace_sym;
 static VALUE	limited_sym;
@@ -185,6 +187,8 @@ extern ParseCallbacks	ox_obj_callbacks;
 extern ParseCallbacks	ox_gen_callbacks;
 extern ParseCallbacks	ox_limited_callbacks;
 extern ParseCallbacks	ox_nomode_callbacks;
+extern ParseCallbacks	ox_hash_callbacks;
+extern ParseCallbacks	ox_hash_no_attrs_callbacks;
 
 static void	parse_dump_options(VALUE ropts, Options copts);
 
@@ -271,7 +275,7 @@ hints_to_overlay(Hints hints) {
  * - _:with_xml_ [true|false|nil] include XML prolog in the dump
  * - _:circular_ [true|false|nil] support circular references while dumping
  * - _:xsd_date_ [true|false|nil] use XSD date format instead of decimal format
- * - _:mode_ [:object|:generic|:limited|nil] load method to use for XML
+ * - _:mode_ [:object|:generic|:limited|:hash|:hash_no_attrs|nil] load method to use for XML
  * - _:effort_ [:strict|:tolerant|:auto_define] set the tolerance level for loading
  * - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings
  * - _:skip_ [:skip_none|:skip_return|:skip_white] determines how to handle white space in text
@@ -310,11 +314,13 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, smart_sym, (Yes == ox_default_options.smart) ? Qtrue : ((No == ox_default_options.smart) ? Qfalse : Qnil));
     rb_hash_aset(opts, convert_special_sym, (ox_default_options.convert_special) ? Qtrue : Qfalse);
     switch (ox_default_options.mode) {
-    case ObjMode:	rb_hash_aset(opts, mode_sym, object_sym);	break;
-    case GenMode:	rb_hash_aset(opts, mode_sym, generic_sym);	break;
-    case LimMode:	rb_hash_aset(opts, mode_sym, limited_sym);	break;
+    case ObjMode:		rb_hash_aset(opts, mode_sym, object_sym);		break;
+    case GenMode:		rb_hash_aset(opts, mode_sym, generic_sym);		break;
+    case LimMode:		rb_hash_aset(opts, mode_sym, limited_sym);		break;
+    case HashMode:		rb_hash_aset(opts, mode_sym, hash_sym);			break;
+    case HashNoAttrMode:	rb_hash_aset(opts, mode_sym, hash_no_attrs_sym);	break;
     case NoMode:
-    default:		rb_hash_aset(opts, mode_sym, Qnil);		break;
+    default:			rb_hash_aset(opts, mode_sym, Qnil);			break;
     }
     switch (ox_default_options.effort) {
     case StrictEffort:		rb_hash_aset(opts, effort_sym, strict_sym);		break;
@@ -404,7 +410,7 @@ sax_html_overlay(VALUE self) {
  *   - _:with_xml_ [true|false|nil] include XML prolog in the dump
  *   - _:circular_ [true|false|nil] support circular references while dumping
  *   - _:xsd_date_ [true|false|nil] use XSD date format instead of decimal format
- *   - _:mode_ [:object|:generic|:limited|nil] load method to use for XML
+ *   - _:mode_ [:object|:generic|:limited|:hash|:hash_no_attrs|nil] load method to use for XML
  *   - _:effort_ [:strict|:tolerant|:auto_define] set the tolerance level for loading
  *   - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings
  *   - _:skip_ [:skip_none|:skip_return|:skip_white] determines how to handle white space in text
@@ -473,8 +479,12 @@ set_def_opts(VALUE self, VALUE opts) {
 	ox_default_options.mode = GenMode;
     } else if (limited_sym == v) {
 	ox_default_options.mode = LimMode;
+    } else if (hash_sym == v) {
+	ox_default_options.mode = HashMode;
+    } else if (hash_no_attrs_sym == v) {
+	ox_default_options.mode = HashNoAttrMode;
     } else {
-	rb_raise(ox_parse_error_class, ":mode must be :object, :generic, :limited, or nil.\n");
+	rb_raise(ox_parse_error_class, ":mode must be :object, :generic, :limited, :hash, :hash_no_attrs, or nil.\n");
     }
 
     v = rb_hash_aref(opts, effort_sym);
@@ -700,8 +710,12 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
 		options.mode = GenMode;
 	    } else if (limited_sym == v) {
 		options.mode = LimMode;
+	    } else if (hash_sym == v) {
+		options.mode = HashMode;
+	    } else if (hash_no_attrs_sym == v) {
+		options.mode = HashNoAttrMode;
 	    } else {
-		rb_raise(ox_parse_error_class, ":mode must be :generic, :object, or :limited.\n");
+		rb_raise(ox_parse_error_class, ":mode must be :generic, :object, :limited, :hash, :hash_no_attrs.\n");
 	    }
 	}
 	if (Qnil != (v = rb_hash_lookup(h, effort_sym))) {
@@ -830,6 +844,12 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
     case LimMode:
 	obj = ox_parse(xml, ox_limited_callbacks, 0, &options, err);
 	break;
+    case HashMode:
+	obj = ox_parse(xml, ox_hash_callbacks, 0, &options, err);
+	break;
+    case HashNoAttrMode:
+	obj = ox_parse(xml, ox_hash_no_attrs_callbacks, 0, &options, err);
+	break;
     case NoMode:
 	obj = ox_parse(xml, ox_nomode_callbacks, 0, &options, err);
 	break;
@@ -854,6 +874,8 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
  *     - _:object_ - object format
  *     - _:generic_ - read as a generic XML file
  *     - _:limited_ - read as a generic XML file but with callbacks on text and elements events only
+ *     - _:hash_ - read and convert to a Hash and core class objects only
+ *     - _:hash_no_attrs_ - read and convert to a Hash and core class objects only without capturing attributes
  *   - *:effort* [:strict|:tolerant|:auto_define] effort to use when an undefined class is encountered, default: :strict
  *     - _:strict_ - raise an NameError for missing classes and modules
  *     - _:tolerant_ - return nil for missing classes and modules
@@ -913,6 +935,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
  *     - _:object_ - object format
  *     - _:generic_ - read as a generic XML file
  *     - _:limited_ - read as a generic XML file but with callbacks on text and elements events only
+ *     - _:hash_ - read and convert to a Hash and core class objects only
+ *     - _:hash_no_attrs_ - read and convert to a Hash and core class objects only without capturing attributes
  *   - *:effort* [:strict|:tolerant|:auto_define] effort to use when an undefined class is encountered, default: :strict
  *     - _:strict_ - raise an NameError for missing classes and modules
  *     - _:tolerant_ - return nil for missing classes and modules
@@ -1412,9 +1436,12 @@ void Init_ox() {
     convert_special_sym = ID2SYM(rb_intern("convert_special")); rb_gc_register_address(&convert_special_sym);
     effort_sym = ID2SYM(rb_intern("effort"));			rb_gc_register_address(&effort_sym);
     generic_sym = ID2SYM(rb_intern("generic"));			rb_gc_register_address(&generic_sym);
+    hash_no_attrs_sym = ID2SYM(rb_intern("hash_no_attrs"));	rb_gc_register_address(&hash_no_attrs_sym);
+    hash_sym = ID2SYM(rb_intern("hash"));			rb_gc_register_address(&hash_sym);
     inactive_sym = ID2SYM(rb_intern("inactive"));		rb_gc_register_address(&inactive_sym);
     invalid_replace_sym = ID2SYM(rb_intern("invalid_replace"));	rb_gc_register_address(&invalid_replace_sym);
     limited_sym = ID2SYM(rb_intern("limited"));			rb_gc_register_address(&limited_sym);
+    margin_sym = ID2SYM(rb_intern("margin"));			rb_gc_register_address(&margin_sym);
     mode_sym = ID2SYM(rb_intern("mode"));			rb_gc_register_address(&mode_sym);
     nest_ok_sym = ID2SYM(rb_intern("nest_ok"));			rb_gc_register_address(&nest_ok_sym);
     object_sym = ID2SYM(rb_intern("object"));			rb_gc_register_address(&object_sym);
@@ -1434,7 +1461,6 @@ void Init_ox() {
     smart_sym = ID2SYM(rb_intern("smart"));			rb_gc_register_address(&smart_sym);
     strict_sym = ID2SYM(rb_intern("strict"));			rb_gc_register_address(&strict_sym);
     strip_namespace_sym = ID2SYM(rb_intern("strip_namespace"));	rb_gc_register_address(&strip_namespace_sym);
-    margin_sym = ID2SYM(rb_intern("margin"));			rb_gc_register_address(&margin_sym);
     symbolize_keys_sym = ID2SYM(rb_intern("symbolize_keys"));	rb_gc_register_address(&symbolize_keys_sym);
     symbolize_sym = ID2SYM(rb_intern("symbolize"));		rb_gc_register_address(&symbolize_sym);
     tolerant_sym = ID2SYM(rb_intern("tolerant"));		rb_gc_register_address(&tolerant_sym);
@@ -1477,7 +1503,7 @@ void Init_ox() {
 #endif
 }
 
-void
+_Noreturn void
 _ox_raise_error(const char *msg, const char *xml, const char *current, const char* file, int line) {
     int	xline = 1;
     int	col = 1;

data/ext/ox/ox.h

@@ -87,10 +87,12 @@ typedef enum {
 } YesNo;
 
 typedef enum {
-    ObjMode  = 'o',
-    GenMode  = 'g',
-    LimMode  = 'l',
-    NoMode   = 0
+    ObjMode        = 'o',
+    GenMode        = 'g',
+    LimMode        = 'l',
+    HashMode       = 'h',
+    HashNoAttrMode = 'n',
+    NoMode         = 0
 } LoadMode;
 
 typedef enum {
@@ -109,6 +111,7 @@ typedef struct _ParseCallbacks {
     void	(*add_text)(PInfo pi, char *text, int closed);
     void	(*add_element)(PInfo pi, const char *ename, Attr attrs, int hasChildren);
     void	(*end_element)(PInfo pi, const char *ename);
+    void	(*finish)(PInfo pi);
 } *ParseCallbacks;
 
 typedef struct _CircArray {

data/ext/ox/parse.c

@@ -93,12 +93,27 @@ next_white(PInfo pi) {
     }
 }
 
+static void
+mark_pi_cb(void *ptr) {
+    if (NULL != ptr) {
+	HelperStack	stack = &((PInfo)ptr)->helpers;
+	Helper		h;
+
+	for (h = stack->head; h < stack->tail; h++) {
+	    if (NoCode != h->type) {
+		rb_gc_mark(h->obj);
+	    }
+	}
+    }
+}
+
 VALUE
 ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err) {
     struct _PInfo	pi;
     int			body_read = 0;
     int			block_given = rb_block_given_p();
-
+    volatile VALUE	wrap;
+    
     if (0 == xml) {
 	set_error(err, "Invalid arg, xml string can not be null", xml, 0);
 	return Qnil;
@@ -108,6 +123,9 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err) {
     }
     /* initialize parse info */
     helper_stack_init(&pi.helpers);
+    // Protect against GC
+    wrap = rb_data_object_wrap(rb_cObject, &pi, mark_pi_cb, NULL);
+
     err_init(&pi.err);
     pi.str = xml;
     pi.s = xml;
@@ -175,10 +193,17 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err) {
 	    return Qnil;
 	}
 	if (block_given && Qnil != pi.obj && Qundef != pi.obj) {
+	    if (NULL != pcb->finish) {
+		pcb->finish(&pi);
+	    }
 	    rb_yield(pi.obj);
 	}
     }
+    DATA_PTR(wrap) = NULL;
     helper_stack_cleanup(&pi.helpers);
+    if (NULL != pcb->finish) {
+	pcb->finish(&pi);
+    }
     return pi.obj;
 }
 

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module. 
-  VERSION = '2.6.0'
+  VERSION = '2.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-09 00:00:00.000000000 Z
+date: 2017-09-18 00:00:00.000000000 Z
 dependencies: []
 description: "A fast XML parser and object serializer that uses only standard C lib.\n
   \           \nOptimized XML (Ox), as the name implies was written to provide speed
@@ -35,11 +35,11 @@ files:
 - ext/ox/cache8.c
 - ext/ox/cache8.h
 - ext/ox/dump.c
-- ext/ox/encode.h
 - ext/ox/err.c
 - ext/ox/err.h
 - ext/ox/extconf.rb
 - ext/ox/gen_load.c
+- ext/ox/hash_load.c
 - ext/ox/helper.h
 - ext/ox/obj_load.c
 - ext/ox/ox.c

data/ext/ox/encode.h

@@ -1,26 +0,0 @@
-/* encode.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
-
-#ifndef __OX_ENCODE_H__
-#define __OX_ENCODE_H__
-
-#include "ruby.h"
-#if HAS_ENCODING_SUPPORT
-#include "ruby/encoding.h"
-#endif
-
-static inline VALUE
-ox_encode(VALUE rstr) {
-#if HAS_ENCODING_SUPPORT
-    rb_enc_associate(rstr, ox_utf8_encoding);
-#else
-    if (Qnil != ox_utf8_encoding) {
-	rstr = rb_funcall(ox_utf8_encoding, ox_iconv_id, 1, rstr);
-    }
-#endif
-    return rstr;
-}
-
-#endif /* __OX_ENCODE_H__ */