RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/{constructor.rb.~1.2.~ → constructor.rb.~1.9.~}

@@ -1,39 +1,60 @@
 require 'base64'
 require 'set'
 
+require 'rbyaml/util'
+
 require 'rbyaml/error'
 require 'rbyaml/nodes'
 require 'rbyaml/composer'
 
+class Symbol
+  def __call(obj,*args)
+    obj.send(self,*args)
+  end
+end
+
+class Proc
+  def __call(obj,*args)
+    call(obj,*args)
+  end
+end
+
+class Method
+  def __call(obj,*args)
+    call(*args)
+  end
+end
+
+
 module RbYAML
   class ConstructorError < MarkedYAMLError
   end
   
-  module BaseConstructor
-    include Composer
-    
+  class BaseConstructor
     @@yaml_constructors = {}
     @@yaml_multi_constructors = {}
+    @@yaml_multi_regexps = {}
     
-    def initialize_constructor
+    def initialize(composer)
+      @composer = composer
       @constructed_objects = {}
       @recursive_objects = {}
     end
 
     def check_data
       # If there are more documents available?
-      check_node
+      @composer.check_node
     end
 
     def get_data
       # Construct and return the next document.
-      construct_document(get_node) if check_node
+      construct_document(@composer.get_node) if @composer.check_node
     end
     
     def each_document
       # Iterator protocol.
-      while check_node
-        yield construct_document(get_node)
+      while @composer.check_node
+        yield construct_document(@composer.get_node)
       end
     end 
 
@@ -43,57 +64,65 @@ module RbYAML
       @recursive_objects = {}
       data
     end
+
+    class RecursiveProxy
+      attr_writer :value
+      def method_missing(*args)
+        @value.send(*args)
+      end
+      def class
+        @value.class
+      end
+      def to_s
+        @value.to_s
+      end
+    end
     
     def construct_object(node)
       return @constructed_objects[node] if @constructed_objects.include?(node)
-      raise ConstructorError.new(nil,nil,"found recursive nod",node.start_mark) if @recursive_objects.include?(node)
-      @recursive_objects[node] = nil
-      constructor = nil
-      ruby_cls = RbYAML::tagged_classes[node.tag]
-      if @@yaml_constructors.include?(node.tag)
-        constructor = @@yaml_constructors[node.tag]
-      elsif !ruby_cls.nil? && self.respond_to?(:construct_ruby_object) && (ruby_cls.method_defined?(:yaml_initialize) || ruby_cls.respond_to?(:yaml_new))
-        constructor = lambda { |node| send(:construct_ruby_object,RbYAML::tagged_classes[node.tag],node) }
-      else
-        through = false
-        for tag_prefix in @@yaml_multi_constructors.keys
+      @constructed_objects[node] = RecursiveProxy.new
+      constructor = @@yaml_constructors[node.tag]
+      if !constructor
+        ruby_cls = RbYAML::tagged_classes[node.tag]
+        if ruby_cls && (ruby_cls.method_defined?(:yaml_initialize) || ruby_cls.respond_to?(:yaml_new))
+          constructor = lambda { |obj,node| send(:construct_ruby_object,ruby_cls,node) }
+        else
           through = true
-          if Regexp.new("^"+Regexp.escape(tag_prefix)) =~ node.tag
-            tag_suffix = node.tag[tag_prefix.length..-1]
-            if Symbol === @@yaml_multi_constructors[tag_prefix]
-              constructor = lambda { |node| send(@@yaml_multi_constructors[tag_prefix],tag_suffix, node) }
-            else
-              constructor = lambda { |node| @@yaml_multi_constructors[tag_prefix].call(tag_suffix, node) }
+          for tag_prefix,reg in @@yaml_multi_regexps
+            if reg =~ node.tag
+              tag_suffix = node.tag[tag_prefix.length..-1]
+              constructor = lambda { |obj, node| @@yaml_multi_constructors[tag_prefix].__call(self,tag_suffix, node) }
+              through = false
+              break
             end
-            break
           end
-        end
-        if !through
-          if @@yaml_multi_constructors.include?(nil)
-            if Symbol === @@yaml_multi_constructors[nil]
-              constructor = lambda { |node| send(@@yaml_multi_constructors[nil],node.tag, node) }
+          if through
+            ctor = @@yaml_multi_constructors[nil]
+            if ctor
+              constructor = lambda { |obj, node| ctor.__call(self,node.tag,node) }
             else
