RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/events.rb

@@ -1,6 +1,4 @@
-
 module RbYAML
-  Event = Struct.new(:start_mark,:end_mark)
   class Event
     def hash
       object_id
@@ -27,8 +25,7 @@ module RbYAML
   
   class NodeEvent < Event
     attr_reader :anchor
-    def initialize(anchor, start_mark=nil, end_mark=nil)
-      super(start_mark,end_mark)
+    def initialize(anchor)
       @anchor = anchor
     end
     def __is_node; true; end
@@ -36,8 +33,8 @@ module RbYAML
 
   class CollectionStartEvent < NodeEvent
     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)
+    def initialize(anchor,tag,implicit,flow_style=nil)
+      super(anchor)
       @tag = tag
       @implicit = implicit
       @flow_style = flow_style        
@@ -51,8 +48,7 @@ module RbYAML
 
   class StreamStartEvent < Event
     attr_reader :encoding
-    def initialize(start_mark=nil,end_mark=nil,encoding=nil)
-      super(start_mark,end_mark)
+    def initialize(encoding=nil)
       @encoding = encoding
     end
     def __is_stream_start; true; end
@@ -64,8 +60,7 @@ module RbYAML
 
   class DocumentStartEvent < Event
     attr_reader :explicit, :version, :tags
-    def initialize(start_mark=nil,end_mark=nil,explicit=nil,version=nil,tags=nil)
-      super(start_mark,end_mark)
+    def initialize(explicit=nil,version=nil,tags=nil)
       @explicit = explicit
       @version = version
       @tags = tags
@@ -75,8 +70,7 @@ module RbYAML
 
   class DocumentEndEvent < Event
     attr_reader :explicit
-    def initialize(start_mark=nil,end_mark=nil,explicit=nil)
-      super(start_mark,end_mark)
+    def initialize(explicit=nil)
       @explicit = explicit
     end
     def __is_document_end; true; end
@@ -88,8 +82,8 @@ module RbYAML
 
   class ScalarEvent < NodeEvent
     attr_reader :tag, :style, :value, :implicit
-    def initialize(anchor,tag,implicit,value,start_mark=nil, end_mark=nil,style=nil)
-      super(anchor,start_mark,end_mark)
+    def initialize(anchor,tag,implicit,value,style=nil)
+      super(anchor)
       @tag = tag
       @style = style
       @value = value

data/lib/rbyaml/{events.rb.~1.2.~ → events.rb.~1.4.~}

@@ -1,17 +1,27 @@
-
 module RbYAML
+  Event = Struct.new(:start_mark,:end_mark)
   class Event
-    attr_reader :start_mark, :end_mark
-    def initialize(start_mark=nil,end_mark=nil)
-      @start_mark = start_mark
-      @end_mark = end_mark
+    def hash
+      object_id
     end
-
     def to_s
       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
+    def __is_node; false; end
+    def __is_collection_start; false; end
+    def __is_collection_end; false; end
+    def __is_stream_start; false; end
+    def __is_stream_end; false; end
+    def __is_document_start; false; end
+    def __is_document_end; false; end
+    def __is_alias; false; end
+    def __is_scalar; false; end
+    def __is_sequence_start; false; end
+    def __is_sequence_end; false; end
+    def __is_mapping_start; false; end
+    def __is_mapping_end; false; end
   end
   
   class NodeEvent < Event
@@ -20,6 +30,7 @@ module RbYAML
       super(start_mark,end_mark)
       @anchor = anchor
     end
+    def __is_node; true; end
   end
 
   class CollectionStartEvent < NodeEvent
@@ -30,9 +41,11 @@ module RbYAML
       @implicit = implicit
       @flow_style = flow_style        
     end
+    def __is_collection_start; true; end
   end
 
   class CollectionEndEvent < Event
+    def __is_collection_end; true; end
   end
 
   class StreamStartEvent < Event
@@ -41,9 +54,11 @@ module RbYAML
       super(start_mark,end_mark)
       @encoding = encoding
     end
