ox 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dfc6cdcfabac2cccd4fee65e58d77bd341d0dad
-  data.tar.gz: 6550189e77b12edc3fa82dc70484f629c0d33961
+  metadata.gz: 6e77323356f912ddf4b3db190f9b8224a084a361
+  data.tar.gz: 6f8d0822eb29ca69f431f3a5cc40b13634bf44a4
 SHA512:
-  metadata.gz: 3ea6d87ceb49d76762801b680f4b75f5715ed5fe1ad3c65aa39023cc4e64ac05b5928ed0c06770ddc32b754d797032979fc5df8ddeca2f6274d77f5d79a04ce2
-  data.tar.gz: ff66b7c9f54457f89b5287dfe78fa2cfdf4d1c12bff7c67f3932e30323f6066f3bc98d1a2ce15338186e24258a4eb981b6b8d1a14fffbaedb10d467378f9e7a6
+  metadata.gz: d242bc1b433db4811d0ef565dca6b3429f48589f73f60e1285566824d7d0c916339112b3bcf1fb079515069e3cdd4cd03b27e9aa86572e2a243808dfa43ad78a
+  data.tar.gz: d3040cd0a7146bad8bead518413dc15e1fd863ce4cf697cd1326758134bf0babae038e9a5daaf36388f8f99aab0e36e23f30fd487e1511f2257f8a97b1ae944e

data/README.md

@@ -24,7 +24,7 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## Links of Interest
 