-              constructor = lambda { |node| @@yaml_multi_constructors[nil].call(node.tag, node) }
+              ctor = @@yaml_constructors[nil]
+              if ctor
+                constructor = lambda { |obj, node| ctor.__call(self,node)}
+              else
+                constructor = lambda { |obj, node| construct_primitive(node) }
+              end
             end
-          elsif @@yaml_constructors.include?(nil)
-            constructor = @@yaml_constructors[nil]
-          else 
-            constructor = lambda { |node| construct_primitive(node) }
           end
         end
       end
-      data = (Symbol === constructor) ? send(constructor,node) : constructor.call(node)
+      data = constructor.__call(self,node)
+      @constructed_objects[node].value = data
       @constructed_objects[node] = data
-      @recursive_objects.delete(node)
       data
     end
 
     def construct_primitive(node)
-      if ScalarNode === node
+      if node.__is_scalar
         construct_scalar(node)
-      elsif SequenceNode === node
+      elsif node.__is_sequence
         construct_sequence(node)
-      elsif MappingNode === node
+      elsif node.__is_mapping
         construct_mapping(node)
       else
         puts node.tag
@@ -101,8 +130,8 @@ module RbYAML
     end
     
     def construct_scalar(node)
-      if !ScalarNode === node
-        if MappingNode === node
+      if !node.__is_scalar
+        if node.__is_mapping
           for key_node in node.value.keys
             if key_node.tag == "tag:yaml.org,2002:value"
               return construct_scalar(node.value[key_node])
@@ -114,52 +143,50 @@ module RbYAML
       node.value
     end
 
+    def construct_private_type(node)
+#      construct_scalar(node)
+      PrivateType.new(node.tag,node.value)
+    end
+
     def construct_sequence(node)
-      raise ConstructorError.new(nil,nil,"expected a sequence node, but found #{node.tid}",node.start_mark) if !SequenceNode === node
-      sequence = []
-      for child in node.value
-        sequence << construct_object(child)
-      end
-      sequence
+      raise ConstructorError.new(nil,nil,"expected a sequence node, but found #{node.tid}",node.start_mark) if !node.__is_sequence
+      node.value.map {|child| construct_object(child) }
     end
 
     def construct_mapping(node)
-      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !MappingNode === node
+      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !node.__is_mapping
       mapping = {}
       merge = nil
-      for key_node in node.value.keys
+      for key_node,value_node in node.value
         if key_node.tag == "tag:yaml.org,2002:merge"
           raise ConstructorError.new("while constructing a mapping", node.start_mark,"found duplicate merge key", key_node.start_mark) if !merge.nil?
-          value_node = node.value[key_node]
-          if MappingNode === value_node
+          if value_node.__is_mapping
             merge = [construct_mapping(value_node)]
-          elsif SequenceNode === value_node
+          elsif value_node.__is_sequence
             merge = []
             for subnode in value_node.value
-              if !MappingNode === subnode
+              if !subnode.__is_mapping
                 raise ConstructorError.new("while constructing a mapping",node.start_mark,"expected a mapping for merging, but found #{subnode.tid}", subnode.start_mark)
               end
-              merge << construct_mapping(subnode)
+              merge.unshift(construct_mapping(subnode))
             end
-            merge.reverse!
           else
             raise ConstructorError.new("while constructing a mapping", node.start_mark,"expected a mapping or list of mappings for merging, but found #{value_node.tid}", value_node.start_mark)
           end
         elsif key_node.tag == "tag:yaml.org,2002:value"
           raise ConstructorError.new("while construction a mapping", node.start_mark,"found duplicate value key", key_node.start_mark) if mapping.include?("=")
-          value = construct_object(node.value[key_node])
+          value = construct_object(value_node)
           mapping["="] = value
-          
         else
           key = construct_object(key_node)
+          value = construct_object(value_node)
+          mapping[key] = value
 #          raise ConstructorError.new("while constructing a mapping", node.start_mark,"found duplicate key", key_node.start_mark) if mapping.include?(key)
         end
-        value = construct_object(node.value[key_node])
-        mapping[key] = value
       end
       if !merge.nil?
         merge << mapping
-        mapping = {}
+        mapping = { }
         for submapping in merge
           mapping.merge!(submapping)
         end
@@ -168,14 +195,8 @@ module RbYAML
     end
 
     def construct_pairs(node)
-      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !MappingNode === node
-      pairs = []
-      for key_node in node.value.keys
-        key = construct_object(key_node)
-        value = construct_object(node.value[key_node])
-        pairs << [key, value]
-      end
-      pairs
+      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !node.__is_mapping
+      node.value.collect {|key_node,value_node| [construct_object(key_node), construct_object(value_node)] }
     end
 
     def self.add_constructor(tag, constructor)