+    def __is_stream_start; true; end
   end
 
   class StreamEndEvent < Event
+    def __is_stream_end; true; end
   end
 
   class DocumentStartEvent < Event
@@ -54,6 +69,7 @@ module RbYAML
       @version = version
       @tags = tags
     end
+    def __is_document_start; true; end
   end
 
   class DocumentEndEvent < Event
@@ -62,9 +78,11 @@ module RbYAML
       super(start_mark,end_mark)
       @explicit = explicit
     end
+    def __is_document_end; true; end
   end
 
   class AliasEvent < NodeEvent
+    def __is_alias; true; end
   end
 
   class ScalarEvent < NodeEvent
@@ -76,18 +94,23 @@ module RbYAML
       @value = value
       @implicit = implicit
     end
+    def __is_scalar; true; end
   end
 
   class SequenceStartEvent < CollectionStartEvent
+    def __is_sequence_start; true; end
   end
 
   class SequenceEndEvent < CollectionEndEvent
+    def __is_sequence_end; true; end
   end
 
   class MappingStartEvent < CollectionStartEvent
+    def __is_mapping_start; true; end
   end
 
   class MappingEndEvent < CollectionEndEvent
+    def __is_mapping_end; true; end
   end
 end
 

data/lib/rbyaml/nodes.rb

@@ -1,6 +1,6 @@
 
 module RbYAML
-  Node = Struct.new(:tag, :value, :start_mark, :end_mark)
+  Node = Struct.new(:tag, :value)
   class Node
     def hash
       object_id
@@ -22,8 +22,8 @@ module RbYAML
     
     attr_accessor :style
     
-    def initialize(tag, value,start_mark=nil,end_mark=nil,style=nil)
-      super(tag,value,start_mark,end_mark)
+    def initialize(tag,value,style=nil)
+      super(tag,value)
       @style = style
     end
     def __is_scalar; true; end
@@ -32,8 +32,8 @@ module RbYAML
   class CollectionNode < Node
     attr_accessor :flow_style
     
-    def initialize(tag, value,start_mark=nil,end_mark=nil,flow_style=nil)
-      super(tag,value,start_mark,end_mark)
+    def initialize(tag, value,flow_style=nil)
+      super(tag,value)
       @flow_style = flow_style
     end
     def __is_collection; true; end

data/lib/rbyaml/{nodes.rb.~1.2.~ → nodes.rb.~1.3.~}

@@ -1,18 +1,18 @@
 
 module RbYAML
+  Node = Struct.new(:tag, :value, :start_mark, :end_mark)
   class Node
-    attr_accessor :tag, :value, :start_mark, :end_mark
-    
-    def initialize(tag, value, start_mark, end_mark)
-      @tag = tag
-      @value = value
-      @start_mark = start_mark
-      @end_mark = end_mark
+    def hash
+      object_id
     end
-    
     def to_s
-      "#{self.class.name}(tag=#{@tag}, value=#{@value})"
+      "#{self.class.name}(tag=#{tag}, value=#{value})"
     end
+
+    def __is_scalar; false; end
+    def __is_collection; false; end
+    def __is_sequence; false; end
+    def __is_mapping; false; end
   end
   
   class ScalarNode < Node
@@ -26,6 +26,7 @@ module RbYAML
       super(tag,value,start_mark,end_mark)
       @style = style
     end
+    def __is_scalar; true; end
   end
   
   class CollectionNode < Node
@@ -35,18 +36,21 @@ module RbYAML
       super(tag,value,start_mark,end_mark)
       @flow_style = flow_style
     end
+    def __is_collection; true; end
   end
   
   class SequenceNode < CollectionNode
     def tid
       "sequence"
     end
+    def __is_sequence; true; end
   end
   
   class MappingNode < CollectionNode
     def tid
       "mapping"
     end
+    def __is_mapping; true; end
   end
 end
 

data/lib/rbyaml/parser.rb

@@ -50,7 +50,7 @@ require 'rbyaml/events'
 require 'rbyaml/scanner'
 
 module RbYAML
