RbYAML 0.0.1 → 0.0.2

data/lib/rbyaml/composer.rb

@@ -6,14 +6,9 @@ module RbYAML
   class ComposerError < MarkedYAMLError
   end
 
-  module BaseComposer
-    @@yaml_resolvers = {}
-
+  module Composer
     def initialize_composer
-      @all_anchors = {}
-      @complete_anchors = {}
-      @resolver_tags = []
-      @resolver_paths = []
+      @anchors = {}
     end
 
     def check_node
@@ -33,157 +28,82 @@ module RbYAML
       get_event if check_event(StreamStartEvent)
       get_event
       # Compose the root node.
-      node = compose_node([])
+      node = compose_node(nil,nil)
       # Drop the DOCUMENT-END event.
       get_event
-      @all_anchors = {}
-      @complete_anchors = {}
-      @resolver_tags = []
-      @resolver_paths = []
+      @anchors = {}
       node
     end
 
-    def increase_resolver_depth(path)
-      depth = path.length
-      tag = []
-      paths = []
-      if depth == 0
-        for resolver_path in @@yaml_resolvers.keys
-          if resolver_path
-            paths += resolver_path
-          else
-            tag = @@yaml_resolvers[resolver_path]
-          end
-        end
-      else
-        base, index = path[-1]
-        if ScalarNode === index && index.tag == DEFAULT_SCALAR_TAG
-          index = index.value
-        elsif Node === index
-          index = nil
-        end
-        if @resolver_paths[-1]
-          for resolver_path in @resolver_paths[-1]
-            resolver_index = resolver_path[depth-1]
-            if resolver_index.nil? || resolver_index == index
-              if resolver_index.length > depth
-                paths += resolver_path
-              else
-                tag = @@yaml_resolvers[resolver_path]
-              end
-            end
-          end
-        end
-      end
-
-      @resolver_tags += tag
-      @resolver_paths += paths
-    end
-
-    def decrease_resolver_depth
-      @resolver_tags.pop
-      @resolver_paths.pop
-    end
-
-    def compose_node(path)
+    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 !@all_anchors.include?(anchor)
-        if !@complete_anchors.include?(anchor)
-          collection_event = @all_anchors[anchor]
-          raise ComposerError.new("while composing a collection",collection_event.start_mark,"found recursive anchor #{anchor}",event.start_mark)
-        end
-        return @complete_anchors[anchor]
+        raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@anchors.include?(anchor)
+        return @anchors[anchor]
       end
-      increase_resolver_depth(path)
       event = peek_event
       anchor = event.anchor
       if !anchor.nil?
-        if @all_anchors.include?(anchor)
-          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @all_anchors[anchor].start_mark,"second occurence", event.start_mark)
+        if @anchors.include?(anchor)
+          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @anchors[anchor].start_mark,"second occurence", event.start_mark)
         end
-        @all_anchors[anchor] = event
       end
+      descend_resolver(parent,index)
       if check_event(ScalarEvent)
-        node = compose_scalar_node(path)
+        node = compose_scalar_node(anchor)
       elsif check_event(SequenceStartEvent)
-        node = compose_sequence_node(path)
+        node = compose_sequence_node(anchor)
       elsif check_event(MappingStartEvent)
-        node = compose_mapping_node(path)
+        node = compose_mapping_node(anchor)
       end
-      
-      if !anchor.nil?
-        @complete_anchors[anchor] = node
-      end
-      decrease_resolver_depth
+      ascend_resolver
       node
     end
 
-    def compose_scalar_node(path)
+    def compose_scalar_node(anchor)
       event = get_event
-      tag = resolve_scalar(path, event.tag, event.implicit, event.value)
-      ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, style=event.style)
+      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(path)
+    def compose_sequence_node(anchor)
       start_event = get_event
-      tag = resolve_sequence(path, start_event.tag)
-      node = SequenceNode.new(tag, [],start_event.start_mark, nil,flow_style=start_event.flow_style)
+      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(path+[[node, index]])
+        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(path)
+    def compose_mapping_node(anchor)
       start_event = get_event
