RbYAML 0.0.2 → 0.1.0

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

@@ -0,0 +1,381 @@
+require 'base64'
+require 'set'
+
+require 'rbyaml/error'
+require 'rbyaml/nodes'
+require 'rbyaml/composer'
+
+module RbYAML
+  class ConstructorError < MarkedYAMLError
+  end
+  
+  module BaseConstructor
+    include Composer
+    
+    @@yaml_constructors = {}
+    @@yaml_multi_constructors = {}
+    
+    def initialize_constructor
+      @constructed_objects = {}
+      @recursive_objects = {}
+    end
+
+    def check_data
+      # If there are more documents available?
+      check_node
+    end
+
+    def get_data
+      # Construct and return the next document.
+      construct_document(get_node) if check_node
+    end
+    
+    def each_document
+      # Iterator protocol.
+      while check_node
+        yield construct_document(get_node)
+      end
+    end 
+
+    def construct_document(node)
+      data = construct_object(node)
+      @constructed_objects = {}
+      @recursive_objects = {}
+      data
+    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
+          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) }
+            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) }
+            else
+              constructor = lambda { |node| @@yaml_multi_constructors[nil].call(node.tag, node) }
+            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)
+      @constructed_objects[node] = data
+      @recursive_objects.delete(node)
+      data
+    end
+
+    def construct_primitive(node)
+      if ScalarNode === node
+        construct_scalar(node)
+      elsif SequenceNode === node
+        construct_sequence(node)
+      elsif MappingNode === node
+        construct_mapping(node)
+      else
+        puts node.tag
+      end
+    end
+    
+    def construct_scalar(node)
+      if !ScalarNode === node
+        if MappingNode === node
+          for key_node in node.value.keys
+            if key_node.tag == "tag:yaml.org,2002:value"
+              return construct_scalar(node.value[key_node])
+            end
+          end
+        end
+        raise ConstructorError.new(nil, nil,"expected a scalar node, but found #{node.tid}",node.start_mark)
+      end
+      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
+    end
+
+    def construct_mapping(node)
+      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !MappingNode === node
+      mapping = {}
+      merge = nil
+      for key_node in node.value.keys
+        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
+            merge = [construct_mapping(value_node)]
+          elsif SequenceNode === value_node
+            merge = []
+            for subnode in value_node.value
+              if !MappingNode === subnode
+                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)
+            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])
+          mapping["="] = value
+          
+        else
+          key = construct_object(key_node)
+#          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 = {}
+        for submapping in merge
+          mapping.merge!(submapping)
+        end
+      end
+      mapping
+    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
+    end
+
+    def self.add_constructor(tag, constructor)
+      @@yaml_constructors[tag] = constructor
+    end
+
+    def self.add_multi_constructor(tag_prefix, multi_constructor)
+      @@yaml_multi_constructors[tag_prefix] = multi_constructor
+    end
+  end
+
+  module SafeConstructor
+    include BaseConstructor
+
+    def construct_yaml_null(node)
+      construct_scalar(node)
+      nil
+    end
+    
+    BOOL_VALUES = {
+      "y" =>       true,
+      "n" =>       false,
+      "yes" =>     true,
+      "no" =>      false,
+      "true" =>    true,
+      "false" =>   false,
+      "on" =>      true,
+      "off" =>     false
+    }
+
+    def construct_yaml_bool(node)
+      value = construct_scalar(node)
+      SafeConstructor::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])
+      if value == "0"
+        return 0
+      elsif value[0..1] == "0b"
+        return sign*value[2..-1].to_i(2)
+      elsif value[0..1] == "0x"
+        return sign*value[2..-1].to_i(16)
+      elsif value[0] == ?0
+        return sign*value[1..-1].to_i(8)
+      elsif value.include?(?:)
+        digits = (value.split(/:/).map {|val| val.to_i}).reverse
+        base = 1
+        value = 0
+        for digit in digits
+          value += digit*base
+          base *= 60
+        end
+        return sign*value
+      else
+        return sign*value.to_i
+      end
+    end
+
+    INF_VALUE = +1.0/0.0
+    NAN_VALUE = 0.0/0.0
+    
+    def construct_yaml_float(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])
+      if value.downcase == ".inf"
+        return sign*SafeConstructor::INF_VALUE
+      elsif value.downcase == ".nan"
+        return SafeConstructor::NAN_VALUE
+      elsif value.include?(?:)
+        digits = (value.split(/:/).map {|val| val.to_f}).reverse
+        base = 1
+        value = 0.0
+        for digit in digits
+          value += digit*base
+          base *= 60
+        end
+        return sign*value
+      else
+        return value.to_f
+      end
+    end
+
+    def construct_yaml_binary(node)
+      value = construct_scalar(node)
+      Base64.decode64(value.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])?)?))?)?$/
+    
+    def construct_yaml_timestamp(node)
+      value = construct_scalar(node)
+      match = SafeConstructor::TIMESTAMP_REGEXP.match(node.value)
+      values = match.captures.map {|val| val.to_i}
+      fraction = values[6]
+      if fraction != 0
+        fraction *= 10 while 10*fraction < 1000
+        values[6] = fraction
+      end
+      stamp = Time.gm(values[0],values[1],values[2],values[3],values[4],values[5],values[6])
+      
+      diff = values[7] * 3600 + values[8] * 60
+      return stamp-diff
+    end
+    
+    def construct_yaml_omap(node)
+      # 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
+      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
+        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]
+        key = construct_object(key_node)
+        value = construct_object(subnode.value[key_node])
+        omap << [key, value]
+      end
+      omap
+    end
+
+    def construct_yaml_pairs(node)
+      construct_yaml_omap(node)
+    end
+
+    def construct_yaml_set(node)
+      Set.new(construct_mapping(node).keys)
+    end
+    
+    def construct_yaml_str(node)
+      construct_scalar(node).to_s
+    end
+
+    def construct_yaml_seq(node)
+      construct_sequence(node)
+    end
+    
+    def construct_yaml_map(node)
+      construct_mapping(node)
+    end
+
+    def construct_yaml_object(node, cls)
+      mapping = construct_mapping(node)
+      data = cls.new
+      mapping.each {|key,val| data.instance_variable_set("@#{key}",val)}
+      data
+    end
+
+    def construct_undefined(node)
+      raise ConstructorError.new(nil,nil,"could not determine a constructor for the tag #{node.tag}",node.start_mark)
+    end
+
+    def construct_ruby_object(cls,node)
+      val = construct_primitive(node)
+      if cls.respond_to?(:yaml_new)
+        obj = cls.yaml_new(cls,node.tag,val)
+      else
+        obj = cls.allocate
+        obj.yaml_initialize(node.tag,val)
+      end
+      obj
+    end
+
+    def construct_ruby(tag,node)
+      obj_class = Object
+      tag.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tag
+      o = obj_class.allocate
+      mapping = construct_mapping(node)
+      mapping.each {|key,val| o.instance_variable_set("@#{key}",val)}
+      o
+    end
+  end
+  
+  BaseConstructor::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)
+  BaseConstructor::add_constructor('tag:yaml.org,2002:binary',:construct_yaml_binary)
+  BaseConstructor::add_constructor('tag:yaml.org,2002:timestamp',:construct_yaml_timestamp)
+  BaseConstructor::add_constructor('tag:yaml.org,2002:omap',:construct_yaml_omap)
+  BaseConstructor::add_constructor('tag:yaml.org,2002:pairs',:construct_yaml_pairs)
+  BaseConstructor::add_constructor('tag:yaml.org,2002:set',:construct_yaml_set)
+  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_multi_constructor("!ruby/object:",:construct_ruby)
+
+  module Constructor
+    include SafeConstructor
+  end
+end