-  class ParserError < MarkedYAMLError
+  class ParserError < YAMLError
   end
 
   class Parser
@@ -59,6 +59,14 @@ module RbYAML
       '!!' => 'tag:yaml.org,2002:'
     }
 
+    DOCUMENT_END_TRUE = DocumentEndEvent.new(true)
+    DOCUMENT_END_FALSE = DocumentEndEvent.new(false)
+    MAPPING_END = MappingEndEvent.new
+    SEQUENCE_END = SequenceEndEvent.new
+    STREAM_END = StreamEndEvent.new
+    STREAM_START = StreamStartEvent.new
+    
+
     def initialize(scanner)
       @scanner = scanner
       @current_event = nil
@@ -67,9 +75,6 @@ module RbYAML
       @working_events = nil
       @tag_handles = { }
       @parse_stack = nil
-      @start_mark = []
-      @tks = []
-
     end
 
     def check_event(*choices)
@@ -108,11 +113,8 @@ module RbYAML
     def parse_stream
       if !@parse_stack
         @parse_stack = [:stream]
-        @tokens = nil
         @tags = []
         @anchors = []
-        @start_marks = []
-        @end_marks = []
       end
     end
 
@@ -129,11 +131,8 @@ module RbYAML
           end
         end
       else
-        @tokens = nil
         @tags = []
         @anchors = []
-        @start_marks = []
-        @end_marks = []
         return nil
       end
     end
@@ -141,140 +140,125 @@ module RbYAML
 #TERMINALS, definitions
 
     def stream_start
-      token = @scanner.get_token
-      StreamStartEvent.new(token.start_mark, token.end_mark,token.encoding)
+      @scanner.get_token
+      STREAM_START
     end
 
     def stream_end
-      token = @scanner.get_token
-      StreamEndEvent.new(token.start_mark, token.end_mark)
+      @scanner.get_token
+      STREAM_END
     end
     
     def document_start_implicit
       token = @scanner.peek_token
       version, tags = process_directives
-      DocumentStartEvent.new(token.start_mark,token.start_mark,false)
+      DocumentStartEvent.new(false,version,tags)
     end
 
     def document_start
       token = @scanner.peek_token
-      start_mark = token.start_mark
       version, tags = process_directives
-      raise ParserError.new(nil, nil,"expected '<document start>', but found #{token.tid}",token.start_mark) unless @scanner.peek_token.__is_document_start
-      @token = token = @scanner.get_token
-      end_mark = token.end_mark
-      DocumentStartEvent.new(start_mark, end_mark,true,version,tags)
+      raise ParserError.new(nil, "expected '<document start>', but found #{token.tid}") unless @scanner.peek_token.__is_document_start
+      @scanner.get_token
+      DocumentStartEvent.new(true,version,tags)
     end
 
     def document_end
       token = @scanner.peek_token
-      start_mark = end_mark = token.start_mark
       explicit = false
       while @scanner.peek_token.__is_document_end
-        @tokens = token = @scanner.get_token
-        end_mark = token.end_mark
+        @scanner.get_token
         explicit = true
       end
-      DocumentEndEvent.new(start_mark, end_mark, explicit)
+      explicit ? DOCUMENT_END_TRUE : DOCUMENT_END_FALSE
     end
 
     def _alias
-      token = @scanner.get_token
-      AliasEvent.new(token.value, token.start_mark, token.end_mark)
+      AliasEvent.new(@scanner.get_token.value)
     end
 
     def block_sequence_start
-      end_mark = @scanner.peek_token.start_mark
-      implicit = @tags.last.nil? || @tags.last == ?!
-      @tokens = token = @scanner.get_token
-      SequenceStartEvent.new(@anchors.last, @tags.last, implicit, @start_marks.last, end_mark,false)
+      implicit = @tags.last.nil? || @tags.last == "!"
+      @scanner.get_token
+      SequenceStartEvent.new(@anchors.last, @tags.last, implicit, false)
     end
 
     def block_indentless_sequence_start
