RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/serializer.rb

@@ -7,15 +7,15 @@ module RbYAML
   end
 
   class Serializer
-    ANCHOR_TEMPLATE = "id%03d"
-
-    def initialize(emitter, resolver, explicit_start=nil, explicit_end=nil, version=nil, tags=nil)
+    def initialize(emitter, resolver, opts={})
       @emitter = emitter
       @resolver = resolver
-      @use_explicit_start = explicit_start
-      @use_explicit_end = explicit_end
-      @use_version = version
-      @use_tags = tags
+      @options = opts
+      @use_explicit_start = opts[:ExplicitStart]
+      @use_explicit_end = opts[:ExplicitEnd]
+      @use_version = opts[:UseVersion] && opts[:Version]
+      @use_tags = opts[:UseHeader]
+      @anchor_template = opts[:AnchorFormat] || "id%03d"
       @serialized_nodes = {}
       @anchors = {}
       @last_anchor_id = 0
@@ -77,7 +77,7 @@ module RbYAML
 
     def generate_anchor(node)
       @last_anchor_id += 1
-      ANCHOR_TEMPLATE % @last_anchor_id
+      @anchor_template % @last_anchor_id
     end
     
     def serialize_node(node,parent,index)
@@ -91,7 +91,7 @@ module RbYAML
           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)
-          @emitter.emit(ScalarEvent.new(talias, node.tag, implicit, node.value,nil,nil,node.style))
+          @emitter.emit(ScalarEvent.new(talias, node.tag, implicit, node.value,node.style))
         elsif SequenceNode === node
           implicit = (node.tag == @resolver.resolve(SequenceNode, node.value, true))
           @emitter.emit(SequenceStartEvent.new(talias, node.tag, implicit,node.flow_style))

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

