RbYAML 0.0.2 → 0.1.0

data/lib/rbyaml/serializer.rb

@@ -6,10 +6,12 @@ module RbYAML
   class SerializerError < YAMLError
   end
 
-  module Serializer
+  class Serializer
     ANCHOR_TEMPLATE = "id%03d"
 
-    def initialize_serializer(explicit_start=nil, explicit_end=nil, version=nil, tags=nil)
+    def initialize(emitter, resolver, explicit_start=nil, explicit_end=nil, version=nil, tags=nil)
+      @emitter = emitter
+      @resolver = resolver
       @use_explicit_start = explicit_start
       @use_explicit_end = explicit_end
       @use_version = version
@@ -22,7 +24,7 @@ module RbYAML
 
     def open
       if @closed.nil?
-        emit(StreamStartEvent.new)
+        @emitter.emit(StreamStartEvent.new)
         @closed = false
       elsif @closed
         raise SerializerError.new("serializer is closed")
@@ -35,7 +37,7 @@ module RbYAML
       if @closed.nil?
         raise SerializerError.new("serializer is not opened")
       elsif !@closed
-        emit(StreamEndEvent.new)
+        @emitter.emit(StreamEndEvent.new)
         @closed = true
       end
     end
@@ -46,10 +48,10 @@ module RbYAML
       elsif @closed
         raise SerializerError.new("serializer is closed")
       end
-      emit(DocumentStartEvent.new(@use_explicit_start,@use_version,@use_tags))
+      @emitter.emit(DocumentStartEvent.new(@use_explicit_start,@use_version,@use_tags))
       anchor_node(node)
       serialize_node(node,nil,nil)
-      emit(DocumentEndEvent.new(@use_explicit_end))
+      @emitter.emit(DocumentEndEvent.new(@use_explicit_end))
       @serialized_nodes = {}
       @anchors = {}
       @last_alias_id = 0
@@ -81,32 +83,32 @@ module RbYAML
     def serialize_node(node,parent,index)
       talias = @anchors[node]
       if @serialized_nodes.include?(node)
-        emit(AliasEvent.new(talias))
+        @emitter.emit(AliasEvent.new(talias))
       else
         @serialized_nodes[node] = true
-        descend_resolver(parent, index)
+        @resolver.descend_resolver(parent, index)
         if ScalarNode === node
-          detected_tag = resolve(ScalarNode, node.value, [true,false])
-          default_tag = resolve(ScalarNode, node.value, [false,true])
+          detected_tag = @resolver.resolve(ScalarNode, node.value, [true,false])
+          default_tag = @resolver.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))
+          @emitter.emit(ScalarEvent.new(talias, node.tag, implicit, node.value,nil,nil,node.style))
         elsif SequenceNode === node
-          implicit = (node.tag == resolve(SequenceNode, node.value, true))
-          emit(SequenceStartEvent.new(talias, node.tag, implicit,node.flow_style))
+          implicit = (node.tag == @resolver.resolve(SequenceNode, node.value, true))
+          @emitter.emit(SequenceStartEvent.new(talias, node.tag, implicit,node.flow_style))
           index = 0
           for item in node.value
             serialize_node(item,node,index)
             index += 1
           end
-          emit(SequenceEndEvent.new)
+          @emitter.emit(SequenceEndEvent.new)
         elsif MappingNode === node
-          implicit = (node.tag == resolve(MappingNode, node.value, true))
-          emit(MappingStartEvent.new(talias, node.tag, implicit,node.flow_style))
+          implicit = (node.tag == @resolver.resolve(MappingNode, node.value, true))
+          @emitter.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)
+          @emitter.emit(MappingEndEvent.new)
         end
       end
     end

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