-      tag = resolve_mapping(path, start_event.tag)
-      node = MappingNode.new(tag, {},start_event.start_mark, nil,flow_style=start_event.flow_style)
+      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(path+[[node, nil]])
-        item_value = compose_node(path+[[node, item_key]])
+        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
-
-    def resolve_scalar(path, tag, implicit, value)
-      tag = detect(value) if implicit
-      tag = resolver_tags[-1] if (tag.nil? || tag == []) && @resolver_tags[-1]
-      tag = DEFAULT_SCALAR_TAG if tag.nil? || tag == [] || tag == "!"
-      tag
-    end
-
-    def resolve_sequence(path, tag)
-      tag = resolver_tags[-1] if tag.nil? && @resolver_tags[-1]
-      tag = DEFAULT_SEQUENCE_TAG if tag.nil? || tag == "!"
-      tag
-    end
-
-    def resolve_mapping(path, tag)
-      tag = resolver_tags[-1] if tag.nil? && @resolver_tags[-1]
-      tag = DEFAULT_MAPPING_TAG if tag.nil? || tag == "!"
-      tag
-    end
-
-    def self.add_resolver(tag, path)
-      @@yaml_resolvers[path] = tag
-    end
-  end
-  
-  module Composer
-    include BaseComposer
   end
 end

data/lib/rbyaml/constructor.rb

@@ -17,6 +17,7 @@ module RbYAML
     
     def initialize_constructor
       @constructed_objects = {}
+      @recursive_objects = {}
     end
 
     def check_data
@@ -39,11 +40,14 @@ module RbYAML
     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)
@@ -61,8 +65,8 @@ module RbYAML
             else
               constructor = lambda { |node| @@yaml_multi_constructors[tag_prefix].call(tag_suffix, node) }
             end
+            break
           end
-          break
         end
         if !through
           if @@yaml_multi_constructors.include?(nil)
@@ -80,6 +84,7 @@ module RbYAML
       end
       data = (Symbol === constructor) ? send(constructor,node) : constructor.call(node)
       @constructed_objects[node] = data
+      @recursive_objects.delete(node)
       data
     end
 
@@ -90,6 +95,8 @@ module RbYAML
         construct_sequence(node)
       elsif MappingNode === node
         construct_mapping(node)
+      else
+        puts node.tag
       end
     end
     

data/lib/rbyaml/dumper.rb

@@ -1,13 +1,13 @@
 require 'rbyaml/emitter'
 require 'rbyaml/serializer'
 require 'rbyaml/representer'
-require 'rbyaml/detector'
+require 'rbyaml/resolver'
 
 module RbYAML
   class CommonDumper
     include Emitter, Serializer
     
-    def initialize(stream,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)
       super()
       initialize_emitter(stream,canonical,indent,width,line_break)
       initialize_serializer(explicit_start,explicit_end,version,tags)
@@ -15,26 +15,29 @@ module RbYAML
   end
   
   class BaseDumper < CommonDumper