@@ -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(nil,nil,@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(nil,nil,@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/stream.rb

@@ -0,0 +1,48 @@
+module RbYAML
+  #
+  # RbYAML::Stream -- for emitting many documents
+  #
+  class Stream
+    include Enumerable
+
+    attr_accessor :documents, :options
+    def initialize(opts = {})
+      @options = opts
+      @documents = []
+    end
+    
+    def [](i)
+      @documents[ i ]
+    end
+    
+    def add(doc)
+      @documents << doc
+    end
+
+    def edit(doc_num,doc)
+      @documents[ doc_num ] = doc
+    end
+
+    def each(&block)
+      @documents.each(&block)
+    end
+    
+    def emit
+# TODO: implement
+
+      opts = @options.dup
+      opts[:UseHeader] = true if @documents.length > 1
+      ct = 0
+      out = Emitter.new( opts )
+      @documents.each { |v|
+        if ct > 0
+          out << "\n--- " 
+        end
+        v.to_yaml( :Emitter => out )
+        ct += 1
+      }
+      out.end_object
+    end
+  end
+  
+end

data/lib/rbyaml/tag.rb

@@ -0,0 +1,72 @@
+module RbYAML
+  # A dictionary of taguris which map to
+  # Ruby classes.
+  @@tagged_classes = {}
+  
+  # 
+  # Associates a taguri _tag_ with a Ruby class _cls_.  The taguri is used to give types
+  # to classes when loading YAML.  Taguris are of the form:
+  #
+  #   tag:authorityName,date:specific
+  #
+  # The +authorityName+ is a domain name or email address.  The +date+ is the date the type
+  # was issued in YYYY or YYYY-MM or YYYY-MM-DD format.  The +specific+ is a name for
+  # the type being added.
+  # 
+  # For example, built-in YAML types have 'yaml.org' as the +authorityName+ and '2002' as the
+  # +date+.  The +specific+ is simply the name of the type:
+  #
+  #  tag:yaml.org,2002:int
+  #  tag:yaml.org,2002:float
+  #  tag:yaml.org,2002:timestamp
+  #
+  # The domain must be owned by you on the +date+ declared.  If you don't own any domains on the
+  # date you declare the type, you can simply use an e-mail address.
+  #
+  #  tag:why@ruby-lang.org,2004:notes/personal
+  #
+  def self.tag_class( tag, cls )
+    if @@tagged_classes.has_key? tag
+      warn "class #{ @@tagged_classes[tag] } held ownership of the #{ tag } tag"
+    end
+    @@tagged_classes[tag] = cls
+  end
+
+  # Returns the complete dictionary of taguris, paired with classes.  The key for
+  # the dictionary is the full taguri.  The value for each key is the class constant
+  # associated to that taguri.
+  #
+  #  YAML.tagged_classes["tag:yaml.org,2002:int"] => Integer
+  #
+  def self.tagged_classes
+    @@tagged_classes
+  end
+end
+
+class Module # :nodoc: all
+  def yaml_as( tag, sc = true )
+    class_eval <<-"end;", __FILE__, __LINE__+1
+    attr_writer :taguri
+    def taguri
+      return @taguri if defined?(@taguri) and @taguri
+      tag = #{ tag.dump }
+        if self.class.yaml_tag_subclasses? and self.class != RbYAML::tagged_classes[tag]
+          tag = "\#{ tag }:\#{ self.class.yaml_tag_class_name }"
+        end
+      tag
+    end
+    def self.yaml_tag_subclasses?; #{ sc ? 'true' : 'false' }; end
+    end;
+    RbYAML::tag_class tag, self
+  end
+  # Transforms the subclass name into a name suitable for display
+    # in a subclassed tag.
+  def yaml_tag_class_name
+    self.name
+  end
+  # Transforms the subclass name found in the tag into a Ruby
+  # constant name.
+  def yaml_tag_read_class( name )
+    name
+  end
+end

data/lib/rbyaml/tokens.rb

@@ -1,7 +1,4 @@
-
 module RbYAML
-  Token = Struct.new(:start_mark, :end_mark)
-
   class Token
     def __is_document_start; false; end
     def __is_document_end; false; end
@@ -34,8 +31,7 @@ module RbYAML
       "<directive>"
     end
     attr_reader :name, :value
-    def initialize(name, value, start_mark, end_mark)
-      super(start_mark,end_mark)
+    def initialize(name, value)
       @name = name
       @value = value
     end
@@ -61,8 +57,7 @@ module RbYAML
       "<stream start>"
     end
     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
   end
@@ -157,8 +152,7 @@ module RbYAML
       "<alias>"
     end
     attr_reader :value
-    def initialize(value, start_mark, end_mark)
-      super(start_mark,end_mark)
+    def initialize(value)
       @value = value
     end
   end
@@ -169,8 +163,7 @@ module RbYAML
       "<anchor>"
     end
     attr_reader :value
-    def initialize(value, start_mark, end_mark)
-      super(start_mark,end_mark)
+    def initialize(value)
       @value = value
     end
   end
@@ -181,8 +174,7 @@ module RbYAML
       "<tag>"
     end
     attr_reader :value
-    def initialize(value, start_mark, end_mark)
-      super(start_mark,end_mark)
+    def initialize(value)
       @value = value
     end
   end
@@ -193,12 +185,26 @@ module RbYAML
       "<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)
+    def initialize(value, plain, style=nil)
       @value = value
       @plain = plain
       @style = style
     end
   end
+
+  DOCUMENT_START = DocumentStartToken.new
+  DOCUMENT_END = DocumentEndToken.new
+  BLOCK_MAPPING_START = BlockMappingStartToken.new
+  BLOCK_SEQUENCE_START = BlockSequenceStartToken.new
+  BLOCK_ENTRY = BlockEntryToken.new
+  BLOCK_END = BlockEndToken.new
+  FLOW_ENTRY = FlowEntryToken.new
+  FLOW_MAPPING_END = FlowMappingEndToken.new
+  FLOW_MAPPING_START = FlowMappingStartToken.new
+  FLOW_SEQUENCE_END = FlowSequenceEndToken.new
+  FLOW_SEQUENCE_START = FlowSequenceStartToken.new
+  KEY = KeyToken.new
+  VALUE = ValueToken.new
+  STREAM_END = StreamEndToken.new
+  STREAM_START = StreamStartToken.new
 end

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

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