ox 1.0.3 → 1.1.0

data/README.rdoc

@@ -18,7 +18,8 @@ changes with releases making Marshal dumped Object incompatible between some
 versions. The use of a binary format make debugging message streams or file
 contents next to impossible unless the same version of Ruby and only Ruby is
 used for inspecting the serialize Object. Ox on the other hand uses human
-readable XML.
+readable XML. Ox also includes options that allow strict, tolerant, or a mode
+that automatically defines missing classes.
 
 It is possible to write an XML serialization gem with Nokogiri but writing
 such a package in Ruby results in a module significantly slower than

data/ext/ox/obj_load.c

@@ -51,8 +51,9 @@ static VALUE    parse_double_time(const char *text, VALUE clas);
 static VALUE    parse_regexp(const char *text);
 
 static VALUE            get_var_sym_from_attrs(Attr a);
-static VALUE            get_obj_from_attrs(Attr a, int best_effort);
-static VALUE            get_class_from_attrs(Attr a, int best_effort);
+static VALUE            get_obj_from_attrs(Attr a, PInfo pi);
+static VALUE            get_class_from_attrs(Attr a, PInfo pi);
+static VALUE            classname2class(const char *name, PInfo pi);
 static unsigned long    get_id_from_attrs(PInfo pi, Attr a);
 static CircArray        circ_array_new(void);
 static void             circ_array_free(CircArray ca);
@@ -93,48 +94,37 @@ name2var(const char *name) {
 }
 
 inline static VALUE