-    include BaseRepresenter, BaseDetector
-    def initialize(stream,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+    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
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
     end
   end
   
   class SafeDumper < CommonDumper
-    include SafeRepresenter, Detector
-    def initialize(stream,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+    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
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
     end
   end
   
   class Dumper < CommonDumper
-    include Representer, Detector
-    def initialize(stream,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+    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
-    end
+      initialize_representer(default_style,default_flow_style)
+      initialize_resolver
     end
+  end
 end

data/lib/rbyaml/emitter.rb

@@ -491,19 +491,21 @@ module RbYAML
       tag = @event.tag
       if ScalarEvent === @event
         @style = choose_scalar_style if @style.nil?
-        if @style == ""
+        if ((!@canonical || tag.nil?) && ((@style == "" && @event.implicit[0]) || (@style != "" && @event.implicit[1])))
           @prepared_tag = nil
-          return nil
+          return
         end
-        if @event.implicit && !tag
+        if @event.implicit[0] && tag.nil?
           tag = "!"
           @prepared_tag = nil
         end
+      else
+        if (!@canonical || tag.nil?) && @event.implicit
+          @prepared_tag = nil
+          return
+        end
       end
-      if !tag
-        @prepared_tag = nil
-        return nil
-      end
+      raise EmitterError.new("tag is not specified") if tag.nil?
       @prepared_tag = prepare_tag(tag) if @prepared_tag.nil?
       write_indicator(@prepared_tag, true) if @prepared_tag && !@prepared_tag.empty?
       @prepared_tag = nil
@@ -512,14 +514,12 @@ module RbYAML
     def choose_scalar_style
       @analysis = analyze_scalar(@event.value) if @analysis.nil?
       return '"' if @event.style == '"' || @canonical            
-      if !@event.style && @event.implicit
+      if !@event.style && @event.implicit[0]
         if !(@simple_key_context && (@analysis.empty || @analysis.multiline)) && ((@flow_level!=0 && @analysis.allow_flow_plain) || (@flow_level == 0 && @analysis.allow_block_plain))
           return ""
         end
       end
 
-
-
       if !@event.style && @event.implicit && (!(@simple_key_context && (@analysis.empty || @analysis.multiline)) && 
                                               (@flow_level!=0 && @analysis.allow_flow_plain || (@flow_level==0 && @analysis.allow_block_plain)))
         return ""
@@ -925,7 +925,7 @@ module RbYAML
       while ending <= text.length
         ch = nil
         ch = text[ending] if ending < text.length
-        if ch.nil? || '"\\'.include?(ch) || !(?\x20 <= ch && ch <= ?\x7E)
+        if ch.nil? || "\"\\\x85".include?(ch) || !(?\x20 <= ch && ch <= ?\x7E)
           if start < ending
             data = text[start...ending]
             @column += data.length
@@ -951,7 +951,7 @@ module RbYAML
           write_indent
           @whitespace = false
           @indention = false
-          if ch == 32
+          if text[start] == 32
             data = "\\"
             @column += data.length
             @stream.write(data)

data/lib/rbyaml/events.rb

@@ -8,7 +8,7 @@ module RbYAML
     end
 
     def to_s
-      attributes = ["@anchor","@tag","@value"] & self.instance_variables
+      attributes = ["@anchor","@tag","@implicit","@value"] & self.instance_variables
       args = attributes.collect {|val| "#{val[1..-1]}=" + eval("#{val}").to_s}.join(", ")
       "#{self.class.name}(#{args})"
     end
@@ -23,10 +23,11 @@ module RbYAML
   end
 
   class CollectionStartEvent < NodeEvent
-    attr_reader :tag, :flow_style
-    def initialize(anchor,tag,start_mark=nil, end_mark=nil,flow_style=nil)
+    attr_reader :tag, :implicit, :flow_style
+    def initialize(anchor,tag,implicit,start_mark=nil, end_mark=nil,flow_style=nil)
       super(anchor,start_mark,end_mark)
       @tag = tag
+      @implicit = implicit
       @flow_style = flow_style        
     end
   end

data/lib/rbyaml/loader.rb

@@ -5,7 +5,7 @@ require 'rbyaml/scanner'
 require 'rbyaml/parser'
 require 'rbyaml/composer'
 require 'rbyaml/constructor'
-require 'rbyaml/detector'
+require 'rbyaml/resolver'
 
 module RbYAML
   class CommonLoader
@@ -20,29 +20,32 @@ module RbYAML
   end
   
   class BaseLoader < CommonLoader
-    include BaseComposer, BaseConstructor, BaseDetector
+    include Composer, BaseConstructor, BaseResolver
     def initialize(stream)
       super
       initialize_composer
       initialize_constructor
+      initialize_resolver
     end
   end
   
   class SafeLoader < CommonLoader
-    include Composer, SafeConstructor, Detector
+    include Composer, SafeConstructor, Resolver
     def initialize(stream)
       super
       initialize_composer
       initialize_constructor
-      end
+      initialize_resolver
+    end
   end
   
   class Loader < CommonLoader
-    include Composer, Constructor, Detector
+    include Composer, Constructor, Resolver
     def initialize(stream)
       super
       initialize_composer
       initialize_constructor
+      initialize_resolver
     end
   end
 end

data/lib/rbyaml/nodes.rb

@@ -11,24 +11,7 @@ module RbYAML
     end
     
     def to_s
-      value = @value
-      if Array === value
-        if value.empty?
-          value = "<empty>"
-        elsif value.length == 1
-          value = "<1 item>"
-        else
-          value = "#{value.length} items>"
-        end
-      else
-        if value.length > 75
-          value = value[0..70].to_s+"..."
-        else
-          value = value.to_s
-        end
-      end
-      
-      "#{self.class.name}(tag=#{@tag}, value=#{value})"
+      "#{self.class.name}(tag=#{@tag}, value=#{@value})"
     end
   end
   

data/lib/rbyaml/parser.rb

@@ -257,37 +257,43 @@ module RbYAML
         end
         event = nil
         collection_events = nil
+        implicit = tag.nil? || tag == ?!
         if indentless_sequence && check_token(BlockEntryToken)
           end_mark = peek_token.end_mark
-          event = SequenceStartEvent.new(anchor, tag, start_mark, end_mark)
+          event = SequenceStartEvent.new(anchor, tag, implicit, start_mark, end_mark)
           collection_events = parse_indentless_sequence
         else
           if check_token(ScalarToken)
             token = get_token
             end_mark = token.end_mark
-            implicit = ((tag.nil? || tag == "!") && token.implicit)
+            if (token.plain && tag.nil?) || tag == ?!
+              implicit = [true, false]
+            elsif tag.nil?
+              implicit = [false, true]
+            else
+              implicit = [false, false]
+            end
             event = ScalarEvent.new(anchor, tag, implicit, token.value,start_mark, end_mark,token.style)
           elsif check_token(FlowSequenceStartToken)
             end_mark = peek_token.end_mark
-            event = SequenceStartEvent.new(anchor, tag, start_mark, end_mark,true)
+            event = SequenceStartEvent.new(anchor, tag, implicit, start_mark, end_mark,true)
             collection_events = parse_flow_sequence
           elsif check_token(FlowMappingStartToken)
             end_mark = peek_token.end_mark
-            event = MappingStartEvent.new(anchor, tag, start_mark, end_mark,true)
+            event = MappingStartEvent.new(anchor, tag, implicit, start_mark, end_mark,true)
             collection_events = parse_flow_mapping
           elsif block && check_token(BlockSequenceStartToken)
             end_mark = peek_token.start_mark
-            event = SequenceStartEvent.new(anchor, tag, start_mark, end_mark,false)
+            event = SequenceStartEvent.new(anchor, tag, implicit, start_mark, end_mark,false)
             collection_events = parse_block_sequence
           elsif block && check_token(BlockMappingStartToken)
             end_mark = peek_token.start_mark
-            event = MappingStartEvent.new(anchor, tag, start_mark, end_mark,false)
+            event = MappingStartEvent.new(anchor, tag, implicit, start_mark, end_mark,false)
             collection_events = parse_block_mapping
           elsif !anchor.nil? || !tag.nil?
             # Empty scalars are allowed even if a tag or an anchor is
             # specified.
-            implicit = (tag.nil? || tag == "!")
-            event = ScalarEvent.new(anchor, tag, implicit,"",start_mark, end_mark)
+            event = ScalarEvent.new(anchor, tag, [implicit,false],"",start_mark, end_mark)
           else
             if block
               node = "block"
@@ -398,7 +404,7 @@ module RbYAML
       while !check_token(FlowSequenceEndToken)
         if check_token(KeyToken)
           token = get_token
-          events << MappingStartEvent.new(nil,nil,token.start_mark, token.end_mark,true)
+          events << MappingStartEvent.new(nil,nil,true,token.start_mark, token.end_mark,true)
           if !check_token(ValueToken,FlowEntryToken, FlowSequenceEndToken)
             events += parse_flow_node
           else
@@ -481,7 +487,7 @@ module RbYAML
     end
 
     def process_empty_scalar(mark)
-      ScalarEvent.new(nil, nil, nil, "", mark, mark)
+      ScalarEvent.new(nil, nil, [true, false], "", mark, mark)
     end
   end
 end

data/lib/rbyaml/representer.rb

@@ -3,7 +3,6 @@ require 'set'
 
 require 'rbyaml/error'
 require 'rbyaml/nodes'
-require 'rbyaml/detector'
 
 module RbYAML
   class RepresenterError < YAMLError
@@ -11,18 +10,31 @@ module RbYAML
 
   module BaseRepresenter
     @@yaml_representers = {}
+    @@yaml_multi_representers = {}
 
-    def initialize_representer
+    def initialize_representer(default_style=nil, default_flow_style=nil)
+      @default_style = default_style
+      @default_flow_style = default_flow_style
       @represented_objects = {}
     end
 
     def represent(data)
-      node = represent_object(data)
+      node = represent_data(data)
       serialize(node)
       represented_objects = {}
     end
     
-    def represent_object(data)
+    CLASSOBJ_TYPE = Class
+    INSTANCE_TYPE = Object
+    FUNCTION_TYPE = Method
+    BUILTIN_FUNCTION_TYPE = Method
+    MODULE_TYPE = Module
+
+    def get_classobj_bases(cls)
+      [cls] + cls.ancestors
+    end
+    
+    def represent_data(data)
       if ignore_aliases(data)
         alias_key = nil
       else
@@ -38,22 +50,35 @@ module RbYAML
         @represented_objects[alias_key] = nil
       end
       
-      rerun = false
+      data_types = data.class.ancestors
+      data_types = get_classobj_bases(data.class) + data_types if INSTANCE_TYPE === data
 
-      for data_type in data.class.ancestors
+      if @@yaml_representers.include?(data_types[0])
+        node = send(@@yaml_representers[data_types[0]],data)
+      else
         rerun = true
-        if @@yaml_representers.include?(data_type)
-          node = send(@@yaml_representers[data_type],data)
-          break
+        for data_type in data_types
+          if @@yaml_multi_representers.include?(data_type)
+            node = send(@@yaml_multi_representers[data_type],data)
+            rerun = false
+            break
+          elsif @@yaml_representers.include?(data_type)
+            node = send(@@yaml_representers[data_type],data)
+            rerun = false
+            break
+          end
         end
-      end
-      if !rerun
-        if @@yaml_representers.include?(nil)
-          node = send(@@yaml_representers[nil], data)
-        else
-          node = ScalarNode.new(data.taguri, data)
+        if rerun
+          if @@yaml_multi_representers.include?(nil)
+            node = send(@@yaml_multi_representers[nil],data)
+          elsif @@yaml_representers.include?(nil)
+            node = send(@@yaml_representers[nil],data)
+          else
+            node = ScalarNode.new(nil, data)
+          end
         end
       end
+        
       @represented_objects[alias_key] = node if !alias_key.nil?
       node
     end
@@ -61,19 +86,49 @@ module RbYAML
     def self.add_representer(data_type, representer)
       @@yaml_representers[data_type] = representer
     end
+
+    def self.add_multi_representer(data_type, representer)
+      @@yaml_multi_representers[data_type] = representer
+    end
     
     def represent_scalar(tag, value, style=nil)
+      style ||= @default_style
       ScalarNode.new(tag, value, style)
     end
 
     def represent_sequence(tag, sequence, flow_style=nil)
-      value = sequence.map {|item| represent_object(item)}
+      best_style = true
+      value = sequence.map {|item| 
+        node_item = represent_data(item)
+        best_style = false if !ScalarNode === node_item && !node_item.style
+        node_item
+      }
+      flow_style ||= (@flow_default_style || best_style)
       SequenceNode.new(tag, value, flow_style)
     end
 
     def represent_mapping(tag, mapping, flow_style=nil)
-      value = {}
-      mapping.each { |item_key,item_value| value[represent_object(item_key)] = represent_object(item_value) }
+      best_style = true
+      if mapping.respond_to?(:keys)
+        value = {}
+        for item_key,item_value in mapping
+          node_key = represent_data(item_key)
+          node_value = represent_data(item_value)
+          best_style = false if !ScalarNode === node_key && !node_key.style
+          best_style = false if !ScalarNode === node_value && !node_value.style
+          value[node_key] = node_value
+        end
+      else
+        value = []
+        for item_key, item_value in mapping
+          node_key = represent_data(item_key)
+          node_value = represent_data(item_value)
+          best_style = false if !ScalarNode === node_key && !node_key.style
+          best_style = false if !ScalarNode === node_value && !node_value.style
+          value << [node_key, node_value]
+        end
+      end
+      flow_style ||= (@flow_default_style || best_style)
       MappingNode.new(tag, value, flow_style)
     end
 
@@ -94,7 +149,7 @@ module RbYAML
     end
 
     def represent_str(data)
-      represent_scalar(data.taguri,data)
+      represent_scalar(data.taguri,data,nil)
     end
 
     def represent_symbol(data)
@@ -124,6 +179,7 @@ module RbYAML
     end
     
     def represent_list(data)
+#no support for pairs right now. should probably be there, though...
       represent_sequence(data.taguri, data)
     end
 

data/lib/rbyaml/resolver.rb

@@ -0,0 +1,163 @@
+require 'rbyaml/nodes'
+require 'rbyaml/error'
+  
+module RbYAML
+  class ResolverError < MarkedYAMLError
+  end
+
+  DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
+  DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
+  DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
+  
+  module BaseResolver
+    @@yaml_implicit_resolvers = {}
+    @@yaml_path_resolvers = {}
+
+    def initialize_resolver
+      @resolver_exact_paths = []
+      @resolver_prefix_paths = []
+    end
+    
+    def self.add_implicit_resolver(tag, regexp, first)
+      if first.nil?
+        first = ""
+      end
+      first.each_byte { |ch|
+        @@yaml_implicit_resolvers[ch] ||= []
+        @@yaml_implicit_resolvers[ch] << [tag,regexp]
+      }
+    end
+
+    def self.add_path_resolver(tag, path, kind=nil)
+      new_path = []
+      for element in path
+        if Array === element
+          if element.length == 2
+            node_check, index_check = element
+          elsif element.length == 1
+            node_check = element[0]
+            index_check = true
+          else
+            raise ResolverError.new("Invalid path element: #{element}")
+          end
+        else
+          node_check = nil
+          index_check = element
+        end
+        if String == node_check
+          node_check = ScalarNode
+        elsif Array == node_check
+          node_check = SequenceNode
+        elsif Hash == node_check
+          node_check = MappingNode
+        elsif ![ScalarNode, SequenceNode, MappingNode].include?(node_check) && !Symbol === node_check && !node_check.nil?
+          raise ResolverError.new("Invalid node checker: #{node_check}")
+        end
+        if !(String === index_check || Integer === index_check) && !index_check.nil?
+          raise ResolverError.new("Invalid index checker: #{index_check}")
+        end
+        new_path << [node_check, index_check]
+      end
+      if String == kind
+        kind = ScalarNode
+      elsif Array == kind
+        kind = SequenceNode
+      elsif Hash == kind
+        kind = MappingNode
+      elsif ![ScalarNode, SequenceNode, MappingNode].include?(kind) && !kind.nil?
+        raise ResolverError.new("Invalid node kind: #{kind}")
+      end
+      @@yaml_path_resolvers[[[new_path], kind]] = tag
+    end
+
+    def descend_resolver(current_node, current_index)
+      exact_paths = {}
+      prefix_paths = []
+      if current_node
+        depth = @resolver_prefix_paths.length
+        for path, kind in @resolver_prefix_paths[-1]
+          if check_resolver_prefix(depth, path, kind,current_node, current_index)
+            if path.length > depth
+              prefix_paths << [path, kind]
+            else
+              exact_paths[kind] = @@yaml_path_resolvers[[path, kind]]
+            end
+          end
+        end
+      else
+        for path, kind in @@yaml_path_resolvers
+          if !path
+            exact_paths[kind] = @@yaml_path_resolvers[[path, kind]]
+          else
+            prefix_paths << [path, kind]
+          end
+        end
+      end
+      @resolver_exact_paths << exact_paths
+      @resolver_prefix_paths << prefix_paths
+    end
+
+    def ascend_resolver
+      @resolver_exact_paths.pop
+      @resolver_prefix_paths.pop
+    end
+
+    def check_resolver_prefix(depth, path, kind, current_node, current_index)
+      node_check, index_check = path[depth-1]
+      if String === node_check
+        return false if current_node.tag != node_check
+      elsif !node_check.nil?
+        return false if !node_check === current_node
+      end
+      return false if index_check==true && !current_index.nil?
+      return false if !index_check && current_index.nil?
+      if String === index_check
+        return false if !(ScalarNode === current_index && index_check == current_index.value)
+      elsif Integer === index_check
+        return false if index_check != current_index
+      end
+      true
+    end
+
+    def resolve(kind, value, implicit)
+      if ScalarNode == kind && implicit[0]
+        if value == ""
+          resolvers = @@yaml_implicit_resolvers.fetch("", [])
+        else
+          resolvers = @@yaml_implicit_resolvers.fetch(value[0], [])
+        end
+        resolvers += @@yaml_implicit_resolvers.fetch(nil, [])
+        for tag, regexp in resolvers
+          return tag if regexp =~ value
+        end
+        implicit = implicit[1]
+      end
+      exact_paths = @resolver_exact_paths[-1]
+      return exact_paths[kind] if exact_paths.include?(kind) 
+      return exact_paths[nil] if exact_paths.include?(nil)
+      if ScalarNode == kind
+        return RbYAML::DEFAULT_SCALAR_TAG
+      elsif SequenceNode == kind
+        return RbYAML::DEFAULT_SEQUENCE_TAG
+      elsif MappingNode == kind
+          return RbYAML::DEFAULT_MAPPING_TAG
+      end
+    end
+  end
+
+  module Resolver
+    include BaseResolver
+  end
+  
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:bool',/^(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:int',/^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?(?:0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$/,'-+0123456789')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:merge',/^(?:<<)$/,'<')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:null',/^(?: ~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:timestamp',/^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]|[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])?))?)$/,'0123456789')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:value',/^(?:=)$/,'=')
+  # The following implicit resolver is only for documentation purposes. It cannot work
+  # because plain scalars cannot start with '!', '&', or '*'.
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:yaml',/^(?:!|&|\*)$/,'!&*')
+end
+

data/lib/rbyaml/scanner.rb

@@ -579,10 +579,7 @@ module RbYAML
 
     def check_document_end
       # DOCUMENT-END:     ^ '...' (' '|'\n')
-      if @column == 0
-        prefix = peek(4)
-        return true if prefix(3) == "..." && "\0 \t\r\n\x85".include?(peek(3))
-      end
+      @column == 0 && prefix(3) == "..." && "\0 \t\r\n\x85".include?(peek(3))
     end
 
     def check_block_entry
@@ -1112,13 +1109,17 @@ module RbYAML
       while true
         length = 0
         break if peek == ?#
-          while true
-            ch = peek(length)
-            if "\0 \t\r\n\x85".include?(ch) || (@flow_level==0 && ch == ?: && "\0 \t\r\n\x28".include?(peek(length+1))) || (@flow_level!=0 && ",:?[]{}".include?(ch))
-              break
-            end
-            length += 1
+        while true
+          ch = peek(length)
+          if "\0 \t\r\n\x85".include?(ch) || (@flow_level==0 && ch == ?: && "\0 \t\r\n\x28".include?(peek(length+1))) || (@flow_level!=0 && ",:?[]{}".include?(ch))
+            break
           end
+          length += 1
+        end
+        if @flow_level != 0 && ch == ?: && !"\0 \t\r\n\x28[]{}".include?(peek(length+1))
+          forward(length)
+          raise ScannerError.new("while scanning a plain scalar",start_mark,"found unexpected ':'",get_mark,"Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.")
+        end
         break if length == 0
         @allow_simple_key = false
         chunks += spaces

data/lib/rbyaml/serializer.rb

@@ -48,7 +48,7 @@ module RbYAML
       end
       emit(DocumentStartEvent.new(@use_explicit_start,@use_version,@use_tags))
       anchor_node(node)
-      serialize_node(node)
+      serialize_node(node,nil,nil)
       emit(DocumentEndEvent.new(@use_explicit_end))
       @serialized_nodes = {}
       @anchors = {}
@@ -65,9 +65,9 @@ module RbYAML
             anchor_node(item)
           end
         elsif MappingNode === node
-          for key in node.value.keys
+          for key,val in node.value
             anchor_node(key)
-            anchor_node(node.value[key])
+            anchor_node(val)
           end
         end
       end
@@ -78,38 +78,33 @@ module RbYAML
       ANCHOR_TEMPLATE % @last_anchor_id
     end
     
-    def serialize_node(node)
+    def serialize_node(node,parent,index)
       talias = @anchors[node]
       if @serialized_nodes.include?(node)
         emit(AliasEvent.new(talias))
       else
         @serialized_nodes[node] = true
+        descend_resolver(parent, index)
         if ScalarNode === node
-          detected_tag = detect(node.value)
-          implicit = node.tag == detect(node.value) || (node.tag == DEFAULT_SCALAR_TAG && detected_tag.nil?)
+          detected_tag = resolve(ScalarNode, node.value, [true,false])
+          default_tag = resolve(ScalarNode, node.value, [false,true])
+          implicit = (node.tag == detected_tag), (node.tag == default_tag)
           emit(ScalarEvent.new(talias, node.tag, implicit, node.value,nil,nil,node.style))
         elsif SequenceNode === node
-          tag = node.tag
-          tag = nil if tag == DEFAULT_SEQUENCE_TAG && !@canonical
-          emit(SequenceStartEvent.new(talias, tag,nil,nil,node.flow_style))
+          implicit = (node.tag == resolve(SequenceNode, node.value, true))
+          emit(SequenceStartEvent.new(talias, node.tag, implicit,node.flow_style))
+          index = 0
           for item in node.value
-            serialize_node(item)
+            serialize_node(item,node,index)
+            index += 1
           end
           emit(SequenceEndEvent.new)
         elsif MappingNode === node
-          tag = node.tag
-          tag = nil if tag == DEFAULT_MAPPING_TAG && !@canonical
-          emit(MappingStartEvent.new(talias, tag,nil,nil,node.flow_style))
-          if node.value.respond_to?(:keys)
-            for key in node.value.keys
-              serialize_node(key)
-              serialize_node(node.value[key])
-            end
-          else
-            for key, value in node.value
-              serialize_node(key)
-              serialize_node(value)
-            end
+          implicit = (node.tag == resolve(MappingNode, node.value, true))
+          emit(MappingStartEvent.new(talias, node.tag, implicit,node.flow_style))
+          for key, value in node.value
+            serialize_node(key,node,nil)
+            serialize_node(value,node,key)
           end
           emit(MappingEndEvent.new)
         end

data/lib/rbyaml/tokens.rb

@@ -152,11 +152,12 @@ module RbYAML
     def tid
       "<scalar>"
     end
-    attr_reader :value, :implicit, :style
-    def initialize(value, implicit, start_mark, end_mark, style=nil)
+    attr_reader :value, :plain, :style
+    alias :implicit :plain #Until all references to ScalarToken.implicit has been removed
+    def initialize(value, plain, start_mark, end_mark, style=nil)
       super(start_mark, end_mark)
       @value = value
-      @implicit = implicit
+      @plain = plain
       @style = style
     end
   end

data/lib/rbyaml/yaml.rb

@@ -2,18 +2,6 @@ require 'stringio'
 
 require 'rbyaml/error'
 
-require 'rbyaml/reader'
-require 'rbyaml/scanner'
-require 'rbyaml/parser'
-require 'rbyaml/composer'
-require 'rbyaml/constructor'
-
-require 'rbyaml/emitter'
-require 'rbyaml/serializer'
-require 'rbyaml/representer'
-
-require 'rbyaml/detector'
-
 require 'rbyaml/tokens'
 require 'rbyaml/events'
 require 'rbyaml/nodes'
@@ -60,24 +48,24 @@ module RbYAML
     _load(stream, SafeLoader)
   end
 
-  def self._emit(events, stream=nil, dumper=Dumper,canonical=nil, indent=nil, width=nil,line_break=nil)
+  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,canonical,indent,width,line_break)
+    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,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  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,canonical,indent,width,line_break,version,tags,explicit_start,explicit_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)
@@ -90,12 +78,12 @@ module RbYAML
     _serialize_all([node], stream, dumper, *kwds)
   end
   
-  def self._dump_all(documents,stream=nil,dumper=Dumper,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  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,canonical,indent,width,line_break,version,tags,explicit_start,explicit_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)
@@ -116,13 +104,14 @@ module RbYAML
     _dump_all([data], stream, SafeDumper, *kwds)
   end
 
-  def self._add_detector(tag, regexp, first=nil, loader=Loader, dumper=Dumper)
-    loader.add_detector(tag, regexp, first)
-    dumper.add_detector(tag, regexp, first)
+  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_resolver(tag, path, loader=Loader)
-    loader.add_resolver(tag, path)
+  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)
@@ -133,11 +122,15 @@ module RbYAML
     loader.add_multi_constructor(tag_prefix, multi_constructor)
   end
 