@@ -0,0 +1,115 @@
+require 'rbyaml/error'
+require 'rbyaml/events'
+require 'rbyaml/nodes'
+
+module RbYAML
+  class SerializerError < YAMLError
+  end
+
+  module Serializer
+    ANCHOR_TEMPLATE = "id%03d"
+
+    def initialize_serializer(explicit_start=nil, explicit_end=nil, version=nil, tags=nil)
+      @use_explicit_start = explicit_start
+      @use_explicit_end = explicit_end
+      @use_version = version
+      @use_tags = tags
+      @serialized_nodes = {}
+      @anchors = {}
+      @last_anchor_id = 0
+      @closed = nil
+    end
+
+    def open
+      if @closed.nil?
+        emit(StreamStartEvent.new)
+        @closed = false
+      elsif @closed
+        raise SerializerError.new("serializer is closed")
+      else
+        raise SerializerError.new("serializer is already opened")
+      end
+    end
+
+    def close
+      if @closed.nil?
+        raise SerializerError.new("serializer is not opened")
+      elsif !@closed
+        emit(StreamEndEvent.new)
+        @closed = true
+      end
+    end
+
+    def serialize(node)
+      if @closed.nil?
+        raise SerializerError.new("serializer is not opened")
+      elsif @closed
+        raise SerializerError.new("serializer is closed")
+      end
+      emit(DocumentStartEvent.new(@use_explicit_start,@use_version,@use_tags))
+      anchor_node(node)
+      serialize_node(node,nil,nil)
+      emit(DocumentEndEvent.new(@use_explicit_end))
+      @serialized_nodes = {}
+      @anchors = {}
+      @last_alias_id = 0
+    end
+
+    def anchor_node(node)
+      if @anchors.include?(node)
+        @anchors[node] ||= generate_anchor(node)
+      else
+        @anchors[node] = nil
+        if SequenceNode === node
+          for item in node.value
+            anchor_node(item)
+          end
+        elsif MappingNode === node
+          for key,val in node.value
+            anchor_node(key)
+            anchor_node(val)
+          end
+        end
+      end
+    end
+
+    def generate_anchor(node)
+      @last_anchor_id += 1
+      ANCHOR_TEMPLATE % @last_anchor_id
+    end
+    
+    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 = 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
+          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,node,index)
+            index += 1
+          end
+          emit(SequenceEndEvent.new)
+        elsif MappingNode === node
+          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
+      end
+    end
+  end
+end
+

data/lib/rbyaml/tokens.rb

@@ -1,14 +1,35 @@
 
 module RbYAML
+  Token = Struct.new(:start_mark, :end_mark)
+
   class Token
-    attr_reader :start_mark, :end_mark
-    def initialize(start_mark, end_mark)
-      @start_mark = start_mark
-      @end_mark = end_mark
+    def __is_document_start; false; end
+    def __is_document_end; false; end
+    def __is_stream_start; false; end
+    def __is_stream_end; false; end
+    def __is_directive; false; end
+    def __is_block_sequence_start; false; end
+    def __is_block_mapping_start; false; end
+    def __is_block_end; false; end
+    def __is_flow_sequence_start; false; end
+    def __is_flow_mapping_start; false; end
+    def __is_flow_sequence_end; false; end
+    def __is_flow_mapping_end; false; end
+    def __is_key; false; end
+    def __is_value; false; end
+    def __is_block_entry; false; end
+    def __is_flow_entry; false; end
+    def __is_alias; false; end
+    def __is_anchor; false; end
+    def __is_tag; false; end
+    def __is_scalar; false; end
+    def hash
+      object_id
     end
   end
 
   class DirectiveToken < Token
+    def __is_directive; true; end
     def tid
       "<directive>"
     end
@@ -21,18 +42,21 @@ module RbYAML
   end
 
   class DocumentStartToken < Token
+    def __is_document_start; true; end
     def tid
       "<document start>"
     end
   end
 
   class DocumentEndToken < Token
+    def __is_document_end; true; end
     def tid
       "<document end>"
     end
   end
 
   class StreamStartToken < Token
+    def __is_stream_start; true; end
     def tid
       "<stream start>"
     end
@@ -44,78 +68,91 @@ module RbYAML
   end
   
   class StreamEndToken < Token
+    def __is_stream_end; true; end
     def tid
       "<stream end>"
     end
   end
 
   class BlockSequenceStartToken < Token
+    def __is_block_sequence_start; true; end
     def tid
       "<block sequence start>"
     end
   end
 
   class BlockMappingStartToken < Token
+    def __is_block_mapping_start; true; end
     def tid
       "<block mapping start>"
     end
   end
 
   class BlockEndToken < Token
+    def __is_block_end; true; end
     def tid
       "<block end>"
     end
   end
 
   class FlowSequenceStartToken < Token
+    def __is_flow_sequence_start; true; end
     def tid
       "["
     end
   end
 
   class FlowMappingStartToken < Token
+    def __is_flow_mapping_start; true; end
     def tid
       "{"
     end
   end
 
   class FlowSequenceEndToken < Token