@@ -184,20 +205,19 @@ module RbYAML
 
     def self.add_multi_constructor(tag_prefix, multi_constructor)
       @@yaml_multi_constructors[tag_prefix] = multi_constructor
+      @@yaml_multi_regexps[tag_prefix] = Regexp.new("^"+Regexp.escape(tag_prefix))
     end
   end
 
-  module SafeConstructor
-    include BaseConstructor
-
+  class SafeConstructor < BaseConstructor
     def construct_yaml_null(node)
       construct_scalar(node)
       nil
     end
     
     BOOL_VALUES = {
-      "y" =>       true,
-      "n" =>       false,
+#      "y" =>       true,
+#      "n" =>       false,
       "yes" =>     true,
       "no" =>      false,
       "true" =>    true,
@@ -208,23 +228,32 @@ module RbYAML
 
     def construct_yaml_bool(node)
       value = construct_scalar(node)
-      SafeConstructor::BOOL_VALUES[value.downcase]
+      BOOL_VALUES[value.downcase]
     end
     
     def construct_yaml_int(node)
       value = construct_scalar(node).to_s
       value = value.gsub(/_/, '')
       sign = +1
-      sign = -1 if value[0] == ?-
-      value = value[1..-1] if "+-".include?(value[0])
+      first = value[0]
+      if first == ?-
+        sign = -1
+        value.slice!(0)
+      elsif first == ?+
+        value.slice!(0)
+      end
+      base = 10
       if value == "0"
         return 0
       elsif value[0..1] == "0b"
-        return sign*value[2..-1].to_i(2)
+        value.slice!(0..1)
+        base = 2
       elsif value[0..1] == "0x"
-        return sign*value[2..-1].to_i(16)
+        value.slice!(0..1)
+        base = 16
       elsif value[0] == ?0
-        return sign*value[1..-1].to_i(8)
+        value.slice!(0)
+        base = 8
       elsif value.include?(?:)
         digits = (value.split(/:/).map {|val| val.to_i}).reverse
         base = 1
@@ -237,6 +266,7 @@ module RbYAML
       else
         return sign*value.to_i
       end
+      return sign*value.to_i(base)
     end
 
     INF_VALUE = +1.0/0.0
@@ -246,12 +276,17 @@ module RbYAML
       value = construct_scalar(node).to_s
       value = value.gsub(/_/, '')
       sign = +1
-      sign = -1 if value[0] == ?-
-      value = value[1..-1] if "+-".include?(value[0])
+      first = value[0]
+      if first == ?-
+        sign = -1
+        value.slice!(0)
+      elsif first == ?+
+        value.slice!(0)
+      end
       if value.downcase == ".inf"
-        return sign*SafeConstructor::INF_VALUE
+        return sign*INF_VALUE
       elsif value.downcase == ".nan"
-        return SafeConstructor::NAN_VALUE
+        return NAN_VALUE
       elsif value.include?(?:)
         digits = (value.split(/:/).map {|val| val.to_f}).reverse
         base = 1
@@ -268,14 +303,21 @@ module RbYAML
 
     def construct_yaml_binary(node)
       value = construct_scalar(node)
-      Base64.decode64(value.to_s)
+      Base64.decode64(value.split(/[\n\x85]|(?:\r[^\n])/).to_s)
     end
 
     TIMESTAMP_REGEXP = /^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:(?:[Tt]|[ \t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\.([0-9]*))?(?:[ \t]*(?:Z|([-+][0-9][0-9]?)(?::([0-9][0-9])?)?))?)?$/
+
+    YMD_REGEXP = /^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)$/
     
     def construct_yaml_timestamp(node)
-      value = construct_scalar(node)
-      match = SafeConstructor::TIMESTAMP_REGEXP.match(node.value)
+      if (match = YMD_REGEXP.match(node.value))
+        values = match.captures.map {|val| val.to_i}
+        return Date.new(values[0],values[1],values[2])
+      end
+      unless (match = TIMESTAMP_REGEXP.match(node.value))
+        return construct_private_type(node)
+      end
       values = match.captures.map {|val| val.to_i}
       fraction = values[6]
       if fraction != 0