-  def self._dump_ruby_object(data, dumper=Dumper)
-    _dump(data,nil,dumper)
+  def self._add_representer(data_type, representer, dumper=Dumper)
+    dumper.add_representer(data_type, representer)
   end
 
-  class SimpleDetector
-    include Detector
+  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_rbyaml.rb

@@ -11,8 +11,21 @@ class TestRbYAML < Test::Unit::TestCase
   end
 
   def test_basic_dump
-    assert_equal("A: b\nc: 3.14\n",RbYAML.dump({"A"=>"b","c"=>3.14}))
+    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

@@ -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"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: RbYAML
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2006-05-09 00:00:00 +02:00
+  version: 0.0.2
+date: 2006-05-19 00:00:00 -07:00
 summary: A pure Ruby YAML parser and emitter, mostly supporting YAML 1.1.
 require_paths: 
 - lib
@@ -32,7 +32,6 @@ files:
 - lib/rbyaml.rb
 - lib/rbyaml/composer.rb
 - lib/rbyaml/constructor.rb
-- lib/rbyaml/detector.rb
 - lib/rbyaml/dumper.rb
 - lib/rbyaml/emitter.rb
 - lib/rbyaml/error.rb
@@ -42,12 +41,14 @@ files:
 - lib/rbyaml/parser.rb
 - lib/rbyaml/reader.rb
 - lib/rbyaml/representer.rb