-      end_mark = @scanner.peek_token.end_mark
-      implicit = @tags.last.nil? || @tags.last == ?!
-      SequenceStartEvent.new(@anchors.last, @tags.last, implicit, @start_marks.last, end_mark,false)
+      implicit = @tags.last.nil? || @tags.last == "!"
+      SequenceStartEvent.new(@anchors.last, @tags.last, implicit, false)
     end
 
     def block_sequence_end
       if !@scanner.peek_token.__is_block_end
-        token = @scanner.peek_token
-        raise ParserError.new("while scanning a block collection", @start_marks.last,"expected <block end>, but found #{token.tid}: #{token.inspect}", token.start_mark)
+        raise ParserError.new("while scanning a block collection","expected <block end>, but found #{token.tid}: #{token.inspect}")
       end
-      token = @scanner.get_token
-      SequenceEndEvent.new(token.start_mark, token.end_mark)
+      @scanner.get_token
+      SEQUENCE_END
     end
 
     def block_indentless_sequence_end
-      @tokens = token = @scanner.peek_token
-      SequenceEndEvent.new(token.start_mark, token.end_mark)
+      SEQUENCE_END
     end
 
     def block_mapping_start
-      end_mark = @scanner.peek_token.start_mark
-      implicit = @tags.last.nil? || @tags.last == ?!
-      @tokens = token = @scanner.get_token
-      MappingStartEvent.new(@anchors.last, @tags.last, implicit, @start_marks.last, end_mark,false)
+      implicit = @tags.last.nil? || @tags.last == "!"
+      @scanner.get_token
+      MappingStartEvent.new(@anchors.last, @tags.last, implicit,false)
     end
 
     def block_mapping_end
       if !@scanner.peek_token.__is_block_end
-        token = @scanner.peek_token
-        raise ParserError.new("while scanning a block mapping", @start_marks.last,"expected <block end>, but found #{token.tid}", token.start_mark)
+        raise ParserError.new("while scanning a block mapping","expected <block end>, but found #{token.tid}")
       end
-      @tokens = token = @scanner.get_token
-      MappingEndEvent.new(token.start_mark, token.end_mark)
+      @scanner.get_token
+      MAPPING_END
     end
 
     def flow_sequence_start
-      end_mark = @scanner.peek_token.end_mark
-      implicit = @tags.last.nil? || @tags.last == ?!
-      @tokens = token = @scanner.get_token
-      SequenceStartEvent.new(@anchors.last, @tags.last, implicit, @start_marks.last, end_mark,true)
+      implicit = @tags.last.nil? || @tags.last == "!"
+      @scanner.get_token
+      SequenceStartEvent.new(@anchors.last, @tags.last, implicit,true)
     end
 
     def flow_sequence_end
-      @tokens = token = @scanner.get_token
-      SequenceEndEvent.new(token.start_mark, token.end_mark)
+      @scanner.get_token
+      SEQUENCE_END
     end
 
     def flow_internal_mapping_start
-      @tokens = token = @scanner.get_token
-      MappingStartEvent.new(nil,nil,true,token.start_mark, token.end_mark,true)
+      @scanner.get_token
+      MappingStartEvent.new(nil,nil,true,true)
     end
 
     def flow_internal_mapping_end
-      token = peek_token
-      MappingEndEvent.new(token.start_mark, token.start_mark)
+      MAPPING_END
     end
 
     def flow_mapping_start
-      end_mark = @scanner.peek_token.end_mark
-      implicit = @tags.last.nil? || @tags.last == ?!
-      @tokens = token = @scanner.get_token
-      MappingStartEvent.new(@anchors.last, @tags.last, implicit, @start_marks.last, end_mark,true)
+      implicit = @tags.last.nil? || @tags.last == "!"
+      @scanner.get_token
+      MappingStartEvent.new(@anchors.last, @tags.last, implicit,true)
     end
 
     def flow_mapping_end
