ox 1.0.0

data/test/ox/file.rb

@@ -0,0 +1,33 @@
+
+require 'etc'
+
+module Test
+  module Ox
+
+    class File
+      attr_accessor :name, :ctime, :mtime, :size, :owner, :group, :permissions
+
+      def initialize(filename)
+        @name = ::File.basename(filename)
+        stat = ::File.stat(filename)
+        @ctime = stat.ctime
+        @mtime = stat.mtime
+        @size = stat.size
+        @owner = Etc.getpwuid(stat.uid).name
+        @group = Etc.getgrgid(stat.gid).name
+        @permissions = {
+          :user => [(0 != (stat.mode & 0x0100)) ? 'r' : '-',
+                    (0 != (stat.mode & 0x0080)) ? 'w' : '-',
+                    (0 != (stat.mode & 0x0040)) ? 'x' : '-'].join(''),
+          :group => [(0 != (stat.mode & 0x0020)) ? 'r' : '-',
+                     (0 != (stat.mode & 0x0010)) ? 'w' : '-',
+                     (0 != (stat.mode & 0x0008)) ? 'x' : '-'].join(''),
+          :other => [(0 != (stat.mode & 0x0004)) ? 'r' : '-',
+                     (0 != (stat.mode & 0x0002)) ? 'w' : '-',
+                     (0 != (stat.mode & 0x0001)) ? 'x' : '-'].join('')
+        }
+      end
+
+    end # File
+  end # Ox
+end # Test

data/test/ox/group.rb

@@ -0,0 +1,18 @@
+
+module Test
+  module Ox
+    class Group
+      attr_reader :members
+      
+      def initialize()
+        @members = []
+      end
+      
+      def <<(member)
+        @members << member
+      end
+
+    end # Group
+  end # Ox
+end # Test
+    

data/test/ox/hasprops.rb

@@ -0,0 +1,18 @@
+
+module Test
+  module Ox
+    module HasProps
+
+      def add_prop(key, value)
+        @props = { } unless self.instance_variable_defined?(:@props)
+        @props[key] = value
+      end
+
+      def props
+        @props = { } unless self.instance_variable_defined?(:@props)
+        @props
+      end
+      
+    end # HashProps
+  end # Ox
+end # Test

data/test/ox/layer.rb

@@ -0,0 +1,14 @@
+
+module Test
+  module Ox
+    class Layer < Group
+      attr_accessor :name
+
+      def initialize(name)
+        super()
+        @name = name
+      end
+
+    end # Layer
+  end # Ox
+end # Test

data/test/ox/line.rb

@@ -0,0 +1,22 @@
+module Test
+  module Ox
+
+    class Line
+      include HasProps
+
+      attr_accessor :x, :y, :dx, :dy
+      attr_accessor :color
+      attr_accessor :thick
+      
+      def initialize(x, y, dx, dy, thick, color)
+        @x = x
+        @y = y
+        @dx = dx
+        @dy = dy
+        @thick = thick
+        @color = color
+      end
+
+    end # Line
+  end # Ox
+end # Test

data/test/ox/oval.rb

@@ -0,0 +1,12 @@
+module Test
+  module Ox
+
+    class Oval < Shape
+
+      def initialize(left, top, wide, high, color=nil)
+        super
+      end
+
+    end # Oval
+  end # Ox
+end # Test

data/test/ox/rect.rb

@@ -0,0 +1,12 @@
+
+module Test
+  module Ox
+    class Rect < Shape
+
+      def initialize(left, top, wide, high, color=nil)
+        super
+      end
+
+    end # Rect
+  end # Ox
+end # Test

data/test/ox/shape.rb

@@ -0,0 +1,37 @@
+
+module Test
+  module Ox
+    class Shape
+      include HasProps
+
+      attr_accessor :bounds
+      attr_accessor :color
+      attr_accessor :border, :border_color
+
+      def initialize(left, top, wide, high, color=nil)
+        @bounds = [[left, top], [left + wide, top + high]]
+        @color = color
+        @border = 1
+        @border_color = :black
+      end
+      
+      def left
+        @bounds[0][0]
+      end
+      
+      def top
+        @bounds[0][1]
+      end
+      
+      def width
+        @bounds[1][0] - @bounds[0][0]
+      end
+      
+      def height
+        @bounds[1][1] - @bounds[0][1]
+      end
+      
+    end # Shape
+  end # Ox
+end # Test
+

