ox 1.1.1 → 1.2.0

data/ext/ox/ox.h

@@ -51,6 +51,18 @@ extern "C" {
 #define TRACE           1
 #define DEBUG           2
 
+#define XSD_DATE        0x0001
+#define WITH_XML        0x0002
+#define WITH_INST       0x0004
+#define WITH_DTD        0x0008
+#define CIRCULAR        0x0010
+
+#define XSD_DATE_SET    0x0100
+#define WITH_XML_SET    0x0200
+#define WITH_INST_SET   0x0400
+#define WITH_DTD_SET    0x0800
+#define CIRCULAR_SET    0x1000
+
 typedef enum {
     UseObj      = 1,
     UseAttr     = 2,
@@ -66,11 +78,25 @@ typedef enum {
 } Use;
 
 typedef enum {
-    StrictEffort    = 0,
-    TolerantEffort  = 1,
-    AutoEffort      = 2,
+    StrictEffort    = 's',
+    TolerantEffort  = 't',
+    AutoEffort      = 'a',
+    NoEffort        = 0,
 } Effort;
 
+typedef enum {
+    Yes    = 'y',
+    No     = 'n',
+    NotSet = 0
+} YesNo;
+
+typedef enum {
+    ObjMode  = 'o',
+    GenMode  = 'g',
+    LimMode  = 'l',
+    NoMode   = 0
+} LoadMode;
+
 typedef enum {
     NoCode         = 0,
     ArrayCode      = 'a',
@@ -111,7 +137,7 @@ typedef struct _Helper {
 typedef struct _PInfo   *PInfo;
 
 typedef struct _ParseCallbacks {
-    void        (*add_prolog)(PInfo pi, const char *version, const char *encoding, const char *standalone);
+    void        (*instruct)(PInfo pi, const char *target, Attr attrs);
     void        (*add_doctype)(PInfo pi, const char *docType);
     void        (*add_comment)(PInfo pi, const char *comment);
     void        (*add_cdata)(PInfo pi, const char *cdata, size_t len);
@@ -142,11 +168,24 @@ struct _PInfo {
     Effort              effort;
 };
 
+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
+} *Options;
+
 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);
-extern void     write_obj_to_file(VALUE obj, const char *path, int indent, int xsd_date, int circular);
+extern char*    write_obj_to_str(VALUE obj, Options copts);
+extern void     write_obj_to_file(VALUE obj, const char *path, Options copts);
 
 extern VALUE    Ox;
 

data/ext/ox/parse.c

@@ -36,7 +36,7 @@
 #include "ruby.h"
 #include "ox.h"
 
-static void     read_prolog(PInfo pi);
+static void     read_instruction(PInfo pi);
 static void     read_doctype(PInfo pi);
 static void     read_comment(PInfo pi);
 static void     read_element(PInfo pi);
@@ -115,7 +115,7 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
 	switch (*pi.s) {
 	case '?':	// prolog
 	    pi.s++;
-	    read_prolog(&pi);
+	    read_instruction(&pi);
 	    break;
 	case '!':	/* comment or doctype */
 	    pi.s++;
@@ -150,77 +150,49 @@ parse(char *xml, ParseCallbacks pcb, char **endp, int trace, Effort effort) {
 /* Entered after the "<?" sequence. Ready to read the rest.
  */
 static void
-read_prolog(PInfo pi) {
-    char        *version = 0;
-    char        *encoding = 0;
-    char        *standalone = 0;
-    char        *name;
-    char        *end;
-    char        c;
-    
-    // skip xml string
-    if (0 != strncasecmp("xml", pi->s, 3)) {
-	raise_error("invalid format, expected 'xml'", pi->str, pi->s);
-    }
-    pi->s += 3;	// past xml
-    /* looking for ?> to terminate the prolog */
-    while ('?' != *pi->s) {
-	if ('\0' == *pi->s) {
-	    raise_error("invalid format, prolog not terminated", pi->str, pi->s);
-	}
-        name = read_name_token(pi);
-        end = pi->s;
-	next_non_white(pi);
-        c = *pi->s;
-        *end = '\0'; // terminate name
-        if ('=' == c) {
-	    // Figure out what the token is, read a value for it, and check
-	    // against supported values.
-	    pi->s++;
-	    next_non_white(pi);
-	    if (0 == strcasecmp("version", name)) {
-		version = read_quoted_value(pi);
-		if (validateProlog &&
-                    (0 != strcmp("1.0", version) &&
-                     0 != strcmp("1.1", version))) {
-		    raise_error("invalid format, wrong XML version", pi->str, pi->s);
-		}
-	    } else if (0 == strcasecmp("encoding", name)) {
-		encoding = read_quoted_value(pi);
-                /*
-		if (validateProlog && 0 != strcasecmp("UTF-8", encoding)) {
-		    raise_error("invalid format, only UTF-8 supported", pi->str, pi->s);
-		}
-                */
-	    } else if (0 == strcasecmp("standalone", name)) {
-		standalone = read_quoted_value(pi);
-		if (validateProlog && 0 != strcmp("yes", standalone)) {
-		    raise_error("invalid format, only standalone XML supported", pi->str, pi->s);
-		}
-	    } else {
-		raise_error("invalid format, unknown prolog attribute", pi->str, pi->s);
-	    }
-	} else if ('?' == c) {
-	    pi->s++;
-	    if ('>' != *pi->s++) {
-		raise_error("invalid format, prolog not terminated", pi->str, pi->s);
-	    }
-	    return;
-	} else {
-	    raise_error("invalid format, prolog format error", pi->str, pi->s);
-	}
-    }
-    if ('\0' == pi->s) {
-	raise_error("invalid format, prolog not terminated", pi->str, pi->s);
-    }
-    if ('?' == *pi->s) {
-	pi->s++;
+read_instruction(PInfo pi) {
+    struct _Attr        attrs[MAX_ATTRS + 1];
+    Attr                a = attrs;
+    char                *target;
+    char                *end;
+    char                c;
+        
+    memset(attrs, 0, sizeof(attrs));
+    target = read_name_token(pi);
+    end = pi->s;
+    next_non_white(pi);
+    c = *pi->s;
+    *end = '\0'; // terminate name
+    if ('?' != c) {
+        while ('?' != *pi->s) {
+            if ('\0' == *pi->s) {
+                raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
+            }
+            next_non_white(pi);
+            a->name = read_name_token(pi);
+            end = pi->s;
+            next_non_white(pi);
+            if ('=' != *pi->s++) {
+                raise_error("invalid format, no attribute value", pi->str, pi->s);
+            }
+            *end = '\0'; // terminate name
+            // read value
+            next_non_white(pi);
+            a->value = read_quoted_value(pi);
+            a++;
+            if (MAX_ATTRS <= (a - attrs)) {
+                raise_error("too many attributes", pi->str, pi->s);
+            }
+        }
+        if ('?' == *pi->s) {
+            pi->s++;
+        }
     }
     if ('>' != *pi->s++) {
-	raise_error("invalid format, prolog not terminated", pi->str, pi->s);
+        raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);
     }
-    if (0 != pi->pcb->add_prolog) {
-        pi->pcb->add_prolog(pi, version, encoding, standalone);
+    if (0 != pi->pcb->instruct) {
+        pi->pcb->instruct(pi, target, attrs);
     }
 }
 
@@ -492,7 +464,7 @@ read_text(PInfo pi) {
                     }
                     b = alloc_buf + pos;
                 }
-                end = alloc_buf + size;
+                end = alloc_buf + size - 2;
 	    }
 	    if (spc) {
 		*b++ = ' ';
@@ -503,9 +475,11 @@ read_text(PInfo pi) {
 	}
     }
     *b = '\0';
-    pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
     if (0 != alloc_buf) {
+        pi->pcb->add_text(pi, alloc_buf, ('/' == *(pi->s + 1)));
         free(alloc_buf);
+    } else {
+        pi->pcb->add_text(pi, buf, ('/' == *(pi->s + 1)));
     }
 }
 

data/lib/ox.rb

@@ -83,10 +83,11 @@
 #   doc2 = Ox.parse(xml)
 #   puts "Same? #{doc == doc2}"
 module Ox
-  # Current version of the module. 
-  VERSION = '1.0.0'
+  private
+  @@keep = []
 end
 
+require 'ox/version'
 require 'ox/node'
 require 'ox/comment'
 require 'ox/cdata'

data/lib/ox/bag.rb

@@ -54,35 +54,35 @@ module Ox
     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|
+    # 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)
-        m = m.const_get(sym)
+        c = m.const_get(sym)
       else
-        c = Module.new
+        c = Class.new(Ox::Bag)
         m.const_set(sym, c)
-        m = c
       end
+      c
     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 # Bag
 
 end # Ox

data/lib/ox/version.rb

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

data/test/bug1.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+if __FILE__ == $0
+  if (i = ARGV.index('-I'))
+    x,path = ARGV.slice!(i, 2)
+    $: << path
+  end
+end
+
+require 'ox'
+
+def oxpoo(cnt = 100000)
+  xml = "<?xml version=\"1.0\"?>\n<a>\n  <m>inc</m>\n  <i>1</i>\n</a>\n" 
+  cnt.times do |i|
+    obj = Ox.load(xml, :mode => :object)
+    #puts "#{obj} (#{obj.class})"
+    raise "decode ##{i} not equal; #{obj.inspect} != '#{[:inc, 1] }'" unless [:inc, 1] == obj
+  end
+end
+
+oxpoo()

data/test/bug2.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+if __FILE__ == $0
+  if (i = ARGV.index('-I'))
+    x,path = ARGV.slice!(i, 2)
+    $: << path
+  end
+end
+
+require 'ox'
+
+def bug2()
+  s = File.read('long.pdf')
+  puts "size before: #{s.size}"
+  
+  # s = "Hello\x00\x00\x00there."
+  xml = Ox.dump(s, mode: :object)
+  #puts "xml size: #{xml.size}"
+  s2 = Ox.load(xml, mode: :object)
+  puts "size after: #{s2.size}"
+  #puts s2
+  b1 = s.bytes
+  b2 = s2.bytes
+  (0..s2.bytesize).each do |i|
+    puts "#{s.getbyte(i)}  #{s2.getbyte(i)}"
+    if s.getbyte(i) != s2.getbyte(i)
+      puts "stopped at #{i}"
+      break
+    end
+  end
+  puts "byte sizes #{s.bytesize}  #{s2.bytesize}"
+  puts "char sizes #{s.size}  #{s2.size}"
+end
+
+bug2()

data/test/func.rb

@@ -22,7 +22,51 @@ opts.on("-h", "--help", "Show this display")                { puts opts; Process
 files = opts.parse(ARGV)
 
 class Func < ::Test::Unit::TestCase
-  
+
+  def test_get_options
+    opts = Ox.default_options()
+    assert_equal(opts, {
+                   :encoding=>nil,
+                   :indent=>2,
+                   :trace=>0,
+                   :with_dtd=>false,
+                   :with_xml=>false,
+                   :with_instructions=>false,
+                   :circular=>false,
+                   :xsd_date=>false,
+                   :mode=>nil,
+                   :effort=>:strict})
+  end
+
+  def test_set_options
+    orig = {
+      :encoding=>nil,
+      :indent=>2,
+      :trace=>0,
+      :with_dtd=>false,
+      :with_xml=>true,
+      :with_instructions=>false,
+      :circular=>false,
+      :xsd_date=>false,
+      :mode=>nil,
+      :effort=>:strict}
+    o2 = {
+      :encoding=>"UTF-8",
+      :indent=>4,
+      :trace=>1,
+      :with_dtd=>true,
+      :with_xml=>false,
+      :with_instructions=>true,
+      :circular=>true,
+      :xsd_date=>true,
+      :mode=>:object,
+      :effort=>:tolerant }
+    Ox.default_options = o2
+    opts = Ox.default_options()
+    assert_equal(opts, o2);
+    Ox.default_options = orig # return to original
+  end
+
   def test_nil
     dump_and_load(nil, false)
   end
@@ -133,7 +177,32 @@ class Func < ::Test::Unit::TestCase
     assert_equal(loaded.class.to_s, 'Bad')
     assert_equal(loaded.class.superclass.to_s, 'Ox::Bag')
   end
-  
+
+  def test_xml_instruction
+    xml = Ox.dump("test", mode: :object, with_xml: false)
+    assert_equal(xml, "<s>test</s>\n")
+    xml = Ox.dump("test", mode: :object, with_xml: true)
+    assert_equal(xml, "<?xml version=\"1.0\"?>\n<s>test</s>\n")
+    xml = Ox.dump("test", mode: :object, with_xml: true, encoding: 'UTF-8')
+    assert_equal(xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<s>test</s>\n")
+  end
+
+  def test_ox_instruction
+    xml = Ox.dump("test", mode: :object, with_xml: true, with_instructions: true)
+    assert_equal(xml, "<?xml version=\"1.0\"?>\n<?ox version=\"1.0\" mode=\"object\"?>\n<s>test</s>\n")
+    xml = Ox.dump("test", mode: :object, with_instructions: true)
+    assert_equal(xml, "<?ox version=\"1.0\" mode=\"object\"?>\n<s>test</s>\n")
+    xml = Ox.dump("test", mode: :object, with_instructions: true, circular: true, xsd_date: true)
+    assert_equal(xml, "<?ox version=\"1.0\" mode=\"object\" circular=\"yes\" xsd_date=\"yes\"?>\n<s i=\"1\">test</s>\n")
+    xml = Ox.dump("test", mode: :object, with_instructions: true, circular: false, xsd_date: false)
+    assert_equal(xml, "<?ox version=\"1.0\" mode=\"object\" circular=\"no\" xsd_date=\"no\"?>\n<s>test</s>\n")
+  end
+
+  def test_dtd
+    xml = Ox.dump("test", mode: :object, with_dtd: true)
+    assert_equal(xml, "<!DOCTYPE s SYSTEM \"ox.dtd\">\n<s>test</s>\n")
+  end
+
   def test_class
     dump_and_load(Bag, false)
   end
@@ -215,6 +284,14 @@ class Func < ::Test::Unit::TestCase
     loaded
   end
 
+  def test_instructions
+    xml = Ox.dump("test", with_instructions: true)
+    puts xml
+    obj = Ox.load(xml) # should convert it to an object
+    assert_equal("test", obj)
+  end
+
+
 end
 
 class Bag