ox 2.4.0 → 2.4.1

data/README.md

@@ -34,6 +34,18 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## Release Notes
 
+### Release 2.4.1
+
+ - Made SAX smarter a little smarter or rather let it handle unquoted string
+   with a / at the end.
+
+ - Fixed bug with reporting errors of element names that are too long.
+
+ - Added overlay feature to give control over which elements generate callbacks
+   with the SAX parser.
+
+ - Element.locate now includes self if the path is relative and starts with a wildcard.
+
 ### Release 2.4.0
 
  - Added Ox::Builder that constructs an XML string or writes XML to a stream
@@ -154,6 +166,19 @@ puts "Same? #{doc == doc2}"
 # true
 ```
 
+### HTML Parsing:
+
+Ox can be used to parse HTML with a few options changes. HTML is often loose in
+regard to conformance. For HTML parsing try these options.
+
+```ruby
+Ox.default_options = {
+    mode:   :generic,
+    effort: :tolerant,
+    smart:  true
+}
+```
+
 ### SAX XML Parsing:
 
 ```ruby

data/ext/ox/dump.c

@@ -533,19 +533,19 @@ dump_first_obj(VALUE obj, Out out) {
 	if ('\0' == *copts->encoding) {
 	    dump_value(out, "<?xml version=\"1.0\"?>", 21);
 	} else {
-	    cnt = sprintf(buf, "<?xml version=\"1.0\" encoding=\"%s\"?>", copts->encoding);
+	    cnt = snprintf(buf, sizeof(buf), "<?xml version=\"1.0\" encoding=\"%s\"?>", copts->encoding);
 	    dump_value(out, buf, cnt);
 	}
     }
     if (Yes == copts->with_instruct) {
-	cnt = sprintf(buf, "%s<?ox version=\"1.0\" mode=\"object\"%s%s?>",
+	cnt = snprintf(buf, sizeof(buf), "%s<?ox version=\"1.0\" mode=\"object\"%s%s?>",
 		      (out->buf < out->cur) ? "\n" : "",
 		      (Yes == copts->circular) ? " circular=\"yes\"" : ((No == copts->circular) ? " circular=\"no\"" : ""),
 		      (Yes == copts->xsd_date) ? " xsd_date=\"yes\"" : ((No == copts->xsd_date) ? " xsd_date=\"no\"" : ""));
 	dump_value(out, buf, cnt);
     }
     if (Yes == copts->with_dtd) {
-	cnt = sprintf(buf, "%s<!DOCTYPE %c SYSTEM \"ox.dtd\">", (out->buf < out->cur) ? "\n" : "", obj_class_code(obj));
+	cnt = snprintf(buf, sizeof(buf), "%s<!DOCTYPE %c SYSTEM \"ox.dtd\">", (out->buf < out->cur) ? "\n" : "", obj_class_code(obj));
 	dump_value(out, buf, cnt);
     }
     dump_obj(0, obj, 0, out);
@@ -648,7 +648,7 @@ dump_obj(ID aid, VALUE obj, int depth, Out out) {
 	break;
     case T_FLOAT:
 	e.type = FloatCode;
-	cnt = sprintf(value_buf, "%0.16g", rb_num2dbl(obj)); /* used sprintf due to bug in snprintf */
+	cnt = snprintf(value_buf, sizeof(value_buf), "%0.16g", rb_num2dbl(obj));
 	out->w_start(out, &e);
 	dump_value(out, value_buf, cnt);
 	e.indent = -1;

data/ext/ox/ox.c

@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <stdint.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -26,6 +27,7 @@ void Init_ox();
 
 VALUE	 Ox = Qnil;
 
+ID	ox_abort_id;
 ID	ox_at_column_id;
 ID	ox_at_content_id;
 ID	ox_at_id;
@@ -104,18 +106,24 @@ Cache	ox_symbol_cache = 0;
 Cache	ox_class_cache = 0;
 Cache	ox_attr_cache = 0;
 
+static VALUE	abort_sym;
+static VALUE	active_sym;
 static VALUE	auto_define_sym;
 static VALUE	auto_sym;
+static VALUE	block_sym;
 static VALUE	circular_sym;
 static VALUE	convert_special_sym;
 static VALUE	effort_sym;
 static VALUE	generic_sym;
+static VALUE	inactive_sym;
 static VALUE	invalid_replace_sym;
 static VALUE	limited_sym;
 static VALUE	mode_sym;
 static VALUE	object_sym;
+static VALUE	off_sym;
 static VALUE	opt_format_sym;
 static VALUE	optimized_sym;
+static VALUE	overlay_sym;
 static VALUE	skip_none_sym;
 static VALUE	skip_return_sym;
 static VALUE	skip_sym;
@@ -161,6 +169,7 @@ struct _Options	 ox_default_options = {
     No,			/* allow_invalid */
     { '\0' },		/* inv_repl */
     { '\0' },		/* strip_ns */
+    NULL,		/* html_hints */
 #if HAS_PRIVATE_ENCODING
     Qnil		/* rb_enc */
 #else
@@ -224,7 +233,28 @@ defuse_bom(char *xml, Options options) {
     return xml;
 }
 
-/* call-seq: ox_default_options() => Hash
+static VALUE
+hints_to_overlay(Hints hints) {
+    volatile VALUE	overlay = rb_hash_new();
+    Hint		h;
+    int			i;
+    VALUE		ov;
+    
+    for (i = hints->size, h = hints->hints; 0 < i; i--, h++) {
+	switch (h->overlay) {
+	case InactiveOverlay:	ov = inactive_sym;	break;
+	case BlockOverlay:	ov = block_sym;		break;
+	case OffOverlay:	ov = off_sym;		break;
+	case AbortOverlay:	ov = abort_sym;		break;
+	case ActiveOverlay:
+	default:		ov = active_sym;	break;
+	}
+	rb_hash_aset(overlay, rb_str_new2(h->name), ov);
+    }    
+    return overlay;
+}
+
+/* call-seq: default_options() => Hash
  *
  * Returns the default load and dump options as a Hash. The options are
  * - _:indent_ [Fixnum] number of spaces to indent each element in an XML document
@@ -243,6 +273,13 @@ defuse_bom(char *xml, Options options) {
  * - _:convert_special_ [true|false|nil] flag indicating special characters like &lt; 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.
+ * - _:overlay_ [Hash] a Hash of keys that match html element names and values that are one of
+ *   - _:active_ - make the normal callback for the element
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ * 
  * *return* [Hash] all current option settings.
  *
  * Note that an indent of less than zero will result in a tight one line output
@@ -296,10 +333,54 @@ get_def_opts(VALUE self) {
     } else {
 	rb_hash_aset(opts, strip_namespace_sym, rb_str_new(ox_default_options.strip_ns, strlen(ox_default_options.strip_ns)));
     }
+    if (NULL == ox_default_options.html_hints) {
+	//rb_hash_aset(opts, overlay_sym, hints_to_overlay(ox_hints_html()));
+	rb_hash_aset(opts, overlay_sym, Qnil);
+    } else {
+	rb_hash_aset(opts, overlay_sym, hints_to_overlay(ox_default_options.html_hints));
+    }
     return opts;
 }
 
-/* call-seq: ox_default_options=(opts)
+static int
+set_overlay(VALUE key, VALUE value, VALUE ctx) {
+    Hints	hints = (Hints)ctx;
+    Hint	hint;
+    
+    if (NULL != (hint = ox_hint_find(hints, StringValuePtr(key)))) {
+	if (active_sym == value) {
+	    hint->overlay = ActiveOverlay;
+	} else if (inactive_sym == value) {
+	    hint->overlay = InactiveOverlay;
+	} else if (block_sym == value) {
+	    hint->overlay = BlockOverlay;
+	} else if (off_sym == value) {
+	    hint->overlay = OffOverlay;
+	} else if (abort_sym == value) {
+	    hint->overlay = AbortOverlay;
+	}
+    }
+    return ST_CONTINUE;
+}
+
+/* call-seq: sax_html_overlay() => Hash
+ *
+ * Returns an overlay hash that can be modified and used as an overlay in the
+ * default options or in the sax_html() function call. Values for the keys are:
+ *   - _:active_ - make the normal callback for the element
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ *
+ * *return* [Hash] default SAX HTML settings
+ */
+static VALUE
+sax_html_overlay(VALUE self) {
+    return hints_to_overlay(ox_hints_html());
+}
+
+/* call-seq: default_options=(opts)
  *
  * Sets the default options for load and dump.
  * - +opts+ [Hash] opts options to change
@@ -314,9 +395,17 @@ get_def_opts(VALUE self) {
  *   - _:mode_ [:object|:generic|:limited|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
+ *   - _: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)
  *   - _: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_ [nil|String|true|false] "" 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.
+ * - _:overlay_ [Hash] a Hash of keys that match html element names and values that are one of
+ *   - _:active_ - make the normal callback for the element
+ *   - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *   - _:block_ - block this and all children callbacks
+ *   - _:off_ - block this element and it's children unless the child element is active
+ *   - _:abort_ - abort the html processing and return
+ *
  * *return* [nil]
  */
 static VALUE
@@ -461,6 +550,24 @@ set_def_opts(VALUE self, VALUE opts) {
 	    rb_raise(ox_parse_error_class, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
 	}
     }
+    v = rb_hash_aref(opts, overlay_sym);
+    if (Qnil == v) {
+	ox_hints_destroy(ox_default_options.html_hints);
+	ox_default_options.html_hints = NULL;
+    } else {
+	int	cnt;
+
+	Check_Type(v, T_HASH);
+	cnt = (int)RHASH_SIZE(v);
+	if (0 == cnt) {
+	    ox_hints_destroy(ox_default_options.html_hints);
+	    ox_default_options.html_hints = NULL;
+	} else {
+	    ox_hints_destroy(ox_default_options.html_hints);
+	    ox_default_options.html_hints = ox_hints_dup(ox_hints_html());
+	    rb_hash_foreach(v, set_overlay, (VALUE)ox_default_options.html_hints);
+	}
+    }
     return Qnil;
 }
 
@@ -834,6 +941,7 @@ 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;
+    options.hints = NULL;
     strcpy(options.strip_ns, ox_default_options.strip_ns);
     
     if (argc < 2) {
@@ -886,6 +994,81 @@ sax_parse(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
+/* call-seq: sax_html(handler, io, options)
+ *
+ * Parses an IO stream or file containing an XML document. Raises an exception
+ * if the XML is malformed or the classes specified are not valid.
+ * - +handler+ [Ox::Sax] SAX (responds to OX::Sax methods) like handler
+ * - +io+ [IO|String] IO Object to read from
+ * - +options+ [Hash] options parse options
+ *   - *:convert_special* [true|false] flag indicating special characters like &lt; are converted
+ *   - *:symbolize* [true|false] flag indicating the parser symbolize element and attribute names
+ *   - *:skip* [:skip_return|:skip_white] flag indicating the parser skips \r or collapse white space into a single space. Default (skip nothing)
+ *   - *:overlay* [Hash] a Hash of keys that match html element names and values that are one of
+ *     - _:active_ - make the normal callback for the element
+ *     - _:inactive_ - do not make the element start, end, or attribute callbacks for this element only
+ *     - _:block_ - block this and all children callbacks
+ *     - _:off_ - block this element and it's children unless the child element is active
+ *     - _:abort_ - abort the html processing and return
+ */
+static VALUE
+sax_html(int argc, VALUE *argv, VALUE self) {
+    struct _SaxOptions	options;
+    bool		free_hints = false;
+    
+    options.symbolize = (No != ox_default_options.sym_keys);
+    options.convert_special = ox_default_options.convert_special;
+    options.smart = true;
+    options.skip = ox_default_options.skip;
+    options.hints = ox_default_options.html_hints;
+    if (NULL == options.hints) {
+	options.hints = ox_hints_html();
+    }
+    *options.strip_ns = '\0';
+    
+    if (argc < 2) {
+	rb_raise(ox_parse_error_class, "Wrong number of arguments to sax_html.\n");
+    }
+    if (3 <= argc && rb_cHash == rb_obj_class(argv[2])) {
+	volatile VALUE	h = argv[2];
+	volatile VALUE	v;
+	
+	if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
+	    options.convert_special = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(h, symbolize_sym))) {
+	    options.symbolize = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(h, skip_sym))) {
+	    if (skip_return_sym == v) {
+		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, overlay_sym))) {
+	    int	cnt;
+	    
+	    Check_Type(v, T_HASH);
+	    cnt = (int)RHASH_SIZE(v);
+	    if (0 == cnt) {
+		options.hints = ox_hints_html();
+	    } else {
+		options.hints = ox_hints_dup(options.hints);
+		free_hints = true;
+		rb_hash_foreach(v, set_overlay, (VALUE)options.hints);
+	    }
+	}
+    }
+    ox_sax_parse(argv[0], argv[1], &options);
+    if (free_hints) {
+	ox_hints_destroy(options.hints);
+    }
+    return Qnil;
+}
+
 static void
 parse_dump_options(VALUE ropts, Options copts) {
     struct _YesNoOpt	ynos[] = {
@@ -1065,6 +1248,7 @@ void Init_ox() {
     rb_define_module_function(Ox, "parse", to_gen, 1);
     rb_define_module_function(Ox, "load", load_str, -1);
     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, "dump", dump, -1);
@@ -1072,6 +1256,8 @@ void Init_ox() {
     rb_define_module_function(Ox, "load_file", load_file, -1);
     rb_define_module_function(Ox, "to_file", to_file, -1);
 
+    rb_define_module_function(Ox, "sax_html_overlay", sax_html_overlay, 0);
+    
     ox_init_builder(Ox);
     
     rb_require("time");
@@ -1079,6 +1265,7 @@ void Init_ox() {
     rb_require("bigdecimal");
     rb_require("stringio");
 
+    ox_abort_id = rb_intern("abort");
     ox_at_column_id = rb_intern("@column");
     ox_at_content_id = rb_intern("@content");
     ox_at_id = rb_intern("at");
@@ -1151,30 +1338,36 @@ void Init_ox() {
     ox_stringio_class = rb_const_get(rb_cObject, rb_intern("StringIO"));
     ox_bigdecimal_class = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 
+    abort_sym = ID2SYM(rb_intern("abort"));			rb_gc_register_address(&abort_sym);
+    active_sym = ID2SYM(rb_intern("active"));			rb_gc_register_address(&active_sym);
     auto_define_sym = ID2SYM(rb_intern("auto_define"));		rb_gc_register_address(&auto_define_sym);
     auto_sym = ID2SYM(rb_intern("auto"));			rb_gc_register_address(&auto_sym);
+    block_sym = ID2SYM(rb_intern("block"));			rb_gc_register_address(&block_sym);
     circular_sym = ID2SYM(rb_intern("circular"));		rb_gc_register_address(&circular_sym);
     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);
-    ox_indent_sym = ID2SYM(rb_intern("indent"));		rb_gc_register_address(&ox_indent_sym);
-    ox_size_sym = ID2SYM(rb_intern("size"));			rb_gc_register_address(&ox_size_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);
     mode_sym = ID2SYM(rb_intern("mode"));			rb_gc_register_address(&mode_sym);
     object_sym = ID2SYM(rb_intern("object"));			rb_gc_register_address(&object_sym);
+    off_sym = ID2SYM(rb_intern("off"));				rb_gc_register_address(&off_sym);
     opt_format_sym = ID2SYM(rb_intern("opt_format"));		rb_gc_register_address(&opt_format_sym);
     optimized_sym = ID2SYM(rb_intern("optimized"));		rb_gc_register_address(&optimized_sym);
+    overlay_sym = ID2SYM(rb_intern("overlay"));			rb_gc_register_address(&overlay_sym);
     ox_encoding_sym = ID2SYM(rb_intern("encoding"));		rb_gc_register_address(&ox_encoding_sym);
-    ox_version_sym = ID2SYM(rb_intern("version"));		rb_gc_register_address(&ox_version_sym);
+    ox_indent_sym = ID2SYM(rb_intern("indent"));		rb_gc_register_address(&ox_indent_sym);
+    ox_size_sym = ID2SYM(rb_intern("size"));			rb_gc_register_address(&ox_size_sym);
     ox_standalone_sym = ID2SYM(rb_intern("standalone"));	rb_gc_register_address(&ox_standalone_sym);
+    ox_version_sym = ID2SYM(rb_intern("version"));		rb_gc_register_address(&ox_version_sym);
     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);
+    strip_namespace_sym = ID2SYM(rb_intern("strip_namespace"));	rb_gc_register_address(&strip_namespace_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);

data/ext/ox/ox.h

@@ -119,29 +119,30 @@ typedef struct _CircArray {
 } *CircArray;
 
 typedef struct _Options {
-    char	encoding[64];	/* encoding, stored in the option to avoid GC invalidation in default values */
-    int		indent;		/* indention for dump, default 2 */
-    int		trace;		/* trace level */
-    char	with_dtd;	/* YesNo */
-    char	with_xml;	/* YesNo */
-    char	with_instruct;	/* YesNo */
-    char	circular;	/* YesNo */
-    char	xsd_date;	/* YesNo */
-    char	mode;		/* LoadMode */
-    char	effort;		/* Effort */
-    char	sym_keys;	/* symbolize keys */
-    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 */
+    char		encoding[64];	/* encoding, stored in the option to avoid GC invalidation in default values */
+    int			indent;		/* indention for dump, default 2 */
+    int			trace;		/* trace level */
+    char		with_dtd;	/* YesNo */
+    char		with_xml;	/* YesNo */
+    char		with_instruct;	/* YesNo */
+    char		circular;	/* YesNo */
+    char		xsd_date;	/* YesNo */
+    char		mode;		/* LoadMode */
+    char		effort;		/* Effort */
+    char		sym_keys;	/* symbolize keys */
+    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 */
+    struct _Hints	*html_hints;	/* html hints */
 #if HAS_ENCODING_SUPPORT
-    rb_encoding	*rb_enc;
+    rb_encoding		*rb_enc;
 #elif HAS_PRIVATE_ENCODING
-    VALUE	rb_enc;
+    VALUE		rb_enc;
 #else
-    void	*rb_enc;
+    void		*rb_enc;
 #endif
 } *Options;
 
@@ -171,6 +172,7 @@ extern struct _Options	ox_default_options;
 
 extern VALUE	Ox;
 
+extern ID	ox_abort_id;
 extern ID	ox_at_column_id;
 extern ID	ox_at_content_id;
 extern ID	ox_at_id;