ox 2.2.4 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46e015e0b3899db57415e3edbf2634590d199b7e
-  data.tar.gz: 5aeb573b6fdc7342b392513e4731713f4c7caee2
+  metadata.gz: 1bf8bb0abb35f28192d986125010bca5dac84737
+  data.tar.gz: edfeba0e9a4b9892f4de6b127d7717795a01f007
 SHA512:
-  metadata.gz: 1258f0904dd33ebc85adf0f89436dd1d4d783cfd2393f1cdc4fe0cfc55321c33da5fb687dd4cdda0df15922c850a27fa3cdd1a5491b4e4d713598d4de64f36db
-  data.tar.gz: 3b34e3bbfbb4b6d512f763447a822ce6552f3630e5097b03b8a33ae3ea563452cb9cc2718135b40496640b654b65c180214274594e8605924f434275373e5e98
+  metadata.gz: 9428e17927f1e89e3704401f27c40523c84ad9900826beef3df85af5f71411be9bd6a450a339dff24de28de36ece8c335235b055281b21dd4ca22a2859922dc0
+  data.tar.gz: 853e58cc23f118defd6eafb1c64483cf0a922572a9befde6edb54e4be72d6671ddfc97c4093afa31590f6c239a1cda852c5980d2e27d39e9eb33984492258bc5

data/README.md

@@ -34,20 +34,27 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## Release Notes
 
-### Release 2.2.4
+### Release 2.3.0
 
- - Changed the code to allow compilation on older compilers. No change in
-   functionality otherwise.
+ - Added Oj::Element.replace_text() method.
+
+ - Oj::Element nodes variable is now always initialized to an empty Array.
+
+ - Oj::Element attributes variable is now always initialized to an empty Hash.
 
-### Release 2.2.3
+ - A invalid_replace option has been added. It will replace invalid XML
+   character with a provided string. Strict effort now raises an exception if an
+   invalid character is encountered on dump or load.
 
- - The convert_special option now applies to attributes as well as elements in
-   the SAX parser.
+ - Oj.load and Oj.parse now allow for a callback block to handle multiple top
+   level entities in the input.
 
- - The convert_special option now applies to the regualr parser as well as the
-   SAX parser.
+ - The Oj SAX parser now supports strings as input directly without and IO wrapper.
 
- - Updated to work correctly with Ruby 2.3.0.
+### Release 2.2.4
+
+ - Changed the code to allow compilation on older compilers. No change in
+   functionality otherwise.
 
 ## Description
 

data/ext/ox/dump.c

@@ -78,8 +78,10 @@ static int	is_xml_friendly(const uchar *str, int len);
 
 static const char	hex_chars[17] = "0123456789abcdef";
 
