RbYAML 0.0.1

data/lib/rbyaml/serializer.rb

@@ -0,0 +1,120 @@
+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)
+      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 in node.value.keys
+            anchor_node(key)
+            anchor_node(node.value[key])
+          end
+        end
+      end
+    end
+
+    def generate_anchor(node)
+      @last_anchor_id += 1
+      ANCHOR_TEMPLATE % @last_anchor_id
+    end
+    
+    def serialize_node(node)
+      talias = @anchors[node]
+      if @serialized_nodes.include?(node)
+        emit(AliasEvent.new(talias))
+      else
+        @serialized_nodes[node] = true
+        if ScalarNode === node
+          detected_tag = detect(node.value)
+          implicit = node.tag == detect(node.value) || (node.tag == DEFAULT_SCALAR_TAG && detected_tag.nil?)
+          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))
+          for item in node.value
+            serialize_node(item)
+          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
+          end
+          emit(MappingEndEvent.new)
+        end
+      end
+    end
+  end
+end
+

data/lib/rbyaml/test.rb

@@ -0,0 +1,56 @@
+require 'rbyaml/error'
+require 'rbyaml/reader'
+require 'rbyaml/scanner'
+require 'rbyaml/parser'
+require 'rbyaml/composer'
+require 'rbyaml/constructor'
+require 'rbyaml/detector'
+
+class RbYAMLTester
+  include RbYAML::Reader, RbYAML::Scanner, RbYAML::Parser
+  
+  def initialize(stream)
+    initialize_reader(stream)
+    initialize_scanner
+    initialize_parser
+  end
+end
+
+class RbYAMLTester2
+  include RbYAML::Reader, RbYAML::Scanner, RbYAML::Parser, RbYAML::Composer
+
+  def initialize(stream)
+    initialize_reader(stream)
+    initialize_scanner
+    initialize_parser
+    initialize_composer
+  end
+end
+
+class RbYAMLTester3
+  include RbYAML::Reader, RbYAML::Scanner, RbYAML::Parser, RbYAML::Composer, RbYAML::Constructor, RbYAML::Detector
+
+  def initialize(stream)
+    initialize_reader(stream)
+    initialize_scanner
+    initialize_parser
+    initialize_composer
+    initialize_constructor
+  end
+end
+
+i=0
+begin
+  File.open(ARGV.shift) {|f|
+    tester = RbYAMLTester3.new(f)
+    tester.each_document {|doc|
+      puts "#{doc.inspect}"
+      #    i += 1
+      #    if (i%10000) == 0
+      #      puts "token ##{i}"
+      #    end
+    }
+  }
+rescue RbYAML::MarkedYAMLError => err
+  puts "MarkedYAMLError: #{err}"
+end

data/lib/rbyaml/tokens.rb

@@ -0,0 +1,163 @@
+
+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, :implicit, :style
+    def initialize(value, implicit, start_mark, end_mark, style=nil)
+      super(start_mark, end_mark)
+      @value = value
+      @implicit = implicit
+      @style = style
+    end
+  end
+end

data/lib/rbyaml/yaml.rb

@@ -0,0 +1,143 @@
+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'
+
+require 'rbyaml/loader'
+require 'rbyaml/dumper'
+
+module RbYAML
+  def self._scan(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_token while l.check_token
+  end
+
+  def self._parse(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_event while l.check_event
+  end
+
+  def self._compose(stream, loader=Loader)
+    l = loader.new(stream)
+    l.get_node if l.check_node
+  end
+
+  def self._compose_all(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_node while l.check_node
+  end
+
+  def self._load_all(stream, loader=Loader)
+    l = loader.new(stream)
+    yield l.get_data while l.check_data
+  end
+  
+  def self._load(stream, loader=Loader)
+    l = loader.new(stream)
+    l.get_data if l.check_data
+  end
+
+  def self._safe_load_all(stream)
+    _load_all(stream, SafeLoader)
+  end
+
+  def self._safe_load(stream)
+    _load(stream, SafeLoader)
+  end
+
+  def self._emit(events, stream=nil, dumper=Dumper,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)
+    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)
+    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.open
+    for node in nodes
+      dumper.serialize(node)
+    end
+    dumper.close
+    stream.string if StringIO === stream
+  end
+  
+  def self._serialize(node, stream=nil, dumper=Dumper, *kwds)
+    _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)
+    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.open
+    for data in documents
+      dumper.represent(data)
+    end
+    dumper.close
+    stream.string if StringIO === stream
+  end
+
+  def self._dump(data, stream=nil, dumper=Dumper, *kwds)
+    _dump_all([data], stream, dumper, *kwds)
+  end
+  
+  def self._safe_dump_all(documents, stream=nil, *kwds)
+    _dump_all(documents, stream, SafeDumper, *kwds)
+  end
+  
+  def self._safe_dump(data, stream=nil, *kwds)
+    _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)
+  end
+
+  def self._add_resolver(tag, path, loader=Loader)
+    loader.add_resolver(tag, path)
+  end
+  
+  def self._add_constructor(tag, constructor, loader=Loader)
+    loader.add_constructor(tag, constructor)
+  end
+
+  def self._add_multi_constructor(tag_prefix, multi_constructor, loader=Loader)
+    loader.add_multi_constructor(tag_prefix, multi_constructor)
+  end
+
+  def self._dump_ruby_object(data, dumper=Dumper)
+    _dump(data,nil,dumper)
+  end
+
+  class SimpleDetector
+    include Detector
+  end
+end