ox 1.3.3 → 1.3.4

data/README.md

@@ -26,12 +26,9 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.3.3
-
- - Added an option to the SAX parser to convert special characters.
-
- - The default options encoding is now used as the default for SAX parsing.
+### Release 1.3.4
 
+ - Made Ox SAX compatible with Ruby 1.8.7 when readpartial is not implemented on IO.
 
 ## <a name="description">Description</a>
 

data/ext/ox/ox.c

@@ -64,6 +64,7 @@ ID      local_id;
 ID      nodes_id;
 ID      num_id;
 ID      parse_id;
+ID      read_id;
 ID      readpartial_id;
 ID      start_element_id;
 ID      text_id;
@@ -652,6 +653,7 @@ void Init_ox() {
     num_id = rb_intern("@num");
     parse_id = rb_intern("parse");
     readpartial_id = rb_intern("readpartial");
+    read_id = rb_intern("read");
     start_element_id = rb_intern("start_element");
     text_id = rb_intern("text");
     to_c_id = rb_intern("to_c");

data/ext/ox/ox.h

@@ -226,6 +226,7 @@ extern ID       local_id;
 extern ID       nodes_id;
 extern ID       num_id;
 extern ID       parse_id;
+extern ID       read_id;
 extern ID       readpartial_id;
 extern ID       start_element_id;
 extern ID       text_id;

data/ext/ox/sax.c

@@ -88,8 +88,10 @@ static int      read_quoted_value(SaxDrive dr);
 static int      collapse_special(char *str);
 
 static VALUE    io_cb(VALUE rdr);
+static VALUE    partial_io_cb(VALUE rdr);
 static int      read_from_io(SaxDrive dr);
 static int      read_from_fd(SaxDrive dr);
+static int      read_from_io_partial(SaxDrive dr);
 
 static inline char
 sax_drive_get(SaxDrive dr) {
@@ -183,6 +185,16 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
     if (rb_respond_to(io, readpartial_id)) {
         VALUE   rfd;
 
+        if (rb_respond_to(io, rb_intern("fileno")) && Qnil != (rfd = rb_funcall(io, rb_intern("fileno"), 0))) {
+            dr->read_func = read_from_fd;
+            dr->fd = FIX2INT(rfd);
+        } else {
+            dr->read_func = read_from_io_partial;
+            dr->io = io;
+        }
+    } else if (rb_respond_to(io, read_id)) {
+        VALUE   rfd;
+
         if (rb_respond_to(io, rb_intern("fileno")) && Qnil != (rfd = rb_funcall(io, rb_intern("fileno"), 0))) {
             dr->read_func = read_from_fd;
             dr->fd = FIX2INT(rfd);
@@ -191,7 +203,7 @@ sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, int convert) {
             dr->io = io;
         }
     } else {
-        rb_raise(rb_eArgError, "sax_parser io argument must respond to readpartial().\n");
+        rb_raise(rb_eArgError, "sax_parser io argument must respond to readpartial() or read().\n");
     }
     dr->buf = dr->base_buf;
     *dr->buf = '\0';
@@ -730,6 +742,35 @@ read_quoted_value(SaxDrive dr) {
     return 0;
 }
 
+static int
+read_from_io_partial(SaxDrive dr) {
+    int ex = 0;
+
+    rb_protect(partial_io_cb, (VALUE)dr, &ex);
+    // printf("*** io_cb exception = %d\n", ex);
+    // An error code of 6 is always returned not matter what kind of Exception is raised.
+    return ex;
+}
+
+static VALUE
+partial_io_cb(VALUE rdr) {
+    SaxDrive    dr = (SaxDrive)rdr;
+    VALUE       args[1];
+    VALUE       rstr;
+    char        *str;
+    size_t      cnt;
+
+    args[0] = ULONG2NUM(dr->buf_end - dr->cur);
+    rstr = rb_funcall2(dr->io, readpartial_id, 1, args);
+    str = StringValuePtr(rstr);
+    cnt = strlen(str);
+    //printf("*** read %lu bytes, str: '%s'\n", cnt, str);
+    strcpy(dr->cur, str);
+    dr->read_end = dr->cur + cnt;
+
+    return Qnil;
+}
+
 static int
 read_from_io(SaxDrive dr) {
     int ex = 0;
@@ -748,8 +789,9 @@ io_cb(VALUE rdr) {
     char        *str;
     size_t      cnt;
 
-    args[0] = SIZET2NUM(dr->buf_end - dr->cur);
-    rstr = rb_funcall2(dr->io, readpartial_id, 1, args);
+    args[0] = ULONG2NUM(dr->buf_end - dr->cur);
+    //args[0] = SIZET2NUM(dr->buf_end - dr->cur);
+    rstr = rb_funcall2(dr->io, read_id, 1, args);
     str = StringValuePtr(rstr);
     cnt = strlen(str);
     //printf("*** read %lu bytes, str: '%s'\n", cnt, str);

data/lib/ox/version.rb

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

data/test/func.rb

@@ -1,15 +1,8 @@
 #!/usr/bin/env ruby -wW1
 # encoding: UTF-8
 
-$: << '../lib'
-$: << '../ext'
-
-if __FILE__ == $0
-  while (i = ARGV.index('-I'))
-    x,path = ARGV.slice!(i, 2)
-    $: << path
-  end
-end
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
 require 'optparse'
@@ -338,22 +331,26 @@ class Func < ::Test::Unit::TestCase
       "x".foo
     rescue Exception => e
       xml = Ox.dump(e, :effort => :tolerant)
-      o = Ox.load(xml, mode: :object)
+      o = Ox.load(xml, :mode => :object)
       xml2 = Ox.dump(o, :effort => :tolerant)
       assert_equal(xml, xml2)
     end
   end
   
   def test_mutex
-    # Mutex can not be serialize but it should not raise an exception.
-    xml = Ox.dump(Mutex.new, :indent => 2, :effort => :tolerant)
-    assert_equal(%{<z/>
+    if defined?(Mutex)
+      # Mutex can not be serialize but it should not raise an exception.
+      xml = Ox.dump(Mutex.new, :indent => 2, :effort => :tolerant)
+      assert_equal(%{<z/>
 }, xml)
-    xml = Ox.dump(Bag.new(:@x => Mutex.new), :indent => 2, :effort => :tolerant)
-    assert_equal(%{<o c="Bag">
+      xml = Ox.dump(Bag.new(:@x => Mutex.new), :indent => 2, :effort => :tolerant)
+      assert_equal(%{<o c="Bag">
   <z a="@x"/>
 </o>
 }, xml)
+    else
+      assert(true)
+    end
   end
   
   def test_encoding

data/test/parse_cmp.rb

@@ -0,0 +1,261 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+require 'optparse'
+require 'stringio'
+require 'ox'
+
+$verbose = 0
+$iter = 100
+
+opts = OptionParser.new
+opts.on("-v", "increase verbosity")                            { $verbose += 1 }
+opts.on("-i", "--iterations [Int]", Integer, "iterations")     { |i| $iter = i }
+opts.on("-h", "--help", "Show this display")                   { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+### XML conversion to Hash using in memory Ox parsing ###
+
+def node_to_dict(element)
+  dict = Hash.new
+  key = nil
+  element.nodes.each do |n|
+    raise "A dict can only contain elements." unless n.is_a?(::Ox::Element)
+    if key.nil?
+      raise "Expected a key, not a #{n.name}." unless 'key' == n.name
+      key = first_text(n)
+    else
+      dict[key] = node_to_value(n)
+      key = nil
+    end
+  end
+  dict
+end
+
+def node_to_array(element)
+  a = Array.new
+  element.nodes.each do |n|
+    a.push(node_to_value(n))
+  end
+  a
+end
+
+def node_to_value(node)
+  raise "A dict can only contain elements." unless node.is_a?(::Ox::Element)
+  case node.name
+  when 'key'
+    raise "Expected a value, not a key."
+  when 'string'
+    value = first_text(node)
+  when 'dict'
+    value = node_to_dict(node)
+  when 'array'
+    value = node_to_array(node)
+  when 'integer'
+    value = first_text(node).to_i
+  when 'real'
+    value = first_text(node).to_f
+  when 'true'
+    value = true
+  when 'false'
+    value = false
+  else
+    raise "#{node.name} is not a know element type."
+  end
+  value
+end
+
+def first_text(node)
+  node.nodes.each do |n|
+    return n if n.is_a?(String)
+  end
+  nil
+end
+
+def parse_gen(xml)
+  doc = Ox.parse(xml)
+  plist = doc.root
+  dict = nil
+  plist.nodes.each do |n|
+    if n.is_a?(::Ox::Element)
+      dict = node_to_dict(n)
+      break
+    end
+  end
+  dict
+end
+
+### XML conversion to Hash using Ox SAX parser ###
+
+class Handler
+  def initialize()
+    @key = nil
+    @type = nil
+    @plist = nil
+    @stack = []
+  end
+
+  def text(value)
+    last = @stack.last
+    if last.is_a?(Hash) and @key.nil?
+      raise "Expected a key, not #{@type} with a value of #{value}." unless :key == @type
+      @key = value
+    else
+      append(value)
+    end
+  end
+
+  def start_element(name)
+    if :dict == name
+      dict = Hash.new
+      append(dict)
+      @stack.push(dict)
+    elsif :array == name
+      a = Array.new
+      append(a)
+      @stack.push(a)
+    elsif :true == name
+      append(true)
+    elsif :false == name
+      append(false)
+    else
+      @type = name
+    end
+  end
+
+  def end_element(name)
+    @stack.pop if :dict == name or :array == name
+  end
+  
+  def plist
+    @plist
+  end
+
+  def append(value)
+    unless value.is_a?(Array) or value.is_a?(Hash)
+      case @type
+      when :string
+        # ignore
+      when :key
+        # ignore
+      when :integer
+        value = value.to_i
+      when :real
+        value = value.to_f
+      end
+    end
+    last = @stack.last
+    if last.is_a?(Hash)
+      raise "Expected a key, not with a value of #{value}." if @key.nil?
+      last[@key] = value
+      @key = nil
+    elsif last.is_a?(Array)
+      last.push(value)
+    elsif last.nil?
+      @plist = value
+    end
+  end
+
+end
+
+def parse_sax(xml)
+  io = StringIO.new(xml)
+  start = Time.now
+  handler = Handler.new()
+  Ox.sax_parse(handler, io)
+  handler.plist
+end
+
+### XML conversion to Hash using Ox Object parsing with gsub! replacements ###
+
+def convert_parse_obj(xml)
+  xml = plist_to_obj_xml(xml)
+  ::Ox.load(xml, :mode => :object)
+end
+
+### XML conversion to Hash using Ox Object parsing after gsub! replacements ###
+
+def parse_obj(xml)
+  ::Ox.load(xml, :mode => :object)
+end
+
+def plist_to_obj_xml(xml)
+  xml = xml.gsub(%{<plist version="1.0">
+}, '')
+  xml.gsub!(%{
+</plist>}, '')
+  { '<dict>' => '<h>',
+    '</dict>' => '</h>',
+    '<dict/>' => '<h/>',
+    '<array>' => '<a>',
+    '</array>' => '</a>',
+    '<array/>' => '<a/>',
+    '<string>' => '<s>',
+    '</string>' => '</s>',
+    '<string/>' => '<s/>',
+    '<key>' => '<s>',
+    '</key>' => '</s>',
+    '<integer>' => '<i>',
+    '</integer>' => '</i>',
+    '<integer/>' => '<i/>',
+    '<real>' => '<f>',
+    '</real>' => '</f>',
+    '<real/>' => '<f/>',
+    '<true/>' => '<y/>',
+    '<false/>' => '<n/>',
+  }.each do |pat,rep|
+    xml.gsub!(pat, rep)
+  end
+  xml
+end
+
+files.each do |filename|
+  xml = File.read(filename)
+
+  if 0 < $verbose
+    d1 = parse_gen(xml)
+    d2 = parse_sax(xml)
+    d3 = convert_parse_obj(xml)
+    puts "--- It is #{d1 == d2 and d2 == d3} that all parsers yield the same Hash. ---"
+  end
+
+  start = Time.now
+  $iter.times do
+    parse_gen(xml)
+  end
+  gen_time = Time.now - start
+  
+  start = Time.now
+  $iter.times do
+    parse_sax(xml)
+  end
+  sax_time = Time.now - start
+
+  start = Time.now
+  $iter.times do
+    convert_parse_obj(xml)
+  end
+  conv_obj_time = Time.now - start
+
+  xml = plist_to_obj_xml(xml)
+  start = Time.now
+  $iter.times do
+    parse_obj(xml)
+  end
+  obj_time = Time.now - start
+
+  puts "In memory parsing and conversion took #{gen_time} for #{$iter} iterations."
+  puts "SAX parsing and conversion took #{sax_time} for #{$iter} iterations."
+  puts "XML gsub Object parsing and conversion took #{conv_obj_time} for #{$iter} iterations."
+  puts "Object parsing and conversion took #{obj_time} for #{$iter} iterations."
+end
+
+# Results for a run:
+#
+# > parse_cmp.rb Sample.graffle -i 1000
+# In memory parsing and conversion took 4.135701 for 1000 iterations.
+# SAX parsing and conversion took 3.731695 for 1000 iterations.
+# XML gsub Object parsing and conversion took 3.292397 for 1000 iterations.
+# Object parsing and conversion took 0.808877 for 1000 iterations.

data/test/sax_test.rb

@@ -1,15 +1,8 @@
 #!/usr/bin/env ruby -wW1
 # encoding: UTF-8
 
-$: << '../lib'
-$: << '../ext'
-
-if __FILE__ == $0
-  while (i = ARGV.index('-I'))
-    x,path = ARGV.slice!(i, 2)
-    $: << path
-  end
-end
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'stringio'
 require 'test/unit'
@@ -85,7 +78,7 @@ class Func < ::Test::Unit::TestCase
 
   def test_sax_io_file
     handler = AllSax.new()
-    input = IO.open(IO.sysopen('basic.xml'))
+    input = IO.open(IO.sysopen(File.join(File.dirname(__FILE__), 'basic.xml')))
     Ox.sax_parse(handler, input)
     assert_equal(handler.calls,
                  [[:start_element, :top],
@@ -420,16 +413,19 @@ encoding = "UTF-8" ?>},
   end
 
   def test_sax_encoding
-    parse_compare(%{<?xml version="1.0" encoding="UTF-8"?>
+    if RUBY_VERSION.start_with?('1.8')
+      assert(true)
+    else
+      parse_compare(%{<?xml version="1.0" encoding="UTF-8"?>
 <top>ピーター</top>
 },
-                  [[:instruct, "xml"],
-                   [:attr, :version, "1.0"],
-                   [:attr, :encoding, "UTF-8"],
-                   [:start_element, :top],
-                   [:text, 'ピーター'],
-                   [:end_element, :top]])
+                    [[:instruct, "xml"],
+                     [:attr, :version, "1.0"],
+                     [:attr, :encoding, "UTF-8"],
+                     [:start_element, :top],
+                     [:text, 'ピーター'],
+                     [:end_element, :top]])
+    end
   end
 
 end
-

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 3
-  version: 1.3.3
+  - 4
+  version: 1.3.4
 platform: ruby
 authors: 
 - Peter Ohler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-24 00:00:00 +09:00
+date: 2011-09-26 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -75,6 +75,7 @@ files:
 - test/ox/rect.rb
 - test/ox/shape.rb
 - test/ox/text.rb
+- test/parse_cmp.rb
 - test/perf_gen.rb
 - test/perf_mars.rb
 - test/perf_obj.rb