-[Ruby XML Gem Comparison](http://www.ohler.com/dev/xml_with_ruby/xml_with_ruby.html) for a perfomance comparison between Ox, Nokogiri, and LibXML.
+[Ruby XML Gem Comparison](http://www.ohler.com/dev/xml_with_ruby/xml_with_ruby.html) for a performance comparison between Ox, Nokogiri, and LibXML.
 
 [Fast Ruby XML Serialization](http://www.ohler.com/dev/ruby_object_xml_serialization/ruby_object_xml_serialization.html) to see how Ox can be used as a faster replacement for Marshal.
 
@@ -34,6 +34,13 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## Release Notes
 
+### Release 2.1.2
+
+ - Added skip option to parsing. This allows white space to be collapsed in two
+   different ways.
+
+ - Added respond_to? method for easy access method checking. 
+
 ### Release 2.1.1
 
  - Worked around a module reset and clear that occurs on some Rubies.

data/ext/ox/ox.c

@@ -132,8 +132,12 @@ static VALUE	mode_sym;
 static VALUE	object_sym;
 static VALUE	opt_format_sym;
 static VALUE	optimized_sym;
-static VALUE	strict_sym;
+static VALUE	skip_none_sym;
+static VALUE	skip_return_sym;
+static VALUE	skip_sym;
+static VALUE	skip_white_sym;
 static VALUE	smart_sym;
+static VALUE	strict_sym;
 static VALUE	symbolize_keys_sym;
 static VALUE	symbolize_sym;
 static VALUE	tolerant_sym;
@@ -163,6 +167,7 @@ struct _Options	 ox_default_options = {
     NoMode,		/* mode */
     StrictEffort,	/* effort */
     Yes,		/* sym_keys */
+    NoSkip,		/* skip */
 #if HAS_PRIVATE_ENCODING
     Qnil		/* rb_enc */
 #else
@@ -240,6 +245,7 @@ defuse_bom(char *xml, Options options) {
  * - 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
  * @return [Hash] all current option settings.
  *
  * Note that an indent of less than zero will result in a tight one line output
@@ -273,6 +279,12 @@ get_def_opts(VALUE self) {
     case NoEffort:
     default:			rb_hash_aset(opts, effort_sym, Qnil);			break;
     }
+    switch (ox_default_options.skip) {
+    case NoSkip:		rb_hash_aset(opts, skip_sym, skip_none_sym);		break;
+    case CrSkip:		rb_hash_aset(opts, skip_sym, skip_return_sym);		break;
+    case SpcSkip:		rb_hash_aset(opts, skip_sym, skip_white_sym);		break;
+    default:			rb_hash_aset(opts, skip_sym, Qnil);			break;
+    }
     return opts;
 }
 
@@ -291,6 +303,7 @@ get_def_opts(VALUE self) {
  * @param [:object|:generic|:limited|nil] :mode load method to use for XML
  * @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
  * @return [nil]
  */
 static VALUE
@@ -360,6 +373,20 @@ set_def_opts(VALUE self, VALUE opts) {
     } else {
 	rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, :auto_define, or nil.\n");
     }
+
+    v = rb_hash_aref(opts, skip_sym);
+    if (Qnil == v) {
+	ox_default_options.skip = NoSkip;
+    } else if (skip_none_sym == v) {
+	ox_default_options.skip = NoSkip;
+    } else if (skip_return_sym == v) {
+	ox_default_options.skip = CrSkip;
+    } else if (skip_white_sym == v) {
+	ox_default_options.skip = SpcSkip;
+    } else {
+	rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, or nil.\n");
+    }
+
     for (o = ynos; 0 != o->attr; o++) {
 	v = rb_hash_lookup(opts, o->sym);
 	if (Qnil == v) {
@@ -490,6 +517,18 @@ load(char *xml, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
 		rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
 	    }
 	}
+	if (Qnil != (v = rb_hash_lookup(h, skip_sym))) {
+	    if (skip_none_sym == v) {
+		options.skip = NoSkip;
+	    } else if (skip_return_sym == v) {
+		options.skip = CrSkip;
+	    } else if (skip_white_sym == v) {
+		options.skip = SpcSkip;
+	    } else {
+		rb_raise(ox_parse_error_class, ":effort must be :skip_none, :skip_return, or :skip_white.\n");
+	    }
+	}
+
 	if (Qnil != (v = rb_hash_lookup(h, trace_sym))) {
 	    Check_Type(v, T_FIXNUM);
 	    options.trace = FIX2INT(v);
@@ -672,7 +711,8 @@ load_file(int argc, VALUE *argv, VALUE self) {
  * @param [Hash] options parse options
  * @param [true|false] :convert_special flag indicating special characters like < are converted
  * @param [true|false] :symbolize flag indicating the parser symbolize element and attribute names
- * @param [true|false] :smart flag indicating the parser use hints if available (use with html)
+ * @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)
  */
 static VALUE
 sax_parse(int argc, VALUE *argv, VALUE self) {
@@ -681,6 +721,7 @@ sax_parse(int argc, VALUE *argv, VALUE self) {
     options.symbolize = 1;
     options.convert_special = 0;
     options.smart = 0;
+    options.skip = NoSkip;
 
     if (argc < 2) {
 	rb_raise(ox_parse_error_class, "Wrong number of arguments to sax_parse.\n");
@@ -698,6 +739,13 @@ sax_parse(int argc, VALUE *argv, VALUE self) {
 	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;
+	    }
+	}
     }
     ox_sax_parse(argv[0], argv[1], &options);
 
@@ -953,6 +1001,10 @@ void Init_ox() {
     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);
     ox_encoding_sym = ID2SYM(rb_intern("encoding"));		rb_gc_register_address(&ox_encoding_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);
+    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);
     symbolize_keys_sym = ID2SYM(rb_intern("symbolize_keys"));	rb_gc_register_address(&symbolize_keys_sym);

data/ext/ox/ox.h

@@ -118,6 +118,12 @@ typedef enum {
     NoMode   = 0
 } LoadMode;
 
+typedef enum {
+    NoSkip   = 'n',
+    CrSkip   = 'r',
+    SpcSkip  = 's',
+} SkipMode;
+
 typedef struct _PInfo	*PInfo;
 
 typedef struct _ParseCallbacks {
@@ -149,6 +155,7 @@ typedef struct _Options {
     char	mode;		/* LoadMode */
     char	effort;		/* Effort */
     char	sym_keys;	/* symbolize keys */
+    char	skip;		/* skip mode */
 #if HAS_ENCODING_SUPPORT
     rb_encoding	*rb_enc;
 #elif HAS_PRIVATE_ENCODING

data/ext/ox/parse.c

@@ -68,6 +68,21 @@ static int	collapse_special(PInfo pi, char *str);
  * all cases to parse the string.
  */
 
+inline static int
+is_white(char c) {
+    switch (c) {
+    case ' ':
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r':
+	return 1;
+    default:
+	return 0;
+    }
+}
+
+
 inline static void
 next_non_white(PInfo pi) {
     for (; 1; pi->s++) {
@@ -678,7 +693,28 @@ read_text(PInfo pi) {
 		    return;
 		}
 	    } else {
-		*b++ = c;
+		switch (pi->options->skip) {
+		case CrSkip:
+		    if (buf != b && '\n' == c && '\r' == *(b - 1)) {
+			*(b - 1) = '\n';
+		    } else {
+			*b++ = c;
+		    }
+		    break;
+		case SpcSkip:
+		    if (is_white(c)) {
+			if (buf == b || ' ' != *(b - 1)) {
+			    *b++ = ' ';
+			}
+		    } else {
+			*b++ = c;
+		    }			
+		    break;
+		case NoSkip:
+		default:
+		    *b++ = c;
+		    break;
+		}
 	    }
 	    break;
 	}

data/ext/ox/sax.c

@@ -907,6 +907,7 @@ read_element_end(SaxDrive dr) {
 
 static char
 read_text(SaxDrive dr) {
+    VALUE	args[1];
     char        c;
     int		line = dr->buf.line;
     int		col = dr->buf.col - 1;
@@ -923,8 +924,6 @@ read_text(SaxDrive dr) {
 	*(dr->buf.tail - 1) = '\0';
     }
     if (dr->has.value) {
-        VALUE   args[1];
-
 	if (dr->has.line) {
 	    rb_ivar_set(dr->handler, ox_at_line_id, LONG2NUM(line));
 	}
@@ -934,11 +933,19 @@ read_text(SaxDrive dr) {
 	*args = dr->value_obj;
         rb_funcall2(dr->handler, ox_value_id, 1, args);
     } else if (dr->has.text) {
-        VALUE   args[1];
-
         if (dr->options.convert_special) {
             ox_sax_collapse_special(dr, dr->buf.str, line, col);
         }
+	switch (dr->options.skip) {
+	case CrSkip:
+	    buf_collapse_return(dr->buf.str);
+	    break;
+	case SpcSkip:
+	    buf_collapse_white(dr->buf.str);
+	    break;
+	default:
+	    break;
+	}
         args[0] = rb_str_new2(dr->buf.str);
 #if HAS_ENCODING_SUPPORT
         if (0 != dr->encoding) {

data/ext/ox/sax.h

@@ -35,11 +35,13 @@
 #include "sax_has.h"
 #include "sax_stack.h"
 #include "sax_hint.h"
+#include "ox.h"
 
 typedef struct _SaxOptions {
     int			symbolize;
     int			convert_special;
     int			smart;
+    SkipMode		skip;
 } *SaxOptions;
 
 typedef struct _SaxDrive {
@@ -60,6 +62,7 @@ typedef struct _SaxDrive {
 #endif
 } *SaxDrive;
 
+extern void	ox_collapse_return(char *str);
 extern void	ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);
 extern void	ox_sax_drive_cleanup(SaxDrive dr);
 extern void	ox_sax_drive_error(SaxDrive dr, const char *msg);

data/ext/ox/sax_as.c

@@ -146,6 +146,16 @@ sax_value_as_s(VALUE self) {
     if (dr->options.convert_special) {
 	ox_sax_collapse_special(dr, dr->buf.str, dr->buf.line, dr->buf.col);
     }
+    switch (dr->options.skip) {
+    case CrSkip:
+	buf_collapse_return(dr->buf.str);
+	break;
+    case SpcSkip:
+	buf_collapse_white(dr->buf.str);
+	break;
+    default:
+	break;
+    }
     rs = rb_str_new2(dr->buf.str);
 #if HAS_ENCODING_SUPPORT
     if (0 != dr->encoding) {

data/ext/ox/sax_buf.h

@@ -1,4 +1,4 @@
-/* sax_stack.h
+/* sax_buf.h
  * Copyright (c) 2011, Peter Ohler
  * All rights reserved.
  * 
@@ -195,4 +195,43 @@ buf_checkback(Buf buf, CheckPt cp) {
     return cp->c;
 }
 
+static inline void
+buf_collapse_return(char *str) {
+    char	*s = str;
+    char	*back = str;
+
+    for (; '\0' != *s; s++) {
+	if (back != str && '\n' == *s && '\r' == *(back - 1)) {
+	    *(back - 1) = '\n';
+	} else {
+	    *back++ = *s;
+	}
+    }
+    *back = '\0';
+}
+
+static inline void
+buf_collapse_white(char *str) {
+    char	*s = str;
+    char	*back = str;
+
+    for (; '\0' != *s; s++) {
+	switch(*s) {
+	case ' ':
+	case '\t':
+	case '\f':
+	case '\n':
+	case '\r':
+	    if (back == str || ' ' != *(back - 1)) {
+		*back++ = ' ';
+	    }
+	    break;
+	default:
+	    *back++ = *s;
+	    break;
+	}
+    }
+    *back = '\0';
+}
+
 #endif /* __OX_SAX_BUF_H__ */

data/lib/ox/element.rb

@@ -133,11 +133,13 @@ module Ox
     # @return [Element|Node|String|nil] the element, attribute value, or Node identifed by the name
     # @raise [NoMethodError] if no match is found
     def method_missing(id, *args, &block)
+      has_some = false
       ids = id.to_s
       i = args[0].to_i # will be 0 if no arg or parsing fails
       nodes.each do |n|
         if (n.is_a?(Element) || n.is_a?(Instruct)) && (n.value == id || n.value == ids)
           return n if 0 == i
+          has_some = true
           i -= 1
         end
       end
@@ -145,9 +147,27 @@ module Ox
         return @attributes[id] if @attributes.has_key?(id)
         return @attributes[ids] if @attributes.has_key?(ids)
       end
+      return nil if has_some
       raise NoMethodError.new("#{ids} not found", name)
     end
 
+    # @param [String|Symbol] id identifer of the attribute or method
+    # @param inc_all [Boolean] ignored
+    # @return true if the element has a member that matches the provided name.
+    def respond_to?(id, inc_all=false)
+      return true if super
+      id_str = id.to_s
+      id_sym = id.to_sym
+      nodes.each do |n|
+        return true if n.value == id_str || n.value == id_sym
+      end
+      if instance_variable_defined?(:@attributes)
+        return true if @attributes.has_key?(id_str)
+        return true if @attributes.has_key?(id_sym)
+      end
+      false
+    end
+
     # @param [Array] path array of steps in a path
     # @param [Array] found matching nodes
     def alocate(path, found)

data/lib/ox/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-12 00:00:00.000000000 Z
+date: 2014-07-17 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
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ox
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A fast XML parser and object serializer.