+- lib/rbyaml/resolver.rb
 - lib/rbyaml/scanner.rb
 - lib/rbyaml/serializer.rb
 - lib/rbyaml/test.rb
 - lib/rbyaml/tokens.rb
 - lib/rbyaml/yaml.rb
 - test/test_rbyaml.rb
+- test/test_time.rb
 - test/yaml
 - test/yaml/gems.yml
 - test/yaml/gems2.yml

data/lib/rbyaml/detector.rb

@@ -1,44 +0,0 @@
-  
-module RbYAML
-  DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
-  DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
-  DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
-  
-  module BaseDetector
-    @@yaml_detectors = {}
-    
-    def self.add_detector(tag, regexp, first)
-      first.each_byte { |ch|
-        @@yaml_detectors[ch] ||= []
-        @@yaml_detectors[ch] << [tag,regexp]
-      }
-    end
-    
-    def detect(value)
-      if value == ""
-        detectors = @@yaml_detectors.fetch(?\0, [])
-      else
-        detectors = @@yaml_detectors.fetch(value[0], [])
-      end
-      detectors += @@yaml_detectors.fetch(nil, [])
-      for tag, regexp in detectors
-        return tag if regexp =~ value
-      end
-      nil
-    end 
-  end
-  module Detector 
-    include BaseDetector
-  end
-  
-  BaseDetector.add_detector('tag:yaml.org,2002:bool',/^(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
-  BaseDetector.add_detector('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
-  BaseDetector.add_detector('tag:yaml.org,2002:int',/^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?(?:0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$/,'-+0123456789')
-  BaseDetector.add_detector('tag:yaml.org,2002:merge',/^(?:<<)$/,'<')
-  BaseDetector.add_detector('tag:yaml.org,2002:null',/^(?: ~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
-  BaseDetector.add_detector('tag:yaml.org,2002:timestamp',/^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]|[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])?))?)$/,'0123456789')
-  BaseDetector.add_detector('tag:yaml.org,2002:value',/^(?:=)$/,'=')
-  # The following detector is only for documentation purposes. It cannot work
-  # because plain scalars cannot start with '!', '&', or '*'.
-  BaseDetector.add_detector('tag:yaml.org,2002:yaml',/^(?:!|&|\*)$/,'!&*')
-end