ox 1.5.4 → 1.5.5

data/test/perf.rb

@@ -1,91 +0,0 @@
-
-class Perf
-
-  def initialize()
-    @items = []
-  end
-
-  def add(title, op, &blk)
-    @items << Item.new(title, op, &blk)
-  end
-
-  def run(iter)
-    base = Item.new(nil, nil) { }
-    base.run(iter, 0.0)
-    @items.each do |i|
-      i.run(iter, base.duration)
-      if i.error.nil?
-        puts "#{i.title}.#{i.op} #{iter} times in %0.3f seconds or %0.3f #{i.op}/sec." % [i.duration, iter / i.duration]
-      else
-        puts "***** #{i.title}.#{i.op} failed! #{i.error}"
-      end
-    end
-    summary()
-  end
-
-  def summary()
-    fastest = nil
-    slowest = nil
-    width = 6
-    @items.each do |i|
-      next if i.duration.nil?
-      width = i.title.size if width < i.title.size
-    end
-    iva = @items.clone
-    iva.delete_if { |i| i.duration.nil? }
-    iva.sort_by! { |i| i.duration }
-    puts
-    puts "Summary:"
-    puts "%*s  time (secs)  rate (ops/sec)" % [width, 'System']
-    puts "#{'-' * width}  -----------  --------------"
-    iva.each do |i|
-      if i.duration.nil?
-      else
-        puts "%*s %11.3f  %14.3f" % [width, i.title, i.duration, i.rate ]
-      end
-    end
-    puts
-    puts "Comparison Matrix\n(performance factor, 2.0 means row is twice as fast as column)"
-    puts ([' ' * width] + iva.map { |i| "%*s" % [width, i.title] }).join('  ')
-    puts (['-' * width] + iva.map { |i| '-' * width }).join('  ')
-    iva.each do |i|
-      line = ["%*s" % [width, i.title]]
-      iva.each do |o|
-        line << "%*.2f" % [width, o.duration / i.duration]
-      end
-      puts line.join('  ')
-    end
-    puts
-  end
-
-  class Item
-    attr_accessor :title
-    attr_accessor :op
-    attr_accessor :blk
-    attr_accessor :duration
-    attr_accessor :rate
-    attr_accessor :error
-
-    def initialize(title, op, &blk)
-      @title = title
-      @blk = blk
-      @op = op
-      @duration = nil
-      @rate = nil
-      @error = nil
-    end
-
-    def run(iter, base)
-      begin
-        start = Time.now
-        iter.times { @blk.call }
-        @duration = Time.now - start - base
-        @duration = 0.0 if @duration < 0.0
-        @rate = iter / @duration
-      rescue Exception => e
-        @error = "#{e.class}: #{e.message}"
-      end
-    end
-
-  end # Item
-end # Perf

data/test/perf_gen.rb

@@ -1,237 +0,0 @@
-#!/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'
-begin
-  require 'nokogiri'
-rescue Exception => e
-end
-begin
-  require 'libxml'
-rescue Exception => e
-end
-
-$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)
-  File.open('sample.xml', 'w') { |f| f.write(xml) }
-  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)
-    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]
-
-  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
-  
-  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
-  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)
-  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
-
-  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
-  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)
-  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."
-
-  return if $ox_only
-
-  unless defined?(::Nokogiri).nil?
-    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."
-
-  return if $ox_only
-
-  unless defined?(::Nokogiri).nil?
-    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

@@ -1,114 +0,0 @@
-#!/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 "           load                        dump"
-puts "type       Ox      Marshal  ratio      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_load_time = Time.now - start
-  
-  m = Marshal.dump(a)
-  start = Time.now
-  (1..it).each do
-    obj = Marshal.load(m)
-  end
-  mars_load_time = Time.now - start
-
-  obj = Ox.load(xml, :mode => :object)
-  start = Time.now
-  (1..it).each do
-    xml = Ox.dump(a, :indent => -1)
-  end
-  ox_dump_time = Time.now - start
-
-  start = Time.now
-  (1..it).each do
-    m = Marshal.dump(a)
-  end
-  mars_dump_time = Time.now - start
-
-  puts "%8s  %6.3f  %6.3f    %0.1f       %6.3f  %6.3f    %0.1f" % [type.to_s,
-                                       ox_load_time, mars_load_time, mars_load_time / ox_load_time,
-                                       ox_dump_time, mars_dump_time, mars_dump_time / ox_dump_time]
-end

data/test/perf_obj.rb

@@ -1,124 +0,0 @@
-#!/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 'oj'
-require 'perf'
-require 'sample'
-require 'files'
-
-$circular = false
-$indent = 0
-
-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("-c", "circular options")                           { $circular = 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)
-
-$obj = nil
-$xml = nil
-$mars = nil
-$json = nil
-
-unless do_load || do_dump || do_read || do_write
-  do_load = true
-  do_dump = true
-  do_read = true
-  do_write = true
-end
-
-# prepare all the formats for input
-if files.empty?
-  $obj = do_sample ? sample_doc(2) : files('..')
-  $mars = Marshal.dump($obj)
-  $xml = Ox.dump($obj, :indent => $indent, circular: $circular)
-  $json = Oj.dump($obj, :indent => $indent, circular: $circular)
-  File.open('sample.xml', 'w') { |f| f.write($xml) }
-  File.open('sample.json', 'w') { |f| f.write($json) }
-  File.open('sample.marshal', 'w') { |f| f.write($mars) }
-else
-  puts "loading and parsing #{files}\n\n"
-  # TBD change to allow xml and json
-  data = files.map do |f|
-    $xml = File.read(f)
-    $obj = Ox.load($xml);
-    $mars = Marshal.dump($obj)
-    $json = Oj.dump($obj, :indent => $indent, circular: $circular)
-  end
-end
-
-Oj.default_options = { :mode => :object, :indent => $indent }
-
-if do_load
-  puts '-' * 80
-  puts "Load Performance"
-  perf = Perf.new()
-  perf.add('Ox', 'load') { Ox.load($xml, :mode => :object) }
-  perf.add('Oj', 'load') { Oj.load($json) }
-  perf.add('Marshal', 'load') { Marshal.load($mars) }
-  perf.run($iter)
-end
-
-if do_dump
-  puts '-' * 80
-  puts "Dump Performance"
-  perf = Perf.new()
-  perf.add('Ox', 'dump') { Ox.dump($obj, :indent => $indent, :circular => $circular) }
-  perf.add('Oj', 'dump') { Oj.dump($obj) }
-  perf.add('Marshal', 'dump') { Marshal.dump($obj) }
-  perf.run($iter)
-end
-
-if do_read
-  puts '-' * 80
-  puts "Read from file Performance"
-  perf = Perf.new()
-  perf.add('Ox', 'load_file') { Ox.load_file('sample.xml', :mode => :object) }
-  perf.add('Oj', 'load') { Oj.load_file('sample.json') }
-  perf.add('Marshal', 'load') { Marshal.load(File.new('sample.marshal')) }
-  perf.run($iter)
-end
-
-if do_write
-  puts '-' * 80
-  puts "Write to file Performance"
-  perf = Perf.new()
-  perf.add('Ox', 'to_file') { Ox.to_file('sample.xml', $obj, :indent => $indent, :circular => $circular) }
-  perf.add('Oj', 'to_file') { Oj.to_file('sample.json', $obj) }
-  perf.add('Marshal', 'dump') { Marshal.dump($obj, File.new('sample.marshal', 'w')) }
-  perf.run($iter)
-end
-
-