data/test/ox/text.rb

@@ -0,0 +1,23 @@
+
+module Test
+  module Ox
+
+    class Text < Shape
+      attr_accessor :text
+      attr_accessor :font
+      attr_accessor :font_size
+      attr_accessor :just
+      attr_accessor :text_color
+
+      def initialize(text, left, top, wide, high, color=nil)
+        super(left, top, wide, high, color)
+        @text = text
+        @font = 'helvetica'
+        @font_size = 14
+        @just = 'left'
+        @text_color = 'black'
+      end
+
+    end # Text
+  end # Ox
+end # Test

data/test/perf_gen.rb

@@ -0,0 +1,193 @@
+#!/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 'optparse'
+require 'ox'
+require 'sample'
+require 'test/ox/doc'
+require 'files'
+require 'nokogiri'
+
+$verbose = 0
+$ox_only = false
+
+do_sample = false
+do_files = false
+
+do_load = false
+do_dump = false
+do_read = false
+do_write = false
+$iter = 1000
+
+opts = OptionParser.new
+opts.on("-v", "increase verbosity")                         { $verbose += 1 }
+
+opts.on("-x", "ox only")                                    { $ox_only = true }
+
+opts.on("-s", "load and dump as sample Ruby object")        { do_sample = true }
+opts.on("-f", "load and dump as files Ruby object")         { do_files = true }
+
+opts.on("-l", "load")                                       { do_load = true }
+opts.on("-d", "dump")                                       { do_dump = true }
+opts.on("-r", "read")                                       { do_read = true }
+opts.on("-w", "write")                                      { do_write = true }
+opts.on("-a", "load, dump, read and write")                 { do_load = true; do_dump = true; do_read = true; do_write = true }
+
+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)
+
+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 }
+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 }
+  end
+end
+
+$ox_load_time = 0
+$no_load_time = 0
+$ox_dump_time = 0
+$no_dump_time = 0
+
+def perf_load(d)
+  xml = d[:xml]
+
+  if 0 < $verbose
+    obj = Ox.load(xml, :mode => :generic, :trace => $verbose)
+    return
+  end
+  start = Time.now
+  (1..$iter).each do
+    #obj = Ox.load(xml, :mode => :generic)
+    obj = Ox.parse(xml)
+  end
+  $ox_load_time = Time.now - start
+  puts "Parsing #{$iter} times with Ox took #{$ox_load_time} seconds."
+
+  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)
+  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]
+end
+
+def perf_dump(d)
+  obj = d[:ox]
+
+  start = Time.now
+  (1..$iter).each do
+    xml = Ox.dump(obj, :indent => 2)
+    # puts "*** ox:\n#{xml}"
+  end
+  $ox_dump_time = Time.now - start
+  puts "Ox dumping #{$iter} times with ox took #{$ox_dump_time} seconds."
+
+  return if $ox_only
+
+  obj = d[:nokogiri]
+  start = Time.now
+  (1..$iter).each do
+    xml = obj.to_xml(:indent => 0)
+  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]
+end
+
+def perf_read(d)
+  ox_read_time = 0
+
+  filename = d[:file]
+
+  # now load from the file
+  start = Time.now
+  (1..$iter).each do
+    obj = Ox.load_file(filename, :mode => :generic)
+  end
+  ox_read_time = Time.now - start
+  puts "Loading and parsing #{$iter} times with ox took #{ox_read_time} seconds."
+
+  if !$ox_only
+    start = Time.now
+    (1..$iter).each do
+      xml = File.read(filename)
+      obj = Nokogiri::XML::Document.parse(xml)
+    end
+    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
+
+def perf_write(d)
+  ox_write_time = 0
+  
+  filename = 'out.xml'
+  no = 'out.xml'
+  obj = d[:ox]
+
+  start = Time.now
+  (1..$iter).each do
+    xml = Ox.to_file(filename, obj, :indent => 0)
+  end
+  ox_write_time = Time.now - start
+  puts "Ox dumping #{$iter} times with ox took #{ox_write_time} seconds."
+
+  if !$ox_only
+    obj = d[:nokogiri]
+    start = Time.now
+    (1..$iter).each do
+      xml = obj.to_xml(:indent => 0)
+      File.open(filename, "w") { |f| f.write(xml) }
+    end
+    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.each do |d|
+  puts "Using file #{d[:file]}."
+  
+  perf_load(d) if do_load
+  perf_dump(d) if do_dump
+  if do_load and do_dump
+    puts ">>> Ox is %0.1f faster than Nokogiri dumping and loading.\n\n" % [($no_load_time + $no_dump_time)/($ox_load_time + $ox_dump_time)] unless 0 == $no_load_time
+  end
+
+  perf_read(d) if do_read
+  perf_write(d) if do_write
+
+end