-      @tokens = token = @scanner.get_token
-      MappingEndEvent.new(token.start_mark, token.end_mark)
+      @scanner.get_token
+      MAPPING_END
     end
 
     def scalar
       token = @scanner.get_token
-      end_mark = token.end_mark
-      if (token.plain && @tags.last.nil?) || @tags.last == ?!
+      if (token.plain && @tags.last.nil?) || @tags.last == "!"
         implicit = [true, false]
       elsif @tags.last.nil?
         implicit = [false, true]
       else
         implicit = [false, false]
       end
-      ScalarEvent.new(@anchors.last, @tags.last, implicit, token.value, @start_marks.last, end_mark, token.style)
+      ScalarEvent.new(@anchors.last, @tags.last, implicit, token.value,token.style)
     end
 
     def empty_scalar
-      process_empty_scalar(@tokens.end_mark)
+      process_empty_scalar
     end
     
 
@@ -329,54 +313,35 @@ module RbYAML
     def properties
       anchor = nil
       tag = nil
-      start_mark = end_mark = tag_mark = nil
       if @scanner.peek_token.__is_anchor
-        token = @scanner.get_token
-        start_mark = token.start_mark
-        end_mark = token.end_mark
-        anchor = token.value
+        anchor = @scanner.get_token.value
         if @scanner.peek_token.__is_tag
-          token = @scanner.get_token
-          tag_mark = token.start_mark
-          end_mark = token.end_mark
-          tag = token.value
+          tag = @scanner.get_token.value
         end
       elsif @scanner.peek_token.__is_tag
-        token = @scanner.get_token
-        start_mark = tag_mark = token.start_mark
-        end_mark = token.end_mark
-        tag = token.value
+        tag = @scanner.get_token.value
         if @scanner.peek_token.__is_anchor
-          token = @scanner.get_token
-          end_mark = token.end_mark
-          anchor = token.value
+          anchor = @scanner.get_token.value
         end
       end
       
       if !tag.nil? and tag != "!"
         handle, suffix = tag
         if !handle.nil?
-          raise ParserError.new("while parsing a node", start_mark,"found undefined tag handle #{handle}",tag_mark) if !@tag_handles.include?(handle)
+          raise ParserError.new("while parsing a node","found undefined tag handle #{handle}") if !@tag_handles.include?(handle)
           tag = @tag_handles[handle]+suffix
         else
           tag = suffix
         end
       end
-      if start_mark.nil?
-        start_mark = end_mark = @scanner.peek_token.start_mark
-      end
       @anchors << anchor
       @tags << tag
-      @start_marks << start_mark
-      @end_marks << end_mark
       nil
     end
 
     def un_properties
       @anchors.pop
       @tags.pop
-      @start_marks.pop
-      @end_marks.pop
       nil
     end
 
@@ -393,7 +358,7 @@ module RbYAML
       elsif token.__is_scalar
         return scalar
       else
-        raise ParserError.new("while scanning a node", @start_marks.last,"expected the node content, but found #{token.tid}",token.start_mark)
+        raise ParserError.new("while scanning a node","expected the node content, but found #{token.tid}")
       end
     end
 
@@ -406,13 +371,13 @@ module RbYAML
       elsif token.__is_scalar
         return scalar
       else
-        raise ParserError.new("while scanning a flow node", @start_marks.last,"expected the node content, but found #{token.tid}",token.start_mark)
+        raise ParserError.new("while scanning a flow node","expected the node content, but found #{token.tid}")
       end
     end
 
     def block_sequence_entry
       if @scanner.peek_token.__is_block_entry
-        @tokens = token = @scanner.get_token
+        @scanner.get_token
         if !(@scanner.peek_token.__is_block_entry || @scanner.peek_token.__is_block_end)
           @parse_stack += [:block_sequence_entry]
           return block_node
@@ -428,7 +393,7 @@ module RbYAML
       #   ((KEY block_node_or_indentless_sequence?)? (VALUE block_node_or_indentless_sequence?)?)*
       if @scanner.peek_token.__is_key || @scanner.peek_token.__is_value
         if @scanner.check_token(KeyToken)