data/lib/rbyaml/dumper.rb

@@ -5,39 +5,32 @@ require 'rbyaml/resolver'
 
 module RbYAML
   class CommonDumper
-    include Emitter, Serializer
-    
-    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)
+    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)
       super()
-      initialize_emitter(stream,canonical,indent,width,line_break)
-      initialize_serializer(explicit_start,explicit_end,version,tags)
+      @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)
     end
   end
   
   class BaseDumper < CommonDumper
-    include BaseRepresenter, BaseResolver
-    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)
+    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
-      initialize_representer(default_style,default_flow_style)
-      initialize_resolver
     end
   end
   
   class SafeDumper < CommonDumper
-    include SafeRepresenter, 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)
+    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)
       super
-      initialize_representer(default_style,default_flow_style)
-      initialize_resolver
     end
   end
   
   class Dumper < CommonDumper
-    include 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)
+    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)
       super
-      initialize_representer(default_style,default_flow_style)
-      initialize_resolver
     end
   end
 end

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

@@ -0,0 +1,43 @@
+require 'rbyaml/emitter'
+require 'rbyaml/serializer'
+require 'rbyaml/representer'
+require 'rbyaml/resolver'
+
+module RbYAML
+  class CommonDumper
+    include Emitter, Serializer
+    
+    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)
+      super()
+      initialize_emitter(stream,canonical,indent,width,line_break)
+      initialize_serializer(explicit_start,explicit_end,version,tags)
+    end
+  end
+  
+  class BaseDumper < CommonDumper
+    include BaseRepresenter, BaseResolver
+    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)
+      super
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
+    end
+  end
+  
+  class SafeDumper < CommonDumper
+    include SafeRepresenter, 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)
+      super
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
+    end
+  end
+  
+  class Dumper < CommonDumper
+    include 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)
+      super
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
+    end
+  end
+end