RbYAML 0.0.2 → 0.1.0

data/README

@@ -24,7 +24,7 @@ Just require 'rbyaml' and use it as you would use YAML, but in module RbYAML ins
 
 == More information
 
-Visit http://rbyaml.ologix.com for more information and updated versions
+Visit http://rbyaml.rubyforge.org for more information and updated versions
 
 == License
 

data/lib/rbyaml/composer.rb

@@ -6,13 +6,15 @@ module RbYAML
   class ComposerError < MarkedYAMLError
   end
 
-  module Composer
-    def initialize_composer
+  class Composer
+    def initialize(parser,resolver)
+      @parser = parser
+      @resolver = resolver
       @anchors = {}
     end
 
     def check_node
-      !check_event(StreamEndEvent)
+      !@parser.peek_event.__is_stream_end
     end
 
     def get_node
@@ -25,75 +27,76 @@ module RbYAML
 
     def compose_document
       # Drop the STREAM-START event.
-      get_event if check_event(StreamStartEvent)
-      get_event
+      @parser.get_event if @parser.peek_event.__is_stream_start
+      # Drop the DOCUMENT-START event.
+      @parser.get_event
       # Compose the root node.
       node = compose_node(nil,nil)
       # Drop the DOCUMENT-END event.
-      get_event
+      @parser.get_event
       @anchors = {}
       node
     end
 
     def compose_node(parent,index)
-      if check_event(AliasEvent)
-        event = get_event
+      if @parser.peek_event.__is_alias
+        event = @parser.get_event
         anchor = event.anchor
         raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@anchors.include?(anchor)
         return @anchors[anchor]
       end
-      event = peek_event
+      event = @parser.peek_event
       anchor = event.anchor
       if !anchor.nil?
         if @anchors.include?(anchor)
           raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @anchors[anchor].start_mark,"second occurence", event.start_mark)
         end
       end
-      descend_resolver(parent,index)
-      if check_event(ScalarEvent)
+      @resolver.descend_resolver(parent,index)
+      if @parser.peek_event.__is_scalar
         node = compose_scalar_node(anchor)
-      elsif check_event(SequenceStartEvent)
+      elsif @parser.peek_event.__is_sequence_start
         node = compose_sequence_node(anchor)
-      elsif check_event(MappingStartEvent)
+      elsif @parser.peek_event.__is_mapping_start
         node = compose_mapping_node(anchor)
       end
-      ascend_resolver
+      @resolver.ascend_resolver
       node
     end
 
     def compose_scalar_node(anchor)
-      event = get_event
+      event = @parser.get_event
       tag = event.tag
-      tag = resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
       node = ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, event.style)
       @anchors[anchor] = node if !anchor.nil?
       node
     end
 
     def compose_sequence_node(anchor)
-      start_event = get_event
+      start_event = @parser.get_event
       tag = start_event.tag