data/test/perf_mars.rb

@@ -0,0 +1,97 @@
+#!/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 'optparse'
+require 'pp'
+require 'ox'
+
+it = 5000
+
+opts = OptionParser.new
+opts.on("-i", "--iterations [Int]", Integer, "iterations")    { |i| it = i }
+opts.on("-h", "--help", "Show this display")                  { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+module Test
+  module Ox
+    class Wrap
+      attr_accessor :values
+      def initialize(v=[])
+        @values = v
+      end
+    end
+  end
+end
+
+data = { 
+  :Boolean => ::Test::Ox::Wrap.new(),
+  :Fixnum => ::Test::Ox::Wrap.new(),
+  :Float => ::Test::Ox::Wrap.new(),
+  :String => ::Test::Ox::Wrap.new(),
+  :Symbol => ::Test::Ox::Wrap.new(),
+  :Time => ::Test::Ox::Wrap.new(), 
+  :Array => ::Test::Ox::Wrap.new(), 
+  :Hash => ::Test::Ox::Wrap.new(),
+  :Range => ::Test::Ox::Wrap.new(),
+  :Regexp => ::Test::Ox::Wrap.new(),
+  :Bignum => ::Test::Ox::Wrap.new(),
+  :Complex => ::Test::Ox::Wrap.new(),
+  :Rational => ::Test::Ox::Wrap.new(),
+  :Struct => ::Test::Ox::Wrap.new(),
+  :Class => ::Test::Ox::Wrap.new(),
+  :Object => ::Test::Ox::Wrap.new()
+}
+
+s = Struct.new('Zoo', :x, :y, :z)
+
+(1..200).each do |i|
+  data[:Boolean].values << (0 == (i % 2))
+  data[:Fixnum].values << ((i - 10) * 101)
+  data[:Float].values << ((i.to_f - 10.7) * 30.5)
+  data[:String].values << "String #{i}"
+  data[:Symbol].values << "Symbol#{i}".to_sym
+  data[:Time].values << Time.now + i
+  data[:Array].values << []
+  data[:Hash].values << { }
+  data[:Range].values << (0..7)
+  data[:Regexp].values << /^[0-9]/
+  data[:Bignum].values << (7 ** 55)
+  data[:Complex].values << Complex(1, 2)
+  data[:Rational].values << Rational(1, 3)
+  data[:Struct].values << s.new(1, 3, 5)
+  data[:Class].values << ::Test::Ox::Wrap
+  data[:Object].values << ::Test::Ox::Wrap.new(i)
+end
+
+puts "type      Ox      Marshal  ratio"
+data.each do |type,a|
+  #xml = Ox.dump(a, :indent => -1, :xsd_date => true)
+  xml = Ox.dump(a, :indent => -1)
+  #pp a
+  #puts xml
+  start = Time.now
+  (1..it).each do
+    obj = Ox.load(xml, :mode => :object)
+    #pp obj
+  end
+  ox_time = Time.now - start
+  
+  m = Marshal.dump(a)
+  start = Time.now
+  (1..it).each do
+    obj = Marshal.load(m)
+  end
+  marshal_time = Time.now - start
+  puts "%8s  %6.3f  %6.3f    %0.1f" % [type.to_s, ox_time, marshal_time, marshal_time / ox_time]
+end