RbYAML 0.0.2 → 0.1.0

data/lib/rbyaml/error.rb

@@ -1,49 +1,44 @@
 
 module RbYAML
+  Mark = Struct.new(:name,:column,:buffer,:pointer)
   class Mark
-    attr_reader :name,:index,:line,:column,:buffer,:pointer
-    def initialize(name, index, line, column, buffer, pointer)
-      @name = name
-      @index = index
-      @line = line
-      @column = column
-      @buffer = buffer
-      @pointer = pointer
-    end
-    
     def get_snippet(indent=4, max_length=75)
-      return nil if @buffer.nil?
+      return nil if buffer.nil?
       head = ""
-      start = @pointer
-      while start > 0 && !"\0\r\n\x85".include?(@buffer[start-1])
+      start = pointer
+      while start > 0 && !"\0\r\n\x85".include?(buffer[start-1])
         start -= 1
-        if @pointer-start > max_length/2-1
+        if pointer-start > max_length/2-1
           head = " ... "
           start += 5
           break
         end
       end
       tail = ""
-      tend = @pointer
-      while tend < @buffer.length && !"\0\r\n\x85".include?(@buffer[tend])
+      tend = pointer
+      while tend < buffer.length && !"\0\r\n\x85".include?(buffer[tend])
         tend += 1
-        if tend-@pointer > max_length/2-1
+        if tend-pointer > max_length/2-1
           tail = " ... "
           tend -= 5
           break
         end
       end
-      snippet = @buffer[start..tend]
-      ' ' * indent + "#{head}#{snippet}#{tail}\n" + ' '*(indent+@pointer-start+head.length) + ' '
+      snippet = buffer[start..tend]
+      ' ' * indent + "#{head}#{snippet}#{tail}\n" + ' '*(indent+pointer-start+head.length) + ' '
     end
     
     def to_s
       snippet = get_snippet()
-      where = "  in \"#{@name}\", line #{@line+1}, column #{@column+1}"
+      where = "  in \"#{name}\", line ?, column #{column+1}"
       if snippet
         where << ":\n" << snippet
       end
     end
+
+    def hash
+      object_id
+    end
   end
   
   class YAMLError < StandardError
@@ -68,7 +63,6 @@ module RbYAML
       lines << @context if @context
       if @context_mark && (@problem.nil? || @problem_mark.nil? || 
                            @context_mark.name != @problem_mark.name ||
-                           @context_mark.line != @problem_mark.line ||
                            @context_mark.column != @problem_mark.column)
         lines << @context_mark.to_s          
       end

data/lib/rbyaml/events.rb

@@ -1,17 +1,28 @@
 
 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 +31,7 @@ module RbYAML
       super(start_mark,end_mark)
       @anchor = anchor
     end
+    def __is_node; true; end
   end
 
   class CollectionStartEvent < NodeEvent
@@ -30,9 +42,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 +55,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 +70,7 @@ module RbYAML
       @version = version
       @tags = tags
     end
+    def __is_document_start; true; end
   end
 
   class DocumentEndEvent < Event
@@ -62,9 +79,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 +95,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/events.rb.~1.2.~

@@ -0,0 +1,93 @@
+
+module RbYAML
+  class Event
+    attr_reader :start_mark, :end_mark
+    def initialize(start_mark=nil,end_mark=nil)
+      @start_mark = start_mark
+      @end_mark = end_mark
+    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
+  end
+  
+  class NodeEvent < Event
+    attr_reader :anchor
+    def initialize(anchor, start_mark=nil, end_mark=nil)
+      super(start_mark,end_mark)
+      @anchor = anchor
+    end
+  end
+
+  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)
+      @tag = tag
+      @implicit = implicit
+      @flow_style = flow_style        
+    end
+  end
+
+  class CollectionEndEvent < Event
+  end
+
+  class StreamStartEvent < Event
+    attr_reader :encoding
+    def initialize(start_mark=nil,end_mark=nil,encoding=nil)
+      super(start_mark,end_mark)
+      @encoding = encoding
+    end
+  end
+
+  class StreamEndEvent < Event
+  end
+
+  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)
+      @explicit = explicit
+      @version = version
+      @tags = tags
+    end
+  end
+
+  class DocumentEndEvent < Event
+    attr_reader :explicit
+    def initialize(start_mark=nil,end_mark=nil,explicit=nil)
+      super(start_mark,end_mark)
+      @explicit = explicit
+    end
+  end
+
+  class AliasEvent < NodeEvent
+  end
+
+  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)
+      @tag = tag
+      @style = style
+      @value = value
+      @implicit = implicit
+    end
+  end
+
+  class SequenceStartEvent < CollectionStartEvent
+  end
+
+  class SequenceEndEvent < CollectionEndEvent
+  end
+
+  class MappingStartEvent < CollectionStartEvent
+  end
+
+  class MappingEndEvent < CollectionEndEvent
+  end
+end
+