-classname2class(const char *name, int best_effort) {
-    VALUE       *slot;
+resolve_classname(VALUE mod, const char *class_name, Effort effort) {
     VALUE       clas;
-            
-    if (Qundef == (clas = ox_cache_get(class_cache, name, &slot))) {
-        char            class_name[1024];
-        char            *s;
-        const char      *n = name;
-        ID              ci;
+    ID          ci = rb_intern(class_name);
 
-        clas = rb_cObject;
-        for (s = class_name; '\0' != *n; n++) {
-            if (':' == *n) {
-                *s = '\0';
-                n++;
-                ci = rb_intern(class_name);
-                if (!best_effort || rb_const_defined(clas, ci)) {
-                    clas = rb_const_get(clas, ci);
-                } else {
-                    return Qundef;
-                }
-                s = class_name;
-            } else {
-                *s++ = *n;
-            }
+    switch (effort) {
+    case TolerantEffort:
+        if (rb_const_defined(mod, ci)) {
+            clas = rb_const_get(mod, ci);
+        } else {
+            clas = Qundef;
         }
-        *s = '\0';
-        ci = rb_intern(class_name);
-        if (!best_effort || rb_const_defined(clas, ci)) {
-            clas = rb_const_get(clas, ci);
+        break;
+    case AutoEffort:
+        if (rb_const_defined(mod, ci)) {
+            clas = rb_const_get(mod, ci);
         } else {
-            return Qundef;
+            clas = rb_define_class_under(mod, class_name, ox_bag_clas);
         }
-        //clas = rb_const_get(clas, rb_intern(class_name));
-        *slot = clas;
+        break;
+    case StrictEffort:
+    default:
+        // raise an error if name is not defined
+        clas = rb_const_get(mod, ci);
+        break;
     }
     return clas;
 }
 
 inline static VALUE
-classname2obj(const char *name, int best_effort) {
-    VALUE   clas = classname2class(name, best_effort);
+classname2obj(const char *name, PInfo pi) {
+    VALUE   clas = classname2class(name, pi);
     
     if (Qundef == clas) {
         return Qnil;
@@ -178,6 +168,37 @@ parse_time(const char *text, VALUE clas) {
     return t;
 }
 
+static VALUE
+classname2class(const char *name, PInfo pi) {
+    VALUE       *slot;
+    VALUE       clas;
+            
+    if (Qundef == (clas = ox_cache_get(class_cache, name, &slot))) {
+        char            class_name[1024];
+        char            *s;
+        const char      *n = name;
+
+        clas = rb_cObject;
+        for (s = class_name; '\0' != *n; n++) {
+            if (':' == *n) {
+                *s = '\0';
+                n++;
+                if (Qundef == (clas = resolve_classname(clas, class_name, pi->effort))) {
+                    return Qundef;
+                }
+                s = class_name;
+            } else {
+                *s++ = *n;
+            }
+        }
+        *s = '\0';
+        if (Qundef != (clas = resolve_classname(clas, class_name, pi->effort))) {
+            *slot = clas;
+        }
+    }
+    return clas;
+}
+
 static VALUE
 get_var_sym_from_attrs(Attr a) {
     for (; 0 != a->name; a++) {
@@ -189,10 +210,10 @@ get_var_sym_from_attrs(Attr a) {
 }
 
 static VALUE
-get_obj_from_attrs(Attr a, int best_effort) {
+get_obj_from_attrs(Attr a, PInfo pi) {
     for (; 0 != a->name; a++) {
         if ('c' == *a->name && '\0' == *(a->name + 1)) {
-            return classname2obj(a->value, best_effort);
+            return classname2obj(a->value, pi);
         }
     }
     return Qundef;
@@ -209,10 +230,10 @@ get_struct_from_attrs(Attr a) {
 }
 
 static VALUE
-get_class_from_attrs(Attr a, int best_effort) {
+get_class_from_attrs(Attr a, PInfo pi) {
     for (; 0 != a->name; a++) {
         if ('c' == *a->name && '\0' == *(a->name + 1)) {
-            return classname2class(a->value, best_effort);
+            return classname2class(a->value, pi);
         }
     }
     return Qundef;
@@ -537,7 +558,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
         break;
     case RawCode:
         if (hasChildren) {
-            h->obj = parse(pi->s, ox_gen_callbacks, &pi->s, pi->trace, pi->best_effort);
+            h->obj = parse(pi->s, ox_gen_callbacks, &pi->s, pi->trace, pi->effort);
             if (0 != pi->circ_array) {
                 circ_array_set(pi->circ_array, h->obj, get_id_from_attrs(pi, attrs));
             }
@@ -546,7 +567,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
         }
         break;
     case ObjectCode:
-        h->obj = get_obj_from_attrs(attrs, pi->best_effort);
+        h->obj = get_obj_from_attrs(attrs, pi);
         if (0 != pi->circ_array && Qnil != h->obj) {
             circ_array_set(pi->circ_array, h->obj, get_id_from_attrs(pi, attrs));
         }
@@ -558,7 +579,7 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
         }
         break;
     case ClassCode:
-        h->obj = get_class_from_attrs(attrs, pi->best_effort);
+        h->obj = get_class_from_attrs(attrs, pi);
         break;
     case RefCode:
         h->obj = Qundef;

data/ext/ox/ox.c

@@ -71,7 +71,10 @@ VALUE   optimized_sym;
 VALUE   object_sym;
 VALUE   generic_sym;
 VALUE   limited_sym;
-VALUE   best_effort_sym;
+VALUE   strict_sym;
+VALUE   tolerant_sym;
+VALUE   effort_sym;
+VALUE   auto_define_sym;
 VALUE   trace_sym;
 VALUE   empty_string;
 VALUE   zero_fixnum;
@@ -81,7 +84,7 @@ VALUE   ox_comment_clas;
 VALUE   ox_doctype_clas;
 VALUE   ox_document_clas;
 VALUE   ox_element_clas;
-VALUE   ox_text_clas;
+VALUE   ox_bag_clas;
 VALUE   struct_class;
 VALUE   time_class;
 
@@ -112,7 +115,7 @@ to_obj(VALUE self, VALUE ruby_xml) {
     Check_Type(ruby_xml, T_STRING);
     // the xml string gets modified so make a copy of it
     xml = strdup(StringValuePtr(ruby_xml));
-    obj = parse(xml, ox_obj_callbacks, 0, 0, 0);
+    obj = parse(xml, ox_obj_callbacks, 0, 0, StrictEffort);
     free(xml);
     return obj;
 }
@@ -131,7 +134,7 @@ to_gen(VALUE self, VALUE ruby_xml) {
     Check_Type(ruby_xml, T_STRING);
     // the xml string gets modified so make a copy of it
     xml = strdup(StringValuePtr(ruby_xml));
-    obj = parse(xml, ox_gen_callbacks, 0, 0, 0);
+    obj = parse(xml, ox_gen_callbacks, 0, 0, StrictEffort);
     free(xml);
     return obj;
 }
@@ -147,8 +150,8 @@ static VALUE
 load(char *xml, int argc, VALUE *argv, VALUE self) {
     VALUE       obj;
     int         mode = AutoMode;
+    int         effort = StrictEffort;
     int         trace = 0;
-    int         best_effort = 0;
     
     if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
         VALUE   h = *argv;
@@ -169,27 +172,35 @@ load(char *xml, int argc, VALUE *argv, VALUE self) {
                 rb_raise(rb_eArgError, ":mode must be :generic, :object, or :limited.\n");
             }
         }
+        if (Qnil != (v = rb_hash_lookup(h, effort_sym))) {
+            if (auto_define_sym == v) {
+                effort = AutoEffort;
+            } else if (tolerant_sym == v) {
+                effort = TolerantEffort;
+            } else if (strict_sym == v) {
+                effort = StrictEffort;
+            } else {
+                rb_raise(rb_eArgError, ":effort must be :strict, :tolerant, or :auto_define.\n");
+            }
+        }
         if (Qnil != (v = rb_hash_lookup(h, trace_sym))) {
             Check_Type(v, T_FIXNUM);
             trace = FIX2INT(v);
         }
-        if (Qnil != (v = rb_hash_lookup(h, best_effort_sym))) {
-            best_effort = (Qfalse != v);
-        }
     }
     switch (mode) {
     case ObjMode:
-        obj = parse(xml, ox_obj_callbacks, 0, trace, best_effort);
+        obj = parse(xml, ox_obj_callbacks, 0, trace, effort);
         break;
     case GenMode:
-        obj = parse(xml, ox_gen_callbacks, 0, trace, 0);
+        obj = parse(xml, ox_gen_callbacks, 0, trace, StrictEffort);
         break;
     case LimMode:
-        obj = parse(xml, ox_limited_callbacks, 0, trace, best_effort);
+        obj = parse(xml, ox_limited_callbacks, 0, trace, effort);
         break;
     case AutoMode:
     default:
-        obj = parse(xml, ox_gen_callbacks, 0, trace, 0);
+        obj = parse(xml, ox_gen_callbacks, 0, trace, StrictEffort);
         break;
     }
     free(xml);
@@ -204,12 +215,15 @@ load(char *xml, int argc, VALUE *argv, VALUE self) {
  * malformed or the classes specified are not valid.
  * [xml]     XML String
  * [options] load options
- *           [:mode]        format expected
- *                          [: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
- *           [:trace]       trace level as a Fixnum, default: 0 (silent)
- *           [:best_effort] use best effort to create Objects using nil if undefined Class, default: 0
+ *           [:mode]   format expected
+ *                     [: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
+ *           [:effort] 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
+ *                     [:auto_define] auto define missing classes and modules
+ *           [:trace]  trace level as a Fixnum, default: 0 (silent)
  */
 static VALUE
 load_str(int argc, VALUE *argv, VALUE self) {
@@ -229,12 +243,15 @@ load_str(int argc, VALUE *argv, VALUE self) {
  * malformed or the classes specified are not valid.
  * [file_path] file path to read the XML document from
  * [options] load options
- *           [:mode]        format expected
- *                          [: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
- *           [:trace]       trace level as a Fixnum, default: 0 (silent)
- *           [:best_effort] use best effort to create Objects using nil if undefined Class, default: 0
+ *           [:mode]   format expected
+ *                     [: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
+ *           [:effort] 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
+ *                     [:auto_define] auto define missing classes and modules
+ *           [:trace]  trace level as a Fixnum, default: 0 (silent)
  */
 static VALUE
 load_file(int argc, VALUE *argv, VALUE self) {
@@ -419,7 +436,10 @@ void Init_ox() {
     generic_sym = ID2SYM(rb_intern("generic"));
     limited_sym = ID2SYM(rb_intern("limited"));
     trace_sym = ID2SYM(rb_intern("trace"));
-    best_effort_sym = ID2SYM(rb_intern("best_effort"));
+    effort_sym = ID2SYM(rb_intern("effort"));
+    strict_sym = ID2SYM(rb_intern("strict"));
+    tolerant_sym = ID2SYM(rb_intern("tolerant"));
+    auto_define_sym = ID2SYM(rb_intern("auto_define"));
     empty_string = rb_str_new2("");
     zero_fixnum = INT2NUM(0);
     
@@ -429,6 +449,7 @@ void Init_ox() {
     ox_comment_clas = rb_const_get(Ox, rb_intern("Comment"));
     ox_doctype_clas = rb_const_get(Ox, rb_intern("DocType"));
     ox_cdata_clas = rb_const_get(Ox, rb_intern("CData"));
+    ox_bag_clas = rb_const_get(Ox, rb_intern("Bag"));
 
     ox_cache_new(&symbol_cache);
     ox_cache_new(&class_cache);

data/ext/ox/ox.h

@@ -65,6 +65,12 @@ typedef enum {
     UseRaw      = 11,
 } Use;
 
+typedef enum {
+    StrictEffort    = 0,
+    TolerantEffort  = 1,
+    AutoEffort      = 2,
+} Effort;
+
 typedef enum {
     NoCode         = 0,
     ArrayCode      = 'a',
@@ -133,10 +139,10 @@ struct _PInfo {
     rb_encoding         *encoding;
     unsigned long       id;             /* set for text types when cirs_array is set */
     int                 trace;
-    int                 best_effort;
+    Effort              effort;
 };
 
-extern VALUE    parse(char *xml, ParseCallbacks pcb, char **endp, int trace, int best_effort);
+extern VALUE    parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort);
 extern void     _raise_error(const char *msg, const char *xml, const char *current, const char* file, int line);
 
 extern char*    write_obj_to_str(VALUE obj, int indent, int xsd_date, int circular);
@@ -172,7 +178,7 @@ extern VALUE    zero_fixnum;
 
 extern VALUE    ox_document_clas;
 extern VALUE    ox_element_clas;
-extern VALUE    ox_text_clas;
+extern VALUE    ox_bag_clas;
 extern VALUE    ox_comment_clas;
 extern VALUE    ox_doctype_clas;
 extern VALUE    ox_cdata_clas;

data/ext/ox/parse.c

@@ -79,7 +79,7 @@ next_non_white(PInfo pi) {
 }
 
 VALUE
-parse(char *xml, ParseCallbacks pcb, char **endp, int trace, int best_effort) {
+parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
     struct _PInfo       pi;
     int                 body_read = 0;
 
@@ -98,7 +98,7 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, int best_effort) {
     pi.circ_array = 0;
     pi.encoding = 0;
     pi.trace = trace;
-    pi.best_effort = best_effort;
+    pi.effort = effort;
     while (1) {
 	next_non_white(&pi);	// skip white space
 	if ('\0' == *pi.s) {

data/lib/ox.rb

@@ -93,5 +93,6 @@ require 'ox/cdata'
 require 'ox/doctype'
 require 'ox/element'
 require 'ox/document'
+require 'ox/bag'
 
 require 'ox/ox' # C extension

data/lib/ox/bag.rb

@@ -0,0 +1,88 @@
+
+module Ox
+
+  # A generic class that is used only for storing attributes. It is the base
+  # Class for auto-generated classes in the storage system. Instance variables
+  # are added using the instance_variable_set() method. All instance variables
+  # can be accessed using the variable name (without the @ prefix). No setters
+  # are provided as the Class is intended for reading only.
+  class Bag
+
+    # The initializer can take multiple arguments in the form of key values
+    # where the key is the variable name and the value is the variable
+    # value. This is intended for testing purposes only.
+    # Example: Ox::Bag.new(:@x => 42, :@y => 57)
+    def initialize(args={ })
+      args.each do |k,v|
+        self.instance_variable_set(k, v)
+        m = k.to_s[1..-1].to_sym
+        unless respond_to?(m)
+          self.class.define_get(m, k)
+        end
+      end
+    end
+
+    # Replaces the Object.respond_to?() method to return true for any method
+    # than matches instance variables.
+    # [m] method symbol
+    def respond_to?(m)
+      at_m = ('@' + m.to_s).to_sym
+      instance_variables.include?(at_m)
+    end
+
+    # Handles requests for variable values. Others cause an Exception to be
+    # raised.
+    # [m] method symbol
+    def method_missing(m, *args, &block)
+      raise ArgumentError.new("wrong number of arguments(#{args.size} for 0)") unless args.nil? or args.empty?
+      at_m = ('@' + m.to_s).to_sym
+      raise NoMethodError("undefined method", m) unless instance_variable_defined?(at_m)
+      instance_variable_get(at_m)
+    end
+
+    # Replace eql?() with something more reasonable for this Class.
+    # [other] Object to compare this one to
+    def eql?(other)
+      return false if (other.nil? or self.class != other.class)
+      ova = other.instance_variables
+      iv = instance_variables
+      return false if ova.size != iv.size
+      iv.each do |vid|
+        return false if instance_variable_get(vid) != other.instance_variable_get(vid)
+      end
+      true
+    end
+    alias == eql?
+    
+  end # Bag
+
+  # Define a new class based on the Ox::Bag class. This is used internally in
+  # the Ox module and is available to service wrappers that receive XML
+  # requests that include Objects of Classes not defined in the storage
+  # process.
+  # [classname] Class name or symbol that includes Module names
+  def self.define_class(classname)
+    classname = classname.to_s unless classname.is_a?(String)
+    tokens = classname.split('::').map { |n| n.to_sym }
+    raise "Invalid classname '#{classname}" if tokens.empty?
+    m = Object
+    tokens[0..-2].each do |sym|
+      if m.const_defined?(sym)
+        m = m.const_get(sym)
+      else
+        c = Module.new
+        m.const_set(sym, c)
+        m = c
+      end
+    end
+    sym = tokens[-1]
+    if m.const_defined?(sym)
+      c = m.const_get(sym)
+    else
+      c = Class.new(Ox::Bag)
+      m.const_set(sym, c)
+    end
+    c
+  end
+
+end # Ox

data/test/func.rb

@@ -112,15 +112,26 @@ class Func < ::Test::Unit::TestCase
   
   def test_bad_object
     xml = %{<?xml version="1.0"?>
-<o c="Bad">
+<o c="Bad::Boy">
   <i a="@x">3</i>
 </o>
+}
+    xml2 = %{<?xml version="1.0"?>
+<o c="Bad">
+  <i a="@x">7</i>
+</o>
 }
     assert_raise(NameError) {
       Ox.load(xml, :mode => :object, :trace => 0)
     }
-    loaded = Ox.load(xml, :mode => :object, :trace => 0, :best_effort => true)
+    loaded = Ox.load(xml, :mode => :object, :trace => 0, :effort => :tolerant)
     assert_equal(loaded, nil)
+    loaded = Ox.load(xml, :mode => :object, :trace => 0, :effort => :auto_define)
+    assert_equal(loaded.class.to_s, 'Bad::Boy')
+    assert_equal(loaded.class.superclass.to_s, 'Ox::Bag')
+    loaded = Ox.load(xml2, :mode => :object, :trace => 0, :effort => :auto_define)
+    assert_equal(loaded.class.to_s, 'Bad')
+    assert_equal(loaded.class.superclass.to_s, 'Ox::Bag')
   end
   
   def test_class

metadata

@@ -2,7 +2,7 @@
 name: ox
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors: 
 - Peter Ohler
@@ -10,7 +10,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-04 00:00:00 Z
+date: 2011-07-06 00:00:00 +09:00
+default_executable: 
 dependencies: []
 
 description: A fast XML parser and object serializer that uses only standard C lib.
@@ -22,6 +23,7 @@ extensions:
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- lib/ox/bag.rb
 - lib/ox/cdata.rb
 - lib/ox/comment.rb
 - lib/ox/doctype.rb
@@ -73,6 +75,7 @@ files:
 - test/Sample.graffle
 - LICENSE
 - README.rdoc
+has_rdoc: true
 homepage: http://www.ohler.com/ox
 licenses: []
 
@@ -98,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ox
-rubygems_version: 1.8.5
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A fast XML parser and object serializer.