-          @tokens = token = @scanner.get_token
+          @scanner.get_token
           curr = @scanner.peek_token
           if !(curr.__is_key || curr.__is_value || curr.__is_block_end)
             @parse_stack += [:block_mapping_entry,:block_mapping_entry_value]
@@ -448,7 +413,7 @@ module RbYAML
     def block_mapping_entry_value
       if @scanner.peek_token.__is_key || @scanner.peek_token.__is_value
         if @scanner.peek_token.__is_value
-          @tokens = token = @scanner.get_token
+          @scanner.get_token
           curr = @scanner.peek_token
           if !(curr.__is_key || curr.__is_value || curr.__is_block_end)
             return block_node_or_indentless_sequence
@@ -456,7 +421,6 @@ module RbYAML
             return empty_scalar
           end
         else
-          @tokens = token = @scanner.peek_token
           return empty_scalar
         end
       end
@@ -494,7 +458,7 @@ module RbYAML
 
     def indentless_block_sequence_entry
       if @scanner.peek_token.__is_block_entry
-        @tokens = @scanner.get_token
+        @scanner.get_token
         curr = @scanner.peek_token
         if !(curr.__is_block_entry || curr.__is_key || curr.__is_value || curr.__is_block_end)
           @parse_stack << :indentless_block_sequence_entry
@@ -541,14 +505,13 @@ module RbYAML
 
     def flow_internal_value
       if @scanner.peek_token.__is_value
-        @tokens = token = @scanner.get_token
+        @scanner.get_token
         if !(@scanner.peek_token.__is_flow_entry || @scanner.peek_token.__is_flow_sequence_end)
           flow_node
         else
           empty_scalar
         end
       else
-        @tokens = token = @scanner.peek_token
         empty_scalar
       end
     end
@@ -576,7 +539,7 @@ module RbYAML
     def flow_mapping_internal_content
       curr = @scanner.peek_token
       if !(curr.__is_value || curr.__is_flow_entry || curr.__is_flow_mapping_end)
-        @tokens = token = @scanner.get_token
+        @scanner.get_token
         flow_node
       else
         empty_scalar
@@ -585,14 +548,13 @@ module RbYAML
 
     def flow_mapping_internal_value
       if @scanner.peek_token.__is_value
-        @tokens = token = @scanner.get_token
+        @scanner.get_token
         if !(@scanner.peek_token.__is_flow_entry || @scanner.peek_token.__is_flow_mapping_end)
           flow_node
         else
           empty_scalar
         end
       else
-        @tokens = token = @scanner.peek_token
         empty_scalar
       end
     end
@@ -603,13 +565,13 @@ module RbYAML
       while @scanner.peek_token.__is_directive
         token = @scanner.get_token
         if token.name == "YAML"
-          raise ParserError.new(nil, nil,"found duplicate YAML directive", token.start_mark) if !@yaml_version.nil?
+          raise ParserError.new(nil,"found duplicate YAML directive") if !@yaml_version.nil?
           major, minor = token.value[0].to_i, token.value[1].to_i
-          raise ParserError.new(nil,nil,"found incompatible YAML document (version 1.* is required)",token.start_mark) if major != 1
+          raise ParserError.new(nil,"found incompatible YAML document (version 1.* is required)") if major != 1
           @yaml_version = [major,minor]
         elsif token.name == "TAG"
           handle, prefix = token.value
-          raise ParserError.new(nil,nil,"duplicate tag handle #{handle}",token.start_mark) if @tag_handles.member?(handle)
+          raise ParserError.new(nil,"duplicate tag handle #{handle}") if @tag_handles.member?(handle)
           @tag_handles[handle] = prefix
         end
       end
@@ -624,8 +586,8 @@ module RbYAML
       value
     end
 
-    def process_empty_scalar(mark)
-      ScalarEvent.new(nil, nil, [true, false], "", mark, mark)
+    def process_empty_scalar
+      ScalarEvent.new(nil, nil, [true, false], "")
     end
   end
 end