+// The : character is equivalent to 10. Used for replacement characters up to 10
+// characters long such as ''.
 static char	xml_friendly_chars[257] = "\
-88888888811881888888888888888888\
+:::::::::11::1::::::::::::::::::\
 11611156111111111111111111114141\
 11111111111111111111111111111111\
 11111111111111111111111111111111\
@@ -315,7 +317,7 @@ dump_value(Out out, const char *value, size_t size) {
 inline static void
 dump_str_value(Out out, const char *value, size_t size) {
     size_t	xsize = xml_str_len((const uchar*)value, size);
-
+    
     if (out->end - out->cur <= (long)xsize) {
 	grow(out, xsize);
     }
@@ -323,42 +325,63 @@ dump_str_value(Out out, const char *value, size_t size) {
 	if ('1' == xml_friendly_chars[(uchar)*value]) {
 	    *out->cur++ = *value;
 	} else {
-	    *out->cur++ = '&';
 	    switch (*value) {
 	    case '"':
+		*out->cur++ = '&';
 		*out->cur++ = 'q';
 		*out->cur++ = 'u';
 		*out->cur++ = 'o';
 		*out->cur++ = 't';
+		*out->cur++ = ';';
 		break;
 	    case '&':
+		*out->cur++ = '&';
 		*out->cur++ = 'a';
 		*out->cur++ = 'm';
 		*out->cur++ = 'p';
+		*out->cur++ = ';';
 		break;
 	    case '\'':
+		*out->cur++ = '&';
 		*out->cur++ = 'a';
 		*out->cur++ = 'p';
 		*out->cur++ = 'o';
 		*out->cur++ = 's';
+		*out->cur++ = ';';
 		break;
 	    case '<':
+		*out->cur++ = '&';
 		*out->cur++ = 'l';
 		*out->cur++ = 't';
+		*out->cur++ = ';';
 		break;
 	    case '>':
+		*out->cur++ = '&';
 		*out->cur++ = 'g';
 		*out->cur++ = 't';
+		*out->cur++ = ';';
 		break;
 	    default:
-		*out->cur++ = '#';
-		*out->cur++ = 'x';
-		*out->cur++ = '0';
-		*out->cur++ = '0';
-		dump_hex(*value, out);
+		// Must be one of the invalid characters.
+		if (StrictEffort == out->opts->effort) {
+		    rb_raise(rb_eSyntaxError, "'\\#x%02x' is not a valid XML character.", *value);
+		}
+		if (Yes == out->opts->allow_invalid) {
+		    *out->cur++ = '&';
+		    *out->cur++ = '#';
+		    *out->cur++ = 'x';
+		    *out->cur++ = '0';
+		    *out->cur++ = '0';
+		    dump_hex(*value, out);
+		    *out->cur++ = ';';
+		} else if ('\0' != *out->opts->inv_repl) {
+		    // If the empty string then ignore. The first character of
+		    // the replacement is the length.
+		    memcpy(out->cur, out->opts->inv_repl + 1, (size_t)*out->opts->inv_repl);
+		    out->cur += *out->opts->inv_repl;
+		}
 		break;
 	    }
-	    *out->cur++ = ';';
 	}
     }
     *out->cur = '\0';
@@ -1016,7 +1039,7 @@ dump_gen_element(VALUE obj, int depth, Out out) {
     if (Qnil != attrs) {
 	rb_hash_foreach(attrs, dump_gen_attr, (VALUE)out);
     }
-    if (Qnil != nodes) {
+    if (Qnil != nodes && 0 < RARRAY_LEN(nodes)) {
 	int	do_indent;
 	
 	*out->cur++ = '>';
@@ -1199,6 +1222,7 @@ dump_obj_to_xml(VALUE obj, Options copts, Out out) {
 	ox_cache8_new(&out->circ_cache);
     }
     out->indent = copts->indent;
+
     if (ox_document_clas == clas) {
 	dump_gen_doc(obj, -1, out);
     } else if (ox_element_clas == clas) {

data/ext/ox/ox.c

@@ -106,6 +106,7 @@ static VALUE	convert_special_sym;
 static VALUE	effort_sym;
 static VALUE	generic_sym;
 static VALUE	indent_sym;
+static VALUE	invalid_replace_sym;
 static VALUE	limited_sym;
 static VALUE	mode_sym;
 static VALUE	object_sym;
@@ -117,6 +118,7 @@ static VALUE	skip_sym;
 static VALUE	skip_white_sym;
 static VALUE	smart_sym;
 static VALUE	strict_sym;
+static VALUE	strip_namespace_sym;
 static VALUE	symbolize_keys_sym;
 static VALUE	symbolize_sym;
 static VALUE	tolerant_sym;
@@ -126,6 +128,9 @@ static VALUE	with_instruct_sym;
 static VALUE	with_xml_sym;
 static VALUE	xsd_date_sym;
 
+static ID	encoding_id;
+static ID	has_key_id;
+
 #if HAS_ENCODING_SUPPORT
 rb_encoding	*ox_utf8_encoding = 0;
 #elif HAS_PRIVATE_ENCODING
@@ -149,6 +154,9 @@ struct _Options	 ox_default_options = {
     NoSkip,		/* skip */
     No,			/* smart */
     1,			/* convert_special */
+    No,			/* allow_invalid */
+    { '\0' },		/* inv_repl */
+    { '\0' },		/* strip_ns */
 #if HAS_PRIVATE_ENCODING
     Qnil		/* rb_enc */
 #else
@@ -229,6 +237,8 @@ defuse_bom(char *xml, Options options) {
  * - skip: [:skip_none|:skip_return|:skip_white] determines how to handle white space in text
  * - smart: [true|false|nil] flag indicating the SAX parser uses hints if available (use with html)
  * - convert_special: [true|false|nil] flag indicating special characters like < are converted with the SAX parser
+ * - invalid_replace: [nil|String] replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
+ * - strip_namespace: [String|true|false] false or "" results in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  * @return [Hash] all current option settings.
  *
  * Note that an indent of less than zero will result in a tight one line output
@@ -270,6 +280,18 @@ get_def_opts(VALUE self) {
     case SpcSkip:		rb_hash_aset(opts, skip_sym, skip_white_sym);		break;
     default:			rb_hash_aset(opts, skip_sym, Qnil);			break;
     }
+    if (Yes == ox_default_options.allow_invalid) {
+	rb_hash_aset(opts, invalid_replace_sym, Qnil);
+    } else {
+	rb_hash_aset(opts, invalid_replace_sym, rb_str_new(ox_default_options.inv_repl + 1, (int)*ox_default_options.inv_repl));
+    }
+    if ('\0' == *ox_default_options.strip_ns) {
+	rb_hash_aset(opts, strip_namespace_sym, Qfalse);
+    } else if ('*' == *ox_default_options.strip_ns && '\0' == ox_default_options.strip_ns[1]) {
+	rb_hash_aset(opts, strip_namespace_sym, Qtrue);
+    } else {
+	rb_hash_aset(opts, strip_namespace_sym, rb_str_new(ox_default_options.strip_ns, strlen(ox_default_options.strip_ns)));
+    }
     return opts;
 }
 
@@ -289,6 +311,8 @@ get_def_opts(VALUE self) {
  * @param [:strict|:tolerant|:auto_define] :effort set the tolerance level for loading
  * @param [true|false|nil] :symbolize_keys symbolize element attribute keys or leave as Strings
  * @param [:skip_none|:skip_return|:skip_white] determines how to handle white space in text
+ * @param [nil|String] :invalid_replace replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
+ * @param [nil|String|true|false] :strip_namespace "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  * @return [nil]
  */
 static VALUE
@@ -384,6 +408,43 @@ set_def_opts(VALUE self, VALUE opts) {
 	rb_raise(ox_parse_error_class, ":convert_special must be true or false.\n");
     }
 
+    v = rb_hash_aref(opts, invalid_replace_sym);
+    if (Qnil == v) {
+	ox_default_options.allow_invalid = Yes;
+    } else {
+	long	slen;
+
+	Check_Type(v, T_STRING);
+	slen = RSTRING_LEN(v);
+	if (sizeof(ox_default_options.inv_repl) - 2 < slen) {
+	    rb_raise(ox_parse_error_class, ":invalid_replace can be no longer than %ld characters.",
+		     sizeof(ox_default_options.inv_repl) - 2);
+	}
+	strncpy(ox_default_options.inv_repl + 1, StringValuePtr(v), sizeof(ox_default_options.inv_repl) - 1);
+	ox_default_options.inv_repl[sizeof(ox_default_options.inv_repl) - 1] = '\0';
+	*ox_default_options.inv_repl = (char)slen;
+	ox_default_options.allow_invalid = No;
+    }
+
+    v = rb_hash_aref(opts, strip_namespace_sym);
+    if (Qfalse == v) {
+	*ox_default_options.strip_ns = '\0';
+    } else if (Qtrue == v) {
+	*ox_default_options.strip_ns = '*';
+	ox_default_options.strip_ns[1] = '\0';
+    } else if (Qnil != v) {
+	long	slen;
+
+	Check_Type(v, T_STRING);
+	slen = RSTRING_LEN(v);
+	if (sizeof(ox_default_options.strip_ns) - 1 < slen) {
+	    rb_raise(ox_parse_error_class, ":strip_namespace can be no longer than %ld characters.",
+		     sizeof(ox_default_options.strip_ns) - 1);
+	}
+	strncpy(ox_default_options.strip_ns, StringValuePtr(v), sizeof(ox_default_options.strip_ns) - 1);
+	ox_default_options.strip_ns[sizeof(ox_default_options.strip_ns) - 1] = '\0';
+    }
+
     for (o = ynos; 0 != o->attr; o++) {
 	v = rb_hash_lookup(opts, o->sym);
 	if (Qnil == v) {
@@ -536,6 +597,44 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
 	if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
 	    options.convert_special = (Qfalse != v);
 	}
+
+	v = rb_hash_lookup(h, invalid_replace_sym);
+	if (Qnil == v) {
+	    if (Qtrue == rb_funcall(h, has_key_id, 1, invalid_replace_sym)) {
+		options.allow_invalid = Yes;
+	    }
+	} else {
+	    long	slen;
+
+	    Check_Type(v, T_STRING);
+	    slen = RSTRING_LEN(v);
+	    if (sizeof(options.inv_repl) - 2 < slen) {
+		rb_raise(ox_parse_error_class, ":invalid_replace can be no longer than %ld characters.",
+			 sizeof(options.inv_repl) - 2);
+	    }
+	    strncpy(options.inv_repl + 1, StringValuePtr(v), sizeof(options.inv_repl) - 1);
+	    options.inv_repl[sizeof(options.inv_repl) - 1] = '\0';
+	    *options.inv_repl = (char)slen;
+	    options.allow_invalid = No;
+	}
+	v = rb_hash_lookup(h, strip_namespace_sym);
+	if (Qfalse == v) {
+	    *options.strip_ns = '\0';
+	} else if (Qtrue == v) {
+	    *options.strip_ns = '*';
+	    options.strip_ns[1] = '\0';
+	} else if (Qnil != v) {
+	    long	slen;
+
+	    Check_Type(v, T_STRING);
+	    slen = RSTRING_LEN(v);
+	    if (sizeof(options.strip_ns) - 1 < slen) {
+		rb_raise(ox_parse_error_class, ":strip_namespace can be no longer than %ld characters.",
+			 sizeof(options.strip_ns) - 1);
+	    }
+	    strncpy(options.strip_ns, StringValuePtr(v), sizeof(options.strip_ns) - 1);
+	    options.strip_ns[sizeof(options.strip_ns) - 1] = '\0';
+	}
     }
 #if HAS_ENCODING_SUPPORT
     if ('\0' == *options.encoding) {
@@ -590,8 +689,11 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
 /* call-seq: load(xml, options) => Ox::Document or Ox::Element or Object
  *
  * Parses and XML document String into an Ox::Document, or Ox::Element, or
- * Object depending on the options.  Raises an exception if the XML is
- * malformed or the classes specified are not valid.
+ * Object depending on the options.  Raises an exception if the XML is malformed
+ * or the classes specified are not valid. If a block is given it will be called
+ * on the completion of each complete top level entity with that entity as it's
+ * only argument.
+ *
  * @param [String] xml XML String
  * @param [Hash] options load options
  * @param [:object|:generic|:limited] :mode format expected
@@ -604,6 +706,8 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
  *  - *:auto_define* - auto define missing classes and modules
  * @param [Fixnum] :trace trace level as a Fixnum, default: 0 (silent)
  * @param [true|false|nil] :symbolize_keys symbolize element attribute keys or leave as Strings
+ * @param [nil|String] :invalid_replace replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
+ * @param [String|true|false] :strip_namespace "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  */
 static VALUE
 load_str(int argc, VALUE *argv, VALUE self) {
@@ -624,12 +728,12 @@ load_str(int argc, VALUE *argv, VALUE self) {
     }
 #if HAS_ENCODING_SUPPORT
 #ifdef MACRUBY_RUBY
-    encoding = rb_funcall(*argv, rb_intern("encoding"), 0);
+    encoding = rb_funcall(*argv, encoding_id, 0);
 #else
     encoding = rb_obj_encoding(*argv);
 #endif
 #elif HAS_PRIVATE_ENCODING
-    encoding = rb_funcall(*argv, rb_intern("encoding"), 0);
+    encoding = rb_funcall(*argv, encoding_id, 0);
 #else
     encoding = Qnil;
 #endif
@@ -661,6 +765,8 @@ load_str(int argc, VALUE *argv, VALUE self) {
  *  - *:auto_define* - auto define missing classes and modules
  * @param [Fixnum] :trace trace level as a Fixnum, default: 0 (silent)
  * @param [true|false|nil] :symbolize_keys symbolize element attribute keys or leave as Strings
+ * @param [nil|String] :invalid_replace replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
+ * @param [String|true|false] :strip_namespace "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  */
 static VALUE
 load_file(int argc, VALUE *argv, VALUE self) {
@@ -713,6 +819,7 @@ load_file(int argc, VALUE *argv, VALUE self) {
  * @param [true|false] :symbolize flag indicating the parser symbolize element and attribute names
  * @param [true|false] :smart flag indicating the parser uses hints if available (use with html)
  * @param [:skip_return|:skip_white] :skip flag indicating the parser skips \r or collpase white space into a single space. Default (skip nothing)
+ * @param [nil|String|true|false] :strip_namespace "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
  */
 static VALUE
 sax_parse(int argc, VALUE *argv, VALUE self) {
@@ -722,7 +829,8 @@ sax_parse(int argc, VALUE *argv, VALUE self) {
     options.convert_special = ox_default_options.convert_special;
     options.smart = (Yes == ox_default_options.smart);
     options.skip = ox_default_options.skip;
-
+    strcpy(options.strip_ns, ox_default_options.strip_ns);
+    
     if (argc < 2) {
 	rb_raise(ox_parse_error_class, "Wrong number of arguments to sax_parse.\n");
     }
@@ -744,6 +852,27 @@ sax_parse(int argc, VALUE *argv, VALUE self) {
 		options.skip = CrSkip;
 	    } else if (skip_white_sym == v) {
 		options.skip = SpcSkip;
+	    } else if (skip_none_sym == v) {
+		options.skip = NoSkip;
+	    }
+	}
+	if (Qnil != (v = rb_hash_lookup(h, strip_namespace_sym))) {
+	    if (Qfalse == v) {
+		*options.strip_ns = '\0';
+	    } else if (Qtrue == v) {
+		*options.strip_ns = '*';
+		options.strip_ns[1] = '\0';
+	    } else {
+		long	slen;
+
+		Check_Type(v, T_STRING);
+		slen = RSTRING_LEN(v);
+		if (sizeof(options.strip_ns) - 1 < slen) {
+		    rb_raise(ox_parse_error_class, ":strip_namespace can be no longer than %ld characters.",
+			     sizeof(options.strip_ns) - 1);
+		}
+		strncpy(options.strip_ns, StringValuePtr(v), sizeof(options.strip_ns) - 1);
+		options.strip_ns[sizeof(options.strip_ns) - 1] = '\0';
 	    }
 	}
     }
@@ -796,6 +925,26 @@ parse_dump_options(VALUE ropts, Options copts) {
 		rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
 	    }
 	}
+	v = rb_hash_lookup(ropts, invalid_replace_sym);
+	if (Qnil == v) {
+	    if (Qtrue == rb_funcall(ropts, has_key_id, 1, invalid_replace_sym)) {
+		copts->allow_invalid = Yes;
+	    }
+	} else {
+	    long	slen;
+
+	    Check_Type(v, T_STRING);
+	    slen = RSTRING_LEN(v);
+	    if (sizeof(copts->inv_repl) - 2 < slen) {
+		rb_raise(ox_parse_error_class, ":invalid_replace can be no longer than %ld characters.",
+			 sizeof(copts->inv_repl) - 2);
+	    }
+	    strncpy(copts->inv_repl + 1, StringValuePtr(v), sizeof(copts->inv_repl) - 1);
+	    copts->inv_repl[sizeof(copts->inv_repl) - 1] = '\0';
+	    *copts->inv_repl = (char)slen;
+	    copts->allow_invalid = No;
+	}
+	
 	for (o = ynos; 0 != o->attr; o++) {
 	    if (Qnil != (v = rb_hash_lookup(ropts, o->sym))) {
 		VALUE	    c = rb_obj_class(v);
@@ -810,7 +959,7 @@ parse_dump_options(VALUE ropts, Options copts) {
 	    }
 	}
     }
- }
+}
 
 /* call-seq: dump(obj, options) => xml-string
  *
@@ -969,6 +1118,9 @@ void Init_ox() {
     ox_tv_usec_id = rb_intern("tv_usec");
     ox_value_id = rb_intern("value");
 
+    encoding_id = rb_intern("encoding");
+    has_key_id = rb_intern("has_key?");
+
     rb_require("ox/version");
     rb_require("ox/error");
     rb_require("ox/hasattrs");
@@ -997,6 +1149,7 @@ void Init_ox() {
     effort_sym = ID2SYM(rb_intern("effort"));			rb_gc_register_address(&effort_sym);
     generic_sym = ID2SYM(rb_intern("generic"));			rb_gc_register_address(&generic_sym);
     indent_sym = ID2SYM(rb_intern("indent"));			rb_gc_register_address(&indent_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);
     mode_sym = ID2SYM(rb_intern("mode"));			rb_gc_register_address(&mode_sym);
     object_sym = ID2SYM(rb_intern("object"));			rb_gc_register_address(&object_sym);
@@ -1006,6 +1159,7 @@ void Init_ox() {
     skip_none_sym = ID2SYM(rb_intern("skip_none"));		rb_gc_register_address(&skip_none_sym);
     skip_return_sym = ID2SYM(rb_intern("skip_return"));		rb_gc_register_address(&skip_return_sym);
     skip_sym = ID2SYM(rb_intern("skip"));			rb_gc_register_address(&skip_sym);
+    strip_namespace_sym = ID2SYM(rb_intern("strip_namespace"));	rb_gc_register_address(&strip_namespace_sym);
     skip_white_sym = ID2SYM(rb_intern("skip_white"));		rb_gc_register_address(&skip_white_sym);
     smart_sym = ID2SYM(rb_intern("smart"));			rb_gc_register_address(&smart_sym);
     strict_sym = ID2SYM(rb_intern("strict"));			rb_gc_register_address(&strict_sym);

data/ext/ox/ox.h

@@ -133,6 +133,9 @@ typedef struct _Options {
     char	skip;		/* skip mode */
     char	smart;		/* YesNo sax smart mode */
     char	convert_special;/* boolean true or false */
+    char	allow_invalid;	/* YesNo */
+    char	inv_repl[12];	/* max 10 valid characters, first character is the length */
+    char	strip_ns[64];	/* namespace to strip, \0 is no-strip, \* is all, else only matches */
 #if HAS_ENCODING_SUPPORT
     rb_encoding	*rb_enc;
 #elif HAS_PRIVATE_ENCODING

data/ext/ox/parse.c

@@ -43,6 +43,8 @@ static int	collapse_special(PInfo pi, char *str);
  * all cases to parse the string.
  */
 
+static char	xml_valid_lower_chars[34] = "xxxxxxxxxooxxoxxxxxxxxxxxxxxxxxxo";
+
 inline static int
 is_white(char c) {
     switch (c) {
@@ -95,6 +97,7 @@ 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();
 
     if (0 == xml) {
 	set_error(err, "Invalid arg, xml string can not be null", xml, 0);
@@ -171,6 +174,9 @@ ox_parse(char *xml, ParseCallbacks pcb, char **endp, Options options, Err err) {
 	    helper_stack_cleanup(&pi.helpers);
 	    return Qnil;
 	}
+	if (block_given && Qnil != pi.obj && Qundef != pi.obj) {
+	    rb_yield(pi.obj);
+	}
     }
     helper_stack_cleanup(&pi.helpers);
     return pi.obj;
@@ -211,7 +217,6 @@ read_instruction(PInfo pi) {
     char		*cend;
     int			attrs_ok = 1;
 
-
     *content = '\0';
     attr_stack_init(&attrs);
     if (0 == (target = read_name_token(pi))) {
@@ -567,9 +572,32 @@ read_element(PInfo pi) {
 			return 0;
 		    }
 		    if (first && start != slash - 1) {
-			/* some white space between start and here so add as text */
+			// Some white space between start and here so add as
+			// text after checking skip.
 			*(slash - 1) = '\0';
-			pi->pcb->add_text(pi, start, 1);
+			switch (pi->options->skip) {
+			case CrSkip: {
+			    char	*s = start;
+			    char	*e = start;
+			
+			    for (; '\0' != *e; e++) {
+				if ('\r' != *e) {
+				    *s++ = *e;
+				}
+			    }
+			    *s = '\0';
+			    break;
+			}
+			case SpcSkip:
+			    *start = '\0';
+			    break;
+			case NoSkip:
+			default:
+			    break;
+			}
+			if ('\0' != *start) {
+			    pi->pcb->add_text(pi, start, 1);
+			}
 		    }
 		    pi->s++;
 		    pi->pcb->end_element(pi, ename);
@@ -667,27 +695,35 @@ read_text(PInfo pi) {
 		    return;
 		}
 	    } else {
-		switch (pi->options->skip) {
-		case CrSkip:
-		    if (buf != b && '\n' == c && '\r' == *(b - 1)) {
-			*(b - 1) = '\n';
-		    } else {
-			*b++ = c;
+		if (0 <= c && c <= 0x20) {
+		    if (StrictEffort == pi->options->effort && 'x' == xml_valid_lower_chars[(unsigned char)c]) {
+			set_error(&pi->err, "invalid character", pi->str, pi->s);
+			return;
 		    }
-		    break;
-		case SpcSkip:
-		    if (is_white(c)) {
-			if (buf == b || ' ' != *(b - 1)) {
-			    *b++ = ' ';
+		    switch (pi->options->skip) {
+		    case CrSkip:
+			if (buf != b && '\n' == c && '\r' == *(b - 1)) {
+			    *(b - 1) = '\n';
+			} else {
+			    *b++ = c;
 			}
-		    } else {
+			break;
+		    case SpcSkip:
+			if (is_white(c)) {
+			    if (buf == b || ' ' != *(b - 1)) {
+				*b++ = ' ';
+			    }
+			} else {
+			    *b++ = c;
+			}			
+			break;
+		    case NoSkip:
+		    default:
 			*b++ = c;
-		    }			
-		    break;
-		case NoSkip:
-		default:
+			break;
+		    }
+		} else {
 		    *b++ = c;
-		    break;
 		}
 	    }
 	    break;
@@ -795,6 +831,15 @@ read_name_token(PInfo pi) {
 	    set_error(&pi->err, "invalid format, document not terminated", pi->str, pi->s);
 	    return 0;
 	    break; /* to avoid warnings */
+	case ':':
+	    if ('\0' == *pi->options->strip_ns) {
+		break;
+	    } else if ('*' == *pi->options->strip_ns && '\0' == pi->options->strip_ns[1]) {
+		start = pi->s + 1;
+	    } else if (0 == strncmp(pi->options->strip_ns, start, pi->s - start)) {
+		start = pi->s + 1;
+	    }
+	    break;
 	default:
 	    break;
 	}

data/ext/ox/sax.c

@@ -1401,6 +1401,15 @@ read_name_token(SaxDrive dr) {
             /* documents never terminate after a name token */
             ox_sax_drive_error(dr, NO_TERM "document not terminated");
             return '\0';
+	case ':':
+	    if ('\0' == *dr->options.strip_ns) {
+		break;
+	    } else if ('*' == *dr->options.strip_ns && '\0' == dr->options.strip_ns[1]) {
+		dr->buf.str = dr->buf.tail;
+	    } else if (0 == strncmp(dr->options.strip_ns, dr->buf.str, dr->buf.tail - dr->buf.str - 1)) {
+		dr->buf.str = dr->buf.tail;
+	    }
+	    break;
 	default:
 	    break;
 	}

data/ext/ox/sax.h

@@ -17,6 +17,7 @@ typedef struct _SaxOptions {
     int			convert_special;
     int			smart;
     SkipMode		skip;
+    char		strip_ns[64];
 } *SaxOptions;
 
 typedef struct _SaxDrive {

data/ext/ox/sax_buf.c

@@ -30,11 +30,14 @@ static int		read_from_str(Buf buf);
 
 void
 ox_sax_buf_init(Buf buf, VALUE io) {
-    VALUE	io_class = rb_obj_class(io);
-    VALUE	rfd;
+    volatile VALUE	io_class = rb_obj_class(io);
+    VALUE		rfd;
 
-    if (ox_stringio_class == io_class && 0 == FIX2INT(rb_funcall2(io, ox_pos_id, 0, 0))) {
-	VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
+    if (rb_cString == io_class) {
+	buf->read_func = read_from_str;
+	buf->in.str = StringValuePtr(io);
+    } else if (ox_stringio_class == io_class && 0 == FIX2INT(rb_funcall2(io, ox_pos_id, 0, 0))) {
+	volatile VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
 
 	buf->read_func = read_from_str;
 	buf->in.str = StringValuePtr(s);

data/lib/ox/element.rb

@@ -40,8 +40,8 @@ module Ox
     # @param [String] name name of the Element
     def initialize(name)
       super
-      @attributes = nil
-      @nodes = nil
+      @attributes = {}
+      @nodes = []
     end
     alias name value
     
@@ -49,7 +49,7 @@ module Ox
     # Element.
     # @return [Array] all child Nodes.
     def nodes
-      return [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
+      @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
       @nodes
     end
 
@@ -83,6 +83,15 @@ module Ox
       nil
     end
 
+    # Clears any child nodes of an element and replaces those with a single Text
+    # (String) node. Note the existing nodes array is modified and not replaced.
+    # @param [String] txt to become the only element of the nodes array
+    def replace_text(txt)
+      raise "the argument to replace_text() must be a String" unless txt.is_a?(String)
+      @nodes.clear()
+      @nodes << txt
+    end
+
     # Returns an array of Nodes or Strings that correspond to the locations
     # specified by the path parameter. The path parameter describes the path
     # to the return values which can be either nodes in the XML or

data/lib/ox/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 2.3.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-04 00:00:00.000000000 Z
+date: 2016-02-21 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