data/lib/rbyaml/loader.rb

@@ -1,6 +1,5 @@
 # This is a more or less straight translation of PyYAML3000 to Ruby
 
-require 'rbyaml/reader'
 require 'rbyaml/scanner'
 require 'rbyaml/parser'
 require 'rbyaml/composer'
@@ -9,43 +8,32 @@ require 'rbyaml/resolver'
 
 module RbYAML
   class CommonLoader
-    include Reader, Scanner, Parser
-    
-    def initialize(stream)
-      super()
-      initialize_reader(stream)
-      initialize_scanner
-      initialize_parser
+    attr_accessor :scanner, :parser, :composer, :constructor, :resolver
+
+    def initialize(stream,scanner=Scanner,parser=Parser,composer=Composer,constructor=BaseConstructor,resolver=BaseResolver)
+      @scanner = scanner.new(stream)
+      @parser = parser.new(@scanner)
+      @resolver = resolver.new
+      @composer = composer.new(@parser,@resolver)
+      @constructor = constructor.new(@composer)
     end
   end
   
   class BaseLoader < CommonLoader
-    include Composer, BaseConstructor, BaseResolver
     def initialize(stream)
-      super
-      initialize_composer
-      initialize_constructor
-      initialize_resolver
+      super(stream,Scanner,Parser,Composer,BaseConstructor,BaseResolver)
     end
   end
   
   class SafeLoader < CommonLoader
-    include Composer, SafeConstructor, Resolver
     def initialize(stream)
-      super
-      initialize_composer
-      initialize_constructor
-      initialize_resolver
+      super(stream,Scanner,Parser,Composer,SafeConstructor,Resolver)
     end
   end
   
   class Loader < CommonLoader
-    include Composer, Constructor, Resolver
     def initialize(stream)
-      super
-      initialize_composer
-      initialize_constructor
-      initialize_resolver
+      super(stream,Scanner,Parser,Composer,Constructor,Resolver)
     end
   end
 end

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

@@ -0,0 +1,52 @@
+# This is a more or less straight translation of PyYAML3000 to Ruby
+
+require 'rbyaml/reader'
+require 'rbyaml/scanner'
+require 'rbyaml/parser'
+require 'rbyaml/composer'
+require 'rbyaml/constructor'
+require 'rbyaml/resolver'
+
+module RbYAML
+  class CommonLoader
+    include Reader, Scanner, Parser
+    
+    def initialize(stream)
+      super()
+      initialize_reader(stream)
+      initialize_scanner
+      initialize_parser
+    end
+  end
+  
+  class BaseLoader < CommonLoader
+    include Composer, BaseConstructor, BaseResolver
+    def initialize(stream)
+      super
+      initialize_composer
+      initialize_constructor
+      initialize_resolver
+    end
+  end
+  
+  class SafeLoader < CommonLoader
+    include Composer, SafeConstructor, Resolver
+    def initialize(stream)
+      super
+      initialize_composer
+      initialize_constructor
+      initialize_resolver
+    end
+  end
+  
+  class Loader < CommonLoader
+    include Composer, Constructor, Resolver
+    def initialize(stream)
+      super
+      initialize_composer
+      initialize_constructor
+      initialize_resolver
+    end
+  end
+end
+

data/lib/rbyaml/nodes.rb

@@ -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/nodes.rb.~1.2.~

@@ -0,0 +1,52 @@
+
+module RbYAML
+  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
+    end
+    
+    def to_s
+      "#{self.class.name}(tag=#{@tag}, value=#{@value})"
+    end
+  end
+  
+  class ScalarNode < Node
+    def tid
+      "scalar"
+    end
+    
+    attr_accessor :style
+    
+    def initialize(tag, value,start_mark=nil,end_mark=nil,style=nil)
+      super(tag,value,start_mark,end_mark)
+      @style = style
+    end
+  end
+  
+  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)
+      @flow_style = flow_style
+    end
+  end
+  
+  class SequenceNode < CollectionNode
+    def tid
+      "sequence"
+    end
+  end
+  
+  class MappingNode < CollectionNode
+    def tid
+      "mapping"
+    end
+  end
+end
+