ox 1.3.1 → 1.3.2

data/README.md

@@ -18,12 +18,17 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 [![Build Status](http://travis-ci.org/ohler55/ox.png)](http://travis-ci.org/ohler55/ox)
 
+## <a name="links">Links of Interest</a>
+
+[Ruby XML Gem Comparison](http://www.ohler.com/software/thoughts/Blog/Entries/2011/9/21_XML_with_Ruby.html) for a perfomance comparison between Ox, Nokogiri, and LibXML.
+
+[Fast Ruby XML Serialization](http://www.ohler.com/software/thoughts/Blog/Entries/2011/9/20_Ruby_Object_XML_Serialization.html) to see how Ox can be used as a faster replacement for Marshal.
+
 ## <a name="release">Release Notes</a>
 
-### Release 1.3.0
+### Release 1.3.2
 
- - fixed Mutex dump bug
- - added SAX parser, 30+ times faster than Nokogiri and 10+ times faster than LibXML
+ - Changed SAX parser API for element and instruction attributes
 
 ## <a name="description">Description</a>
 
@@ -57,8 +62,8 @@ files may result in slightly different times.
 As an Object serializer Ox is up to 6 times faster than the standard Ruby
 Marshal.dump() and up to 3 times faster than Marshal.load().
 
-The SAX like stream parser is over 30 times faster than Nokogiri and more than
-10 times faster than LibXML when using a trivial Ruby side set of
+The SAX like stream parser is 40 times faster than Nokogiri and more than 13
+times faster than LibXML when validating a file with minimal Ruby
 callbacks. Unlike Nokogiri and LibXML, Ox can be tuned to use only the SAX
 callbacks that are of interest to the caller. (See the perf_sax.rb file for an
 example.)
@@ -120,27 +125,27 @@ necessary.
 
 The type indicator map is:
 
-- +a+ => Array
-- +b+ => Base64
-- +c+ => Class
-- +f+ => Float
-- +g+ => Regexp
-- +h+ => Hash
-- +i+ => Fixnum
-- +j+ => Bignum
-- +l+ => Rational
-- +m+ => Symbol
-- +n+ => FalseClass
-- +o+ => Object
-- +p+ => Ref
-- +r+ => Range
-- +s+ => String
-- +t+ => Time
-- +u+ => Struct
-- +v+ => Complex
-- +x+ => Raw
-- +y+ => TrueClass
-- +z+ => NilClass
+- **a** => Array
+- **b** => Base64
+- **c** => Class
+- **f** => Float
+- **g** => Regexp
+- **h** => Hash
+- **i** => Fixnum
+- **j** => Bignum
+- **l** => Rational
+- **m** => Symbol
+- **n** => FalseClass
+- **o** => Object
+- **p** => Ref
+- **r** => Range
+- **s** => String
+- **t** => Time
+- **u** => Struct
+- **v** => Complex
+- **x** => Raw
+- **y** => TrueClass
+- **z** => NilClass
 
 If the type is an Object, type 'o' then an attribute named 'c' should be set
 with the full Class name including the Module names. If the XML element

data/ext/ox/ox.c

@@ -46,6 +46,7 @@ void Init_ox();
 VALUE    Ox = Qnil;
 
 ID      at_id;
+ID      attr_id;
 ID      attributes_id;
 ID      beg_id;
 ID      cdata_id;
@@ -616,6 +617,7 @@ void Init_ox() {
 
     rb_require("time");
     at_id = rb_intern("at");
+    attr_id = rb_intern("attr");
     attributes_id = rb_intern("@attributes");
     beg_id = rb_intern("@beg");
     cdata_id = rb_intern("cdata");

data/ext/ox/ox.h

@@ -206,6 +206,7 @@ extern void     write_obj_to_file(VALUE obj, const char *path, Options copts);
 extern VALUE    Ox;
 
 extern ID       at_id;
+extern ID       attr_id;
 extern ID       attributes_id;
 extern ID       beg_id;
 extern ID       cdata_id;

data/ext/ox/sax.c

@@ -56,6 +56,7 @@ typedef struct _SaxDrive {
         VALUE   io;
     };
     int         has_instruct;
+    int         has_attr;
     int         has_doctype;
     int         has_comment;
     int         has_cdata;
@@ -80,7 +81,7 @@ static int      read_cdata(SaxDrive dr);
 static int      read_comment(SaxDrive dr);
 static int      read_element(SaxDrive dr);
 static int      read_text(SaxDrive dr);
-static int      read_attrs(SaxDrive dr, VALUE *attrs, char c, char termc, char term2);
+static int      read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml);
 static char     read_name_token(SaxDrive dr);
 static int      read_quoted_value(SaxDrive dr);
 
@@ -162,6 +163,7 @@ ox_sax_parse(VALUE handler, VALUE io) {
 #if 0
     printf("*** sax_parse with these flags\n");
     printf("    has_instruct = %s\n", dr.has_instruct ? "true" : "false");
+    printf("    has_attr = %s\n", dr.has_attr ? "true" : "false");
     printf("    has_doctype = %s\n", dr.has_doctype ? "true" : "false");
     printf("    has_comment = %s\n", dr.has_comment ? "true" : "false");
     printf("    has_cdata = %s\n", dr.has_cdata ? "true" : "false");
@@ -199,6 +201,7 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io) {
     dr->col = 0;
     dr->handler = handler;
     dr->has_instruct = rb_respond_to(handler, instruct_id);
+    dr->has_attr = rb_respond_to(handler, attr_id);
     dr->has_doctype = rb_respond_to(handler, doctype_id);
     dr->has_comment = rb_respond_to(handler, comment_id);
     dr->has_cdata = rb_respond_to(handler, cdata_id);
@@ -373,17 +376,18 @@ read_children(SaxDrive dr, int first) {
  */
 static int
 read_instruction(SaxDrive dr) {
-    VALUE       target = Qnil;
-    VALUE       attrs = Qnil;
     char        c;
 
     if ('\0' == (c = read_name_token(dr))) {
         return -1;
     }
     if (dr->has_instruct) {
-        target = rb_str_new2(dr->str);
+        VALUE       args[1];
+
+        args[0] = rb_str_new2(dr->str);
+        rb_funcall2(dr->handler, instruct_id, 1, args);
     }
-    if (0 != read_attrs(dr, &attrs, c, '?', '?')) {
+    if (0 != read_attrs(dr, c, '?', '?', (0 == strcmp("xml", dr->str)))) {
         return -1;
     }
     c = next_non_white(dr);
@@ -391,13 +395,6 @@ read_instruction(SaxDrive dr) {
         sax_drive_error(dr, "invalid format, instruction not terminated", 1);
         return -1;
     }
-    if (0 != dr->has_instruct) {
-        VALUE       args[2];
-
-        args[0] = target;
-        args[1] = attrs;
-        rb_funcall2(dr->handler, instruct_id, 2, args);
-    }
     dr->str = 0;
 
     return 0;
@@ -519,7 +516,6 @@ read_comment(SaxDrive dr) {
 static int
 read_element(SaxDrive dr) {
     VALUE       name = Qnil;
-    VALUE       attrs = Qnil;
     char        c;
     int         closed;
 
@@ -527,12 +523,18 @@ read_element(SaxDrive dr) {
         return -1;
     }
     name = str2sym(dr->str);
+    if (dr->has_start_element) {
+        VALUE       args[1];
+
+        args[0] = name;
+        rb_funcall2(dr->handler, start_element_id, 1, args);
+    }
     if ('/' == c) {
         closed = 1;
     } else if ('>' == c) {
         closed = 0;
     } else {
-        if (0 != read_attrs(dr, &attrs, c, '/', '>')) {
+        if (0 != read_attrs(dr, c, '/', '>', 0)) {
             return -1;
         }
         closed = ('/' == *(dr->cur - 1));
@@ -544,17 +546,14 @@ read_element(SaxDrive dr) {
             return -1;
         }
     }
-    if (0 != dr->has_start_element) {
-        VALUE       args[2];
+    if (closed) {
+        if (dr->has_end_element) {
+            VALUE       args[1];
 
-        args[0] = name;
-        args[1] = attrs;
-        rb_funcall2(dr->handler, start_element_id, 2, args);
-        if (closed && dr->has_end_element) {
+            args[0] = name;
             rb_funcall2(dr->handler, end_element_id, 1, args);
         }
-    }
-    if (!closed) {
+    } else {
         if (0 != read_children(dr, 0)) {
             return -1;
         }
@@ -601,7 +600,7 @@ read_text(SaxDrive dr) {
 }
 
 static int
-read_attrs(SaxDrive dr, VALUE *attrs, char c, char termc, char term2) {
+read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml) {
     VALUE       name = Qnil;
     int         is_encoding = 0;
     
@@ -618,10 +617,10 @@ read_attrs(SaxDrive dr, VALUE *attrs, char c, char termc, char term2) {
         if ('\0' == (c = read_name_token(dr))) {
             return -1;
         }
-        if ('?' == termc && 0 == strcmp("encoding", dr->str)) {
+        if (is_xml && 0 == strcmp("encoding", dr->str)) {
             is_encoding = 1;
         }
-        if (dr->has_instruct) {
+        if (dr->has_attr) {
             name = str2sym(dr->str);
         }
         if (is_white(c)) {
@@ -639,18 +638,17 @@ read_attrs(SaxDrive dr, VALUE *attrs, char c, char termc, char term2) {
             dr->encoding = rb_enc_find(dr->str);
         }
 #endif
-        if (dr->has_instruct) {
-            VALUE       rstr = rb_str_new2(dr->str);
-            
-            if (Qnil == *attrs) {
-                *attrs = rb_hash_new();
-            }
+        if (dr->has_attr) {
+            VALUE       args[2];
+
+            args[0] = name;
+            args[1] = rb_str_new2(dr->str);
 #ifdef HAVE_RUBY_ENCODING_H
             if (0 != dr->encoding) {
-                rb_enc_associate(rstr, dr->encoding);
+                rb_enc_associate(args[1], dr->encoding);
             }
 #endif
-            rb_hash_aset(*attrs, name, rstr);
+            rb_funcall2(dr->handler, attr_id, 2, args);
         }
         c = next_non_white(dr);
     }

data/lib/ox/sax.rb

@@ -26,12 +26,13 @@ module Ox
   # be made public in the subclasses. If the methods remain private they will
   # not be called during parsing.
   #
-  #    def instruct(target, attrs); end
+  #    def instruct(target); end
+  #    def attr(name, value); end
   #    def doctype(value); end
   #    def comment(value); end
   #    def cdata(value); end
   #    def text(value); end
-  #    def start_element(name, attrs); end
+  #    def start_element(name); end
   #    def end_element(name); end
   #
   class Sax
@@ -44,7 +45,10 @@ module Ox
     # they will not be called during parsing.
     private
 
-    def instruct(target, attrs)
+    def instruct(target)
+    end
+
+    def attr(name, value)
     end
 
     def doctype(value)
@@ -59,7 +63,7 @@ module Ox
     def text(value)
     end
 
-    def start_element(name, attrs)
+    def start_element(name)
     end
 
     def end_element(name)

data/lib/ox/version.rb

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

data/test/perf_gen.rb

@@ -17,7 +17,14 @@ require 'ox'
 require 'sample'
 require 'test/ox/doc'
 require 'files'
-require 'nokogiri'
+begin
+  require 'nokogiri'
+rescue Exception => e
+end
+begin
+  require 'libxml'
+rescue Exception => e
+end
 
 $verbose = 0
 $ox_only = false
@@ -54,25 +61,31 @@ if files.empty?
   data = []
   obj = do_sample ? sample_doc(2) : files('..')
   xml = Ox.dump(obj, :indent => 2, :opt_format => true)
-  gen = Ox.parse(xml)
-  no = Nokogiri::XML::Document.parse(xml)
   File.open('sample.xml', 'w') { |f| f.write(xml) }
-  data << { :file => 'sample.xml', :xml => xml, :ox => gen, :nokogiri => no }
+  gen = Ox.parse(xml)
+  h = { :file => 'sample.xml', :xml => xml, :ox => gen }
+  h[:nokogiri] = Nokogiri::XML::Document.parse(xml) unless defined?(::Nokogiri).nil?
+  h[:libxml] = LibXML::XML::Document.string(xml) unless defined?(::LibXML).nil?
+  data << h
 else
   puts "loading and parsing #{files}\n\n"
   data = files.map do |f|
     xml = File.read(f)
     obj = Ox.parse(xml);
     gen = Ox.parse(xml)
-    no = Nokogiri::XML::Document.parse(xml)
-    { :file => f, :xml => xml, :ox => gen, :nokogiri => no }
+    h = { :file => f, :xml => xml, :ox => gen }
+    h[:nokogiri] = Nokogiri::XML::Document.parse(xml) unless defined?(::Nokogiri).nil?
+    h[:libxml] = LibXML::XML::Document.string(xml) unless defined?(::LibXML).nil?
+    h
   end
 end
 
 $ox_load_time = 0
 $no_load_time = 0
+$lx_load_time = 0
 $ox_dump_time = 0
 $no_dump_time = 0
+$lx_dump_time = 0
 
 def perf_load(d)
   xml = d[:xml]
@@ -91,14 +104,28 @@ def perf_load(d)
 
   return if $ox_only
   
-  start = Time.now
-  (1..$iter).each do
-    obj = Nokogiri::XML::Document.parse(xml)
-    #obj = Nokogiri::XML::Document.parse(xml, nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
+  unless defined?(::Nokogiri).nil?
+    start = Time.now
+    (1..$iter).each do
+      obj = Nokogiri::XML::Document.parse(xml)
+      #obj = Nokogiri::XML::Document.parse(xml, nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
+    end
+    $no_load_time = Time.now - start
+    puts "Nokogiri parse #{$iter} times took #{$no_load_time} seconds."
+  end
+
+  unless defined?(::LibXML).nil?
+    start = Time.now
+    (1..$iter).each do
+      obj = LibXML::XML::Document.string(xml)
+    end
+    $lx_load_time = Time.now - start
+    puts "LibXML parse #{$iter} times took #{$lx_load_time} seconds."
   end
-  $no_load_time = Time.now - start
-  puts "Nokogiri parse #{$iter} times took #{$no_load_time} seconds."
-  puts ">>> Ox is %0.1f faster than Nokogiri parsing.\n\n" % [$no_load_time/$ox_load_time]
+  puts "\n"
+  puts ">>> Ox is %0.1f faster than Nokogiri parsing." % [$no_load_time/$ox_load_time] unless defined?(::Nokogiri).nil?
+  puts ">>> Ox is %0.1f faster than LibXML parsing." % [$lx_load_time/$ox_load_time] unless defined?(::LibXML).nil?
+  puts "\n"
 end
 
 def perf_dump(d)
@@ -114,14 +141,29 @@ def perf_dump(d)
 
   return if $ox_only
 
-  obj = d[:nokogiri]
-  start = Time.now
-  (1..$iter).each do
-    xml = obj.to_xml(:indent => 0)
+  unless defined?(::Nokogiri).nil?
+    obj = d[:nokogiri]
+    start = Time.now
+    (1..$iter).each do
+      xml = obj.to_xml(:indent => 2)
+    end
+    $no_dump_time = Time.now - start
+    puts "Nokogiri to_xml #{$iter} times took #{$no_dump_time} seconds."
+  end
+
+  unless defined?(::LibXML).nil?
+    obj = d[:libxml]
+    start = Time.now
+    (1..$iter).each do
+      xml = obj.to_s()
+    end
+    $lx_dump_time = Time.now - start
+    puts "LibML to_s #{$iter} times took #{$lx_dump_time} seconds."
   end
-  $no_dump_time = Time.now - start
-  puts "Nokogiri to_xml #{$iter} times took #{$no_dump_time} seconds."
-  puts ">>> Ox is %0.1f faster than Nokkgiri to_xml.\n\n" % [$no_dump_time/$ox_dump_time]
+  puts "\n"
+  puts ">>> Ox is %0.1f faster than Nokkgiri to_xml." % [$no_dump_time/$ox_dump_time] unless defined?(::Nokogiri).nil?
+  puts ">>> Ox is %0.1f faster than LibXML to_xml." % [$lx_dump_time/$ox_dump_time] unless defined?(::LibXML).nil?
+  puts "\n"
 end
 
 def perf_read(d)
@@ -137,7 +179,9 @@ def perf_read(d)
   ox_read_time = Time.now - start
   puts "Loading and parsing #{$iter} times with ox took #{ox_read_time} seconds."
 
-  if !$ox_only
+  return if $ox_only
+
+  unless defined?(::Nokogiri).nil?
     start = Time.now
     (1..$iter).each do
       xml = File.read(filename)
@@ -146,7 +190,6 @@ def perf_read(d)
     no_read_time = Time.now - start
     puts "Reading and parsing #{$iter} times took #{no_read_time} seconds."
     puts ">>> Ox is %0.1f faster than Nokogiri loading and parsing.\n\n" % [no_read_time/ox_read_time]
-
   end
 end
 
@@ -164,7 +207,9 @@ def perf_write(d)
   ox_write_time = Time.now - start
   puts "Ox dumping #{$iter} times with ox took #{ox_write_time} seconds."
 
-  if !$ox_only
+  return if $ox_only
+
+  unless defined?(::Nokogiri).nil?
     obj = d[:nokogiri]
     start = Time.now
     (1..$iter).each do
@@ -174,7 +219,6 @@ def perf_write(d)
     no_write_time = Time.now - start
     puts "Nokogiri dumping and writing #{$iter} times took #{no_write_time} seconds."
     puts ">>> Ox is %0.1f faster than Nokogiri writing.\n\n" % [no_write_time/ox_write_time]
-
   end
 end
 

data/test/perf_sax.rb

@@ -77,26 +77,27 @@ def create_file(filename, size)
 end
 
 class OxSax < ::Ox::Sax
-  def start_element(name, attrs); end
   def error(message, line, column); puts message; end
 end
 
 class OxAllSax < OxSax
-  def end_element(name);  end
-  def instruct(target, attrs); end
+  def start_element(name); end
+  def attr(name, value); end
+  def end_element(name); end
+  def text(value); end
+  def instruct(target); end
   def doctype(value); end
   def comment(value); end
   def cdata(value); end
-  def text(value); end
 end
 
 unless defined?(::Nokogiri).nil?
   class NoSax < Nokogiri::XML::SAX::Document
-    def start_element(name, attrs = []); end
     def error(message); puts message; end
     def warning(message); puts message; end
   end
   class NoAllSax < NoSax
+    def start_element(name, attrs = []); end
     def characters(text); end
     def cdata_block(string); end
     def comment(string); end
@@ -110,9 +111,9 @@ end
 unless defined?(::LibXML).nil?
   class LxSax
     include LibXML::XML::SaxParser::Callbacks
-    def on_start_element(element, attributes); end
   end
   class LxAllSax < LxSax
+    def on_start_element(element, attributes); end
     def on_cdata_block(cdata); end
     def on_characters(chars); end
     def on_comment(msg); end
@@ -178,7 +179,7 @@ end
 
 def perf_fileio()
   puts "\n"
-  puts "A #{$filesize} KByte XML file was parsed #{$iter} for this test."
+  puts "A #{$filesize} KByte XML file was parsed #{$iter} times for this test."
   puts "\n"
   start = Time.now
   handler = $all_cbs ? OxAllSax.new() : OxSax.new()

data/test/sax_test.rb

@@ -27,8 +27,12 @@ class StartSax < ::Ox::Sax
     @calls = []
   end
 
-  def start_element(name, attrs)
-    @calls << [:start_element, name, attrs]
+  def start_element(name)
+    @calls << [:start_element, name]
+  end
+
+  def attr(name, value)
+    @calls << [:attr, name, value]
   end
 end
 
@@ -37,8 +41,8 @@ class AllSax < StartSax
     super
   end
 
-  def instruct(target, attrs)
-    @calls << [:instruct, target, attrs]
+  def instruct(target)
+    @calls << [:instruct, target]
   end
 
   def doctype(value)
@@ -75,7 +79,7 @@ class Func < ::Test::Unit::TestCase
     w.close
     Ox.sax_parse(handler, input)
     assert_equal(handler.calls,
-                 [[:start_element, :top, nil],
+                 [[:start_element, :top],
                   [:end_element, :top]])
   end
 
@@ -84,7 +88,7 @@ class Func < ::Test::Unit::TestCase
     input = IO.open(IO.sysopen('basic.xml'))
     Ox.sax_parse(handler, input)
     assert_equal(handler.calls,
-                 [[:start_element, :top, nil],
+                 [[:start_element, :top],
                   [:end_element, :top]])
   end
 
@@ -96,7 +100,7 @@ class Func < ::Test::Unit::TestCase
   end
   
   def test_sax_instruct_simple
-    parse_compare(%{<?xml?>}, [[:instruct, 'xml', nil]])
+    parse_compare(%{<?xml?>}, [[:instruct, 'xml']])
   end
 
   def test_sax_instruct_blank
@@ -105,34 +109,40 @@ class Func < ::Test::Unit::TestCase
 
   def test_sax_instruct_attrs
     parse_compare(%{<?xml version="1.0" encoding="UTF-8"?>},
-                  [[:instruct, 'xml', {:version => '1.0', :encoding => 'UTF-8'}]])
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:attr, :encoding, "UTF-8"]])
   end
 
   def test_sax_instruct_loose
     parse_compare(%{<? xml
 version = "1.0"
 encoding = "UTF-8" ?>},
-                  [[:instruct, 'xml', {:version => '1.0', :encoding => 'UTF-8'}]])
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:attr, :encoding, "UTF-8"]])
   end
 
   def test_sax_element_simple
     parse_compare(%{<top/>},
-                  [[:start_element, :top, nil],
+                  [[:start_element, :top],
                    [:end_element, :top]])
   end
 
   def test_sax_element_attrs
     parse_compare(%{<top x="57" y="42"/>}, 
-                  [[:start_element, :top, {:x => '57', :y => '42'}],
+                  [[:start_element, :top],
+                   [:attr, :x, "57"],
+                   [:attr, :y, "42"],
                    [:end_element, :top]])
   end
 
   def test_sax_two_top
     parse_compare(%{<top/><top/>},
-                  [[:start_element, :top, nil],
+                  [[:start_element, :top],
                    [:end_element, :top],
                    [:error, "invalid format, multiple top level elements", 1, 9],
-                   [:start_element, :top, nil],
+                   [:start_element, :top],
                    [:end_element, :top]])
 
 
@@ -146,10 +156,11 @@ encoding = "UTF-8" ?>},
   </child>
 </top>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
-                   [:start_element, :child, nil],
-                   [:start_element, :grandchild, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
+                   [:start_element, :child],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
                    [:end_element, :child],
                    [:end_element, :top],
@@ -158,10 +169,11 @@ encoding = "UTF-8" ?>},
 
   def test_sax_nested1_tight
     parse_compare(%{<?xml version="1.0"?><top><child><grandchild/></child></top>},
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
-                   [:start_element, :child, nil],
-                   [:start_element, :grandchild, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
+                   [:start_element, :child],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
                    [:end_element, :child],
                    [:end_element, :top],
@@ -175,10 +187,11 @@ encoding = "UTF-8" ?>},
     <grandchild/>
   </parent>
 </top>},
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
-                   [:start_element, :child, nil],
-                   [:start_element, :grandchild, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
+                   [:start_element, :child],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
                    [:error, "invalid format, element start and end names do not match", 5, 12]
                   ])
@@ -196,16 +209,17 @@ encoding = "UTF-8" ?>},
   </child>
 </top>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
-                   [:start_element, :child, nil],
-                   [:start_element, :grandchild, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
+                   [:start_element, :child],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
                    [:end_element, :child],
-                   [:start_element, :child, nil],
-                   [:start_element, :grandchild, nil],
+                   [:start_element, :child],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
-                   [:start_element, :grandchild, nil],
+                   [:start_element, :grandchild],
                    [:end_element, :grandchild],
                    [:end_element, :child],
                    [:end_element, :top],
@@ -216,8 +230,8 @@ encoding = "UTF-8" ?>},
 <top>
   <child/>
 },
-                  [[:start_element, :top, nil],
-                   [:start_element, :child, nil],
+                  [[:start_element, :top],
+                   [:start_element, :child],
                    [:end_element, :child],
                    [:error, "invalid format, element not terminated", 4, 1]
                   ])
@@ -225,7 +239,7 @@ encoding = "UTF-8" ?>},
 
   def test_sax_text
     parse_compare(%{<top>This is some text.</top>},
-                  [[:start_element, :top, nil],
+                  [[:start_element, :top],
                    [:text, "This is some text."],
                    [:end_element, :top]
                   ])
@@ -233,7 +247,7 @@ encoding = "UTF-8" ?>},
 
   def test_sax_text_no_term
     parse_compare(%{<top>This is some text.},
-                  [[:start_element, :top, nil],
+                  [[:start_element, :top],
                    [:error, "invalid format, text terminated unexpectedly", 1, 24],
                   ])
   end
@@ -244,9 +258,10 @@ encoding = "UTF-8" ?>},
 <!DOCTYPE top PUBLIC "top.dtd">
 <top/>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
                    [:doctype, ' top PUBLIC "top.dtd"'],
-                   [:start_element, :top, nil],
+                   [:start_element, :top],
                    [:end_element, :top]])
   end
 
@@ -255,8 +270,9 @@ encoding = "UTF-8" ?>},
 <top/>
 <!DOCTYPE top PUBLIC "top.dtd">
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
                    [:end_element, :top],
                    [:error, "invalid format, DOCTYPE can not come after an element", 3, 11],
                    [:doctype, ' top PUBLIC "top.dtd"']])
@@ -270,8 +286,9 @@ encoding = "UTF-8" ?>},
 },
                   [[:doctype, " top PUBLIC \"top.dtd\""],
                    [:error, "invalid format, instruction must come before elements", 3, 3],
-                   [:instruct, "xml", {:version => "1.0"}],
-                   [:start_element, :top, nil],
+                   [:instruct, "xml"],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
                    [:end_element, :top]])
   end
   
@@ -280,9 +297,10 @@ encoding = "UTF-8" ?>},
 <!--First comment.-->
 <top>Before<!--Nested comment.-->After</top>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
                    [:comment, 'First comment.'],
-                   [:start_element, :top, nil],
+                   [:start_element, :top],
                    [:text, 'Before'],
                    [:comment, 'Nested comment.'],
                    [:text, 'After'],
@@ -294,10 +312,11 @@ encoding = "UTF-8" ?>},
 <!--First comment.--
 <top/>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
                    [:error, "invalid format, comment terminated unexpectedly", 3, 1], # continue on
                    [:comment, 'First comment.'],
-                   [:start_element, :top, nil],
+                   [:start_element, :top],
                    [:end_element, :top]])
   end
 
@@ -307,8 +326,9 @@ encoding = "UTF-8" ?>},
   <![CDATA[This is CDATA.]]>
 </top>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
                    [:cdata, 'This is CDATA.'],
                    [:end_element, :top]])
   end