-      tag = resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
       node = SequenceNode.new(tag,[],start_event.start_mark,nil,start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
       index = 0
-      while !check_event(SequenceEndEvent)
+      while !@parser.peek_event.__is_sequence_end
         node.value << compose_node(node,index)
         index += 1
       end
-      end_event = get_event
+      end_event = @parser.get_event
       node.end_mark = end_event.end_mark
       node
     end
 
     def compose_mapping_node(anchor)
-      start_event = get_event
+      start_event = @parser.get_event
       tag = start_event.tag
-      tag = resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
       node = MappingNode.new(tag, {},start_event.start_mark,nil,start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
-      while !check_event(MappingEndEvent)
-        key_event = peek_event
+      while !@parser.peek_event.__is_mapping_end
+        key_event = @parser.peek_event
         item_key = compose_node(node,nil)
         if node.value.include?(item_key)
           raise ComposerError.new("while composing a mapping", start_event.start_mark,"found duplicate key", key_event.start_mark)
@@ -101,7 +104,7 @@ module RbYAML
         item_value = compose_node(node,item_key)
         node.value[item_key] = item_value
       end
-      end_event = get_event
+      end_event = @parser.get_event
       node.end_mark = end_event.end_mark
       node
     end

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

@@ -0,0 +1,109 @@
+require 'rbyaml/error'
+require 'rbyaml/events'
+require 'rbyaml/nodes'
+
+module RbYAML
+  class ComposerError < MarkedYAMLError
+  end
+
+  module Composer
+    def initialize_composer
+      @anchors = {}
+    end
+
+    def check_node
+      !check_event(StreamEndEvent)
+    end
+
+    def get_node
+      compose_document if check_node
+    end
+
+    def each_node
+      yield compose_document while check_node
+    end
+
+    def compose_document
+      # Drop the STREAM-START event.
+      get_event if check_event(StreamStartEvent)
+      get_event
+      # Compose the root node.
+      node = compose_node(nil,nil)
+      # Drop the DOCUMENT-END event.
+      get_event
+      @anchors = {}
+      node
+    end
+
+    def compose_node(parent,index)
+      if check_event(AliasEvent)
+        event = get_event
+        anchor = event.anchor
+        raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@anchors.include?(anchor)
+        return @anchors[anchor]
+      end
+      event = peek_event
+      anchor = event.anchor
+      if !anchor.nil?
+        if @anchors.include?(anchor)
+          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @anchors[anchor].start_mark,"second occurence", event.start_mark)
+        end
+      end
+      descend_resolver(parent,index)
+      if check_event(ScalarEvent)
+        node = compose_scalar_node(anchor)
+      elsif check_event(SequenceStartEvent)
+        node = compose_sequence_node(anchor)
+      elsif check_event(MappingStartEvent)
+        node = compose_mapping_node(anchor)
+      end
+      ascend_resolver
+      node
+    end
+
+    def compose_scalar_node(anchor)
+      event = get_event
+      tag = event.tag
+      tag = resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
+      node = ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, event.style)
+      @anchors[anchor] = node if !anchor.nil?
+      node
+    end
+
+    def compose_sequence_node(anchor)
+      start_event = get_event
+      tag = start_event.tag
+      tag = resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      node = SequenceNode.new(tag,[],start_event.start_mark,nil,start_event.flow_style)
+      @anchors[anchor] = node if !anchor.nil?
+      index = 0
+      while !check_event(SequenceEndEvent)
+        node.value << compose_node(node,index)
+        index += 1
+      end
+      end_event = get_event
+      node.end_mark = end_event.end_mark
+      node
+    end
+
+    def compose_mapping_node(anchor)
+      start_event = get_event
+      tag = start_event.tag
+      tag = resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      node = MappingNode.new(tag, {},start_event.start_mark,nil,start_event.flow_style)
+      @anchors[anchor] = node if !anchor.nil?
+      while !check_event(MappingEndEvent)
+        key_event = peek_event
+        item_key = compose_node(node,nil)
+        if node.value.include?(item_key)
+          raise ComposerError.new("while composing a mapping", start_event.start_mark,"found duplicate key", key_event.start_mark)
+        end
+        item_value = compose_node(node,item_key)
+        node.value[item_key] = item_value
+      end
+      end_event = get_event
+      node.end_mark = end_event.end_mark
+      node
+    end
+  end
+end

data/lib/rbyaml/constructor.rb

@@ -5,35 +5,54 @@ 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(*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 
 
@@ -48,52 +67,43 @@ module RbYAML
       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
+      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 { |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 { |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] || @@yaml_constructors[nil]
+            if ctor
+              constructor = lambda { |node| ctor.__call(self,node.tag,node) }
             else
-              constructor = lambda { |node| @@yaml_multi_constructors[nil].call(node.tag, node) }
+              constructor = lambda { |node| construct_primitive(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)
+      data = constructor.__call(self,node)
       @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 +111,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])
@@ -115,46 +125,39 @@ module RbYAML
     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)
 #          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])
+        value = construct_object(value_node)
         mapping[key] = value
       end
       if !merge.nil?
@@ -168,14 +171,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,12 +181,11 @@ 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
@@ -208,23 +204,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 +242,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 +252,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
@@ -275,7 +286,7 @@ module RbYAML
     
     def construct_yaml_timestamp(node)
       value = construct_scalar(node)
-      match = SafeConstructor::TIMESTAMP_REGEXP.match(node.value)
+      match = TIMESTAMP_REGEXP.match(node.value)
       values = match.captures.map {|val| val.to_i}
       fraction = values[6]
       if fraction != 0
@@ -292,11 +303,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]
@@ -359,7 +370,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)
@@ -375,7 +386,6 @@ module RbYAML
 
   BaseConstructor::add_multi_constructor("!ruby/object:",:construct_ruby)
 
-  module Constructor
-    include SafeConstructor
+  class Constructor < SafeConstructor
   end
 end