RbYAML 0.0.2 → 0.1.0

data/lib/rbyaml/util.rb

@@ -0,0 +1,28 @@
+class Object
+  def __is_str; false end
+  def __is_sym; false end
+  def __is_a; false end
+  def __is_int; false end
+end
+
+class String
+  def __is_str; true end
+end
+
+class Symbol
+  def __is_sym; true end
+end
+
+class Array
+  def __is_a; true end
+end
+
+class Integer
+  def __is_int; true end
+end
+
+class Fixnum
+  def __is_ascii_num
+    self <= ?9 && self >= ?0
+  end
+end

data/lib/rbyaml/yaml.rb

@@ -12,32 +12,32 @@ require 'rbyaml/dumper'
 module RbYAML
   def self._scan(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_token while l.check_token
+    yield l.scanner.get_token while l.scanner.check_token
   end
 
   def self._parse(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_event while l.check_event
+    yield l.parser.get_event while l.parser.check_event
   end
 
   def self._compose(stream, loader=Loader)
     l = loader.new(stream)
-    l.get_node if l.check_node
+    l.composer.get_node if l.composer.check_node
   end
 
   def self._compose_all(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_node while l.check_node
+    yield l.composer.get_node while l.composer.check_node
   end
 
   def self._load_all(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_data while l.check_data
+    yield l.constructor.get_data while l.constructor.check_data
   end
   
   def self._load(stream, loader=Loader)
     l = loader.new(stream)
-    l.get_data if l.check_data
+    l.constructor.get_data if l.constructor.check_data
   end
 
   def self._safe_load_all(stream)
@@ -66,11 +66,11 @@ module RbYAML
       stream = StringIO.new
     end
     dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
-    dumper.open
+    dumper.serializer.open
     for node in nodes
-      dumper.serialize(node)
+      dumper.serializer.serialize(node)
     end
-    dumper.close
+    dumper.serializer.close
     stream.string if StringIO === stream
   end
   
@@ -84,11 +84,11 @@ module RbYAML
       stream = StringIO.new
     end
     dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
-    dumper.open
+    dumper.serializer.open
     for data in documents
-      dumper.represent(data)
+      dumper.representer.represent(data)
     end
-    dumper.close
+    dumper.serializer.close
     stream.string if StringIO === stream
   end
 

data/lib/rbyaml/yaml.rb.~1.2.~

@@ -0,0 +1,136 @@
+require 'stringio'
+
+require 'rbyaml/error'
+
+require 'rbyaml/tokens'
+require 'rbyaml/events'
+require 'rbyaml/nodes'
+
+require 'rbyaml/loader'
+require 'rbyaml/dumper'
+
+module RbYAML
+  def self._scan(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_token while l.check_token
+  end
+
+  def self._parse(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_event while l.check_event
+  end
+
+  def self._compose(stream, loader=Loader)
+    l = loader.new(stream)
+    l.get_node if l.check_node
+  end
+
+  def self._compose_all(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_node while l.check_node
+  end
+
+  def self._load_all(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_data while l.check_data
+  end
+  
+  def self._load(stream, loader=Loader)
+    l = loader.new(stream)
+    l.get_data if l.check_data
+  end
+
+  def self._safe_load_all(stream)
+    _load_all(stream, SafeLoader)
+  end
+
+  def self._safe_load(stream)
+    _load(stream, SafeLoader)
+  end
+
+  def self._emit(events, stream=nil, dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil, indent=nil, width=nil,line_break=nil)
+    if stream.nil?
+      require 'stringio'
+      stream = StringIO.new
+    end
+    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break)
+    for event in events
+      dumper.emit(event)
+    end        
+    stream.string if StringIO === stream
+  end
+
+  def self._serialize_all(nodes,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+    if stream.nil?
+      require 'stringio'
+      stream = StringIO.new
+    end
+    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
+    dumper.open
+    for node in nodes
+      dumper.serialize(node)
+    end
+    dumper.close
+    stream.string if StringIO === stream
+  end
+  
+  def self._serialize(node, stream=nil, dumper=Dumper, *kwds)
+    _serialize_all([node], stream, dumper, *kwds)
+  end
+  
+  def self._dump_all(documents,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+    if stream.nil?
+      require 'stringio'
+      stream = StringIO.new
+    end
+    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
+    dumper.open
+    for data in documents
+      dumper.represent(data)
+    end
+    dumper.close
+    stream.string if StringIO === stream
+  end
+
+  def self._dump(data, stream=nil, dumper=Dumper, *kwds)
+    _dump_all([data], stream, dumper, *kwds)
+  end
+  
+  def self._safe_dump_all(documents, stream=nil, *kwds)
+    _dump_all(documents, stream, SafeDumper, *kwds)
+  end
+  
+  def self._safe_dump(data, stream=nil, *kwds)
+    _dump_all([data], stream, SafeDumper, *kwds)
+  end
+
+  def self._add_implicit_resolver(tag, regexp, first=nil, loader=Loader, dumper=Dumper)
+    loader.add_implicit_resolver(tag, regexp, first)
+    dumper.add_implicit_resolver(tag, regexp, first)
+  end
+
+  def self._add_path_resolver(tag, path, kind=nil, loader=Loader, dumper=Dumper)
+    loader.add_path_resolver(tag, path, kind)
+    lumper.add_path_resolver(tag, path, kind)
+  end
+  
+  def self._add_constructor(tag, constructor, loader=Loader)
+    loader.add_constructor(tag, constructor)
+  end
+
+  def self._add_multi_constructor(tag_prefix, multi_constructor, loader=Loader)
+    loader.add_multi_constructor(tag_prefix, multi_constructor)
+  end
+
+  def self._add_representer(data_type, representer, dumper=Dumper)
+    dumper.add_representer(data_type, representer)
+  end
+
+  def self._add_multi_representer(data_type, multi_representer, dumper=Dumper)
+    dumper.add_multi_representer(data_type, multi_representer)
+  end
+
+  def self._dump_ruby_object(data, dumper=Dumper)
+    _dump(data,nil,dumper)
+  end
+end

data/test/test_bm.rb

@@ -0,0 +1,28 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'benchmark'
+require 'rbyaml'
+require 'yamlx'
+
+FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test16 test18 test19 test20 gems2}
+DO_TIMES = 100
+
+Benchmark.bmbm do |bm|
+  bm.report("JRuby YAML") { 
+    FILES.each {|fname| 
+      x = File.read("yaml/#{fname}.yml")
+      for k in 1..DO_TIMES
+        YAML::load(x)
+      end
+    }
+  }
+
+  bm.report("RbYAML") { 
+    FILES.each {|fname| 
+      x = File.read("yaml/#{fname}.yml")
+      for k in 1..DO_TIMES
+        RbYAML::load(x)
+      end
+    }
+  }
+end

data/test/test_bm_syck.rb

@@ -0,0 +1,28 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'benchmark'
+require 'rbyaml'
+require 'yaml'
+
+FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test16 test18 test19 test20 gems2}
+DO_TIMES = 100
+
+Benchmark.bmbm do |bm|
+  bm.report("SYCK") { 
+    FILES.each {|fname| 
+      x = File.read("yaml/#{fname}.yml")
+      for k in 1..DO_TIMES
+        YAML::load(x)
+      end
+    }
+  }
+
+  bm.report("RbYAML") { 
+    FILES.each {|fname| 
+      x = File.read("yaml/#{fname}.yml")
+      for k in 1..DO_TIMES
+        RbYAML::load(x)
+      end
+    }
+  }
+end

data/test/test_invoke.rb

@@ -0,0 +1,31 @@
+
+
+class Time
+  def self.time(times = 1)
+    if block_given?
+      before = Time.now
+      times.times { 
+        yield
+      }
+      after = Time.now
+      return after-before
+    end
+  end
+end
+
+
+def methoda
+  10000+1
+end
+
+DO_TIMES = 1000000
+ttimes = Time.time(DO_TIMES) { 
+  methoda
+}
+
+ttimes2 = Time.time(DO_TIMES) { 
+  send(:methoda)
+}
+
+puts "direct invoke: #{ttimes}"
+puts "send invoke: #{ttimes2}"

data/test/test_one.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rbyaml'
+        
+RbYAML.dump(open(File.expand_path(ARGV[0]),"r") {|f| RbYAML.load(f)})

data/test/test_profile.rb

@@ -0,0 +1,32 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+class Module
+  def add_tracer(meth)
+    m_alias = case meth
+                when :+ : "old_plus"
+                when :=== : "old_triple"
+                when :== : "old_eq"
+                else ; "old_#{method}"
+              end
+  module_eval %Q{ 
+    alias :#{m_alias} :#{meth}
+    def #{meth}(*args,&block)
+      puts caller[0] + ": " + self.class.name + "##{meth} called"
+      #{m_alias}(*args,&block)
+    end
+  }
+  end
+end
+
+#Kernel.add_tracer(:===)
+#Kernel.add_tracer(:==)
+#Fixnum.add_tracer(:+)
+
+require 'profile'
+require 'rbyaml'
+
+FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test16 test18 test19 test20 gems2}
+FILES.each {|fname| 
+  RbYAML::load(File.read("yaml/#{fname}.yml"))
+}
+

data/test/test_rbyaml.rb

@@ -2,6 +2,7 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 
 require 'rbyaml'
 require 'test/unit'
+require 'rubygems'
 
 class TestRbYAML < Test::Unit::TestCase
   def test_basic_load
@@ -19,7 +20,7 @@ class TestRbYAML < Test::Unit::TestCase
 end
 
 class TestRbYAMLFromFiles < Test::Unit::TestCase
-  FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test15 test16 test18 test19 test20}
+  FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test15 test16 test18 test19 test20 gems2}
 
   FILES.each { |test|
     self.class_eval <<-ENDCLS

data/test/test_rbyaml.rb.~1.2.~

@@ -0,0 +1,31 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rbyaml'
+require 'test/unit'
+
+class TestRbYAML < Test::Unit::TestCase
+  def test_basic_load
+    assert_equal({"A"=>"b","c"=>3.14},RbYAML.load("--- \nA: b\nc: 3.14\n"))
+    assert_equal(["A","b","c"],RbYAML.load("--- \n- A\n- b\n- c\n"))
+    assert_equal("foo",RbYAML.load("foo\n"))
+  end
+
+  def test_basic_dump
+    answ,ver1,ver2 = RbYAML.dump({"A"=>"b","c"=>3.14}),"A: b\nc: 3.14\n", "c: 3.14\nA: b\n"
+    assert_equal(true, ver1 == answ || ver2 == answ,"was #{answ.inspect} but should be #{ver1.inspect} or #{ver2.inspect}")
+    assert_equal("- A\n- b\n- c\n",RbYAML.dump(["A","b","c"]))
+    assert_equal("foo\n",RbYAML.dump("foo"))
+  end
+end
+
+class TestRbYAMLFromFiles < Test::Unit::TestCase
+  FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test15 test16 test18 test19 test20}
+
+  FILES.each { |test|
+    self.class_eval <<-ENDCLS
+      def test_#{test}
+        RbYAML.dump(open(File.expand_path(File.join(File.dirname(__FILE__),"yaml","#{test}.yml")),"r") {|f| RbYAML.load(f)})
+      end
+ENDCLS
+  }
+end

data/test/test_time.rb

@@ -15,15 +15,20 @@ class Time
   end
 end
 
-DO_TIMES = 10000
-ttimes = Time.time(DO_TIMES) { 
-  open("yaml/test1.yml") { |f| RbYAML::load(f) }
+FILES = %w{test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test12 test13 test14 test16 test18 test19 test20 gems2}
+ttimes = 0
+DO_TIMES = 100
+FILES.each {|fname| 
+  x = File.read("yaml/#{fname}.yml")
+  ttimes += Time.time(DO_TIMES) { 
+    RbYAML::load(x)
+  }
 }
 
-ttimes2 = Time.time(DO_TIMES) { 
-  RbYAML::dump(open("yaml/test1.yml") { |f| RbYAML::load(f) })
-} - ttimes
+#ttimes2 = Time.time(DO_TIMES) { 
+#  RbYAML::dump(open("yaml/test1.yml") { |f| RbYAML::load(f) })
+#} - ttimes
 
-puts "loading a file #{DO_TIMES} times took #{ttimes.to_f * 1000} milli seconds"
+puts "loading a file #{DO_TIMES*FILES.length} times took #{ttimes.to_f * 1000} milli seconds"
 
-puts "dumping a file #{DO_TIMES} times took #{ttimes2.to_f * 1000} milliseconds"
+#puts "dumping a file #{DO_TIMES} times took #{ttimes2.to_f * 1000} milliseconds"

data/test/test_time.rb.~1.1.~

@@ -0,0 +1,29 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rbyaml'
+
+class Time
+  def self.time(times = 1)
+    if block_given?
+      before = Time.now
+      times.times { 
+        yield
+      }
+      after = Time.now
+      return after-before
+    end
+  end
+end
+
+DO_TIMES = 10000
+ttimes = Time.time(DO_TIMES) { 
+  open("yaml/test1.yml") { |f| RbYAML::load(f) }
+}
+
+ttimes2 = Time.time(DO_TIMES) { 
+  RbYAML::dump(open("yaml/test1.yml") { |f| RbYAML::load(f) })
+} - ttimes
+
+puts "loading a file #{DO_TIMES} times took #{ttimes.to_f * 1000} milli seconds"
+
+puts "dumping a file #{DO_TIMES} times took #{ttimes2.to_f * 1000} milliseconds"