@@ -319,8 +339,9 @@ encoding = "UTF-8" ?>},
   <![CDATA[This is CDATA.]]
 </top>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:start_element, :top, nil],
+                  [[:instruct, 'xml'],
+                   [:attr, :version, "1.0"],
+                   [:start_element, :top],
                    [:error, "invalid format, cdata terminated unexpectedly", 5, 1]])
   end
   
@@ -340,27 +361,45 @@ encoding = "UTF-8" ?>},
   </row>
 </table>
 },
-                  [[:instruct, 'xml', {:version => '1.0'}],
-                   [:instruct, "ox", {:version=>"1.0", :mode=>"object", :circular=>"no", :xsd_date=>"no"}],
+                  [[:instruct, "xml"],
+                   [:attr, :version, "1.0"],
+                   [:instruct, "ox"],
+                   [:attr, :version, "1.0"],
+                   [:attr, :mode, "object"],
+                   [:attr, :circular, "no"],
+                   [:attr, :xsd_date, "no"],
                    [:doctype, " table PUBLIC \"-//ox//DTD TABLE 1.0//EN\" \"http://www.ohler.com/DTDs/TestTable-1.0.dtd\""],
-                   [:start_element, :table, nil],
-                   [:start_element, :row, {:id=>"00004"}],
-                   [:start_element, :cell, {:id=>"A", :type=>"Fixnum"}],
+                   [:start_element, :table],
+                   [:start_element, :row],
+                   [:attr, :id, "00004"],
+                   [:start_element, :cell],
+                   [:attr, :id, "A"],
+                   [:attr, :type, "Fixnum"],
                    [:text, "1234"],
                    [:end_element, :cell],
-                   [:start_element, :cell, {:id=>"B", :type=>"String"}],
+                   [:start_element, :cell],
+                   [:attr, :id, "B"],
+                   [:attr, :type, "String"],
                    [:text, "A string."],
                    [:end_element, :cell],
-                   [:start_element, :cell, {:id=>"C", :type=>"String"}],
+                   [:start_element, :cell],
+                   [:attr, :id, "C"],
+                   [:attr, :type, "String"],
                    [:text, "This is a longer string that stretches over a larger number of characters."],
                    [:end_element, :cell],
-                   [:start_element, :cell, {:id=>"D", :type=>"Float"}],
+                   [:start_element, :cell],
+                   [:attr, :id, "D"],
+                   [:attr, :type, "Float"],
                    [:text, "-12.345"],
                    [:end_element, :cell],
-                   [:start_element, :cell, {:id=>"E", :type=>"Date"}],
+                   [:start_element, :cell],
+                   [:attr, :id, "E"],
+                   [:attr, :type, "Date"],
                    [:text, "2011-09-18 23:07:26 +0900"],
                    [:end_element, :cell],
-                   [:start_element, :cell, {:id=>"F", :type=>"Image"}],
+                   [:start_element, :cell],
+                   [:attr, :id, "F"],
+                   [:attr, :type, "Image"],
                    [:cdata, "xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00xx00"],
                    [:end_element, :cell],
                    [:end_element, :row],
@@ -371,8 +410,10 @@ encoding = "UTF-8" ?>},
     parse_compare(%{<?xml version="1.0" encoding="UTF-8"?>
 <top>ピーター</top>
 },
-                  [[:instruct, 'xml', {:version => '1.0', :encoding => 'UTF-8'}],
-                   [:start_element, :top, nil],
+                  [[:instruct, "xml"],
+                   [:attr, :version, "1.0"],
+                   [:attr, :encoding, "UTF-8"],
+                   [:start_element, :top],
                    [:text, 'ピーター'],
                    [:end_element, :top]])
   end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 1
-  version: 1.3.1
+  - 2
+  version: 1.3.2
 platform: ruby
 authors: 
 - Peter Ohler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-19 00:00:00 +09:00
+date: 2011-09-21 00:00:00 +09:00
 default_executable: 
 dependencies: []