@@ -292,11 +334,11 @@ module RbYAML
       # Note: we do not check for duplicate keys, because its too
       # CPU-expensive.
       raise ConstructorError.new("while constructing an ordered map", node.start_mark,
-                                 "expected a sequence, but found #{node.tid}", node.start_mark) if !SequenceNode === node
+                                 "expected a sequence, but found #{node.tid}", node.start_mark) if !node.__is_sequence
       omap = []
       for subnode in node.value
         raise ConstructorError.new("while constructing an ordered map", node.start_mark,
-                                   "expected a mapping of length 1, but found #{subnode.tid}",subnode.start_mark) if !MappingNode === subnode
+                                   "expected a mapping of length 1, but found #{subnode.tid}",subnode.start_mark) if !subnode.__is_mapping
         raise ConstructorError.new("while constructing an ordered map", node.start_mark,
                                    "expected a single mapping item, but found #{subnode.value.length} items",subnode.start_mark) if subnode.value.length != 1
         key_node = subnode.value.keys[0]
@@ -316,7 +358,8 @@ module RbYAML
     end
     
     def construct_yaml_str(node)
-      construct_scalar(node).to_s
+      val = construct_scalar(node).to_s
+      val.empty? ? nil : val
     end
 
     def construct_yaml_seq(node)
@@ -359,7 +402,7 @@ module RbYAML
     end
   end
   
-  BaseConstructor::add_constructor('tag:yaml.org,2002:null',:construct_yaml_null)
+  SafeConstructor::add_constructor('tag:yaml.org,2002:null',:construct_yaml_null)
   BaseConstructor::add_constructor('tag:yaml.org,2002:bool',:construct_yaml_bool)
   BaseConstructor::add_constructor('tag:yaml.org,2002:int',:construct_yaml_int)
   BaseConstructor::add_constructor('tag:yaml.org,2002:float',:construct_yaml_float)
@@ -371,11 +414,10 @@ module RbYAML
   BaseConstructor::add_constructor('tag:yaml.org,2002:str',:construct_yaml_str)
   BaseConstructor::add_constructor('tag:yaml.org,2002:seq',:construct_yaml_seq)
   BaseConstructor::add_constructor('tag:yaml.org,2002:map',:construct_yaml_map)
-  BaseConstructor::add_constructor(nil,:construct_undefined)
+  BaseConstructor::add_constructor(nil,:construct_private_type)
 
   BaseConstructor::add_multi_constructor("!ruby/object:",:construct_ruby)
 
-  module Constructor
-    include SafeConstructor
+  class Constructor < SafeConstructor
   end
 end

data/lib/rbyaml/dumper.rb

@@ -1,3 +1,4 @@
+require 'rbyaml/constants'
 require 'rbyaml/emitter'
 require 'rbyaml/serializer'
 require 'rbyaml/representer'
@@ -6,30 +7,32 @@ require 'rbyaml/resolver'
 module RbYAML
   class CommonDumper
     attr_accessor :emitter, :serializer, :representer, :resolver
-    def initialize(stream,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,emitter=Emitter,serializer=Serializer,representer=Representer,resolver=Resolver)
+    def initialize(stream,opts={})
       super()
-      @emitter = emitter.new(stream,canonical,indent,width,line_break)
-      @resolver = resolver.new
-      @serializer = serializer.new(@emitter,@resolver,explicit_start,explicit_end,version,tags)
-      @representer = representer.new(@serializer,default_style,default_flow_style)
+      opts = DEFAULTS.merge(opts)
+      @emitter = opts[:Emitter].new(stream,opts)
+      @resolver = opts[:Resolver].new
+      @serializer = opts[:Serializer].new(@emitter,@resolver,opts)
+      @representer = opts[:Representer].new(@serializer,opts)
     end
   end
   
   class BaseDumper < CommonDumper
     attr_accessor 
-    def initialize(stream,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,emitter=Emitter,serializer=Serializer,representer=BaseRepresenter,resolver=BaseResolver)
-      super
+    def initialize(stream,opts={})
+      super(stream,DEFAULTS.merge({:Representer=>RbYAML::BaseRepresenter, :Resolver=>RbYAML::BaseResolver}).merge(opts))
     end
   end
   
   class SafeDumper < CommonDumper
-    def initialize(stream,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,emitter=Emitter,serializer=Serializer,representer=SafeRepresenter,resolver=Resolver)
+    def initialize(stream,opts={})
+      super(stream,DEFAULTS.merge({:Representer=>RbYAML::SafeRepresenter}).merge(opts))
       super
     end
   end
   
   class Dumper < CommonDumper
-    def initialize(stream,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,emitter=Emitter,serializer=Serializer,representer=Representer,resolver=Resolver)
+    def initialize(stream,opts={})
       super
     end
   end