+    def __is_flow_sequence_end; true; end
     def tid
       "]"
     end
   end
 
   class FlowMappingEndToken < Token
+    def __is_flow_mapping_end; true; end
     def tid
       "}"
     end
   end
 
   class KeyToken < Token
+    def __is_key; true; end
     def tid
       "?"
     end
   end
 
   class ValueToken < Token
+    def __is_value; true; end
     def tid
       ":"
     end
   end
 
   class BlockEntryToken < Token
+    def __is_block_entry; true; end
     def tid
       "-"
     end
   end
 
   class FlowEntryToken < Token
+    def __is_flow_entry; true; end
     def tid
       ","
     end
   end
 
   class AliasToken < Token
+    def __is_alias; true; end
     def tid
       "<alias>"
     end
@@ -127,6 +164,7 @@ module RbYAML
   end
 
   class AnchorToken < Token
+    def __is_anchor; true; end
     def tid
       "<anchor>"
     end
@@ -138,6 +176,7 @@ module RbYAML
   end
 
   class TagToken < Token
+    def __is_tag; true; end
     def tid
       "<tag>"
     end
@@ -149,6 +188,7 @@ module RbYAML
   end
 
   class ScalarToken < Token
+    def __is_scalar; true; end
     def tid
       "<scalar>"
     end

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

@@ -0,0 +1,164 @@
+
+module RbYAML
+  class Token
+    attr_reader :start_mark, :end_mark
+    def initialize(start_mark, end_mark)
+      @start_mark = start_mark
+      @end_mark = end_mark
+    end
+  end
+
+  class DirectiveToken < Token
+    def tid
+      "<directive>"
+    end
+    attr_reader :name, :value
+    def initialize(name, value, start_mark, end_mark)
+      super(start_mark,end_mark)
+      @name = name
+      @value = value
+    end
+  end
+
+  class DocumentStartToken < Token
+    def tid
+      "<document start>"
+    end
+  end
+
+  class DocumentEndToken < Token
+    def tid
+      "<document end>"
+    end
+  end
+
+  class StreamStartToken < Token
+    def tid
+      "<stream start>"
+    end
+    attr_reader :encoding
+    def initialize(start_mark=nil, end_mark=nil, encoding=nil)
+      super(start_mark,end_mark)
+      @encoding = encoding
+    end
+  end
+  
+  class StreamEndToken < Token
+    def tid
+      "<stream end>"
+    end
+  end
+
+  class BlockSequenceStartToken < Token
+    def tid
+      "<block sequence start>"
+    end
+  end
+
+  class BlockMappingStartToken < Token
+    def tid
+      "<block mapping start>"
+    end
+  end
+
+  class BlockEndToken < Token
+    def tid
+      "<block end>"
+    end
+  end
+
+  class FlowSequenceStartToken < Token
+    def tid
+      "["
+    end
+  end
+
+  class FlowMappingStartToken < Token
+    def tid
+      "{"
+    end
+  end
+
+  class FlowSequenceEndToken < Token
+    def tid
+      "]"
+    end
+  end
+
+  class FlowMappingEndToken < Token
+    def tid
+      "}"
+    end
+  end
+
+  class KeyToken < Token
+    def tid
+      "?"
+    end
+  end
+
+  class ValueToken < Token
+    def tid
+      ":"
+    end
+  end
+
+  class BlockEntryToken < Token
+    def tid
+      "-"
+    end
+  end
+
+  class FlowEntryToken < Token
+    def tid
+      ","
+    end
+  end
+
+  class AliasToken < Token
+    def tid
+      "<alias>"
+    end
+    attr_reader :value
+    def initialize(value, start_mark, end_mark)
+      super(start_mark,end_mark)
+      @value = value
+    end
+  end
+
+  class AnchorToken < Token
+    def tid
+      "<anchor>"
+    end
+    attr_reader :value
+    def initialize(value, start_mark, end_mark)
+      super(start_mark,end_mark)
+      @value = value
+    end
+  end
+
+  class TagToken < Token
+    def tid
+      "<tag>"
+    end
+    attr_reader :value
+    def initialize(value, start_mark, end_mark)
+      super(start_mark,end_mark)
+      @value = value
+    end
+  end
+
+  class ScalarToken < Token
+    def tid
+      "<scalar>"
+    end
+    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
+      @plain = plain
+      @style = style
+    end
+  end
+end