RbYAML 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2006 Ola Bini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

data/README

@@ -0,0 +1,31 @@
+= RbYAML - A pure Ruby YAML 1.1 loader and dumper
+
+Project Contact: Ola Bini <ola@ologix.com>
+
+The code is based mostly on the Python code written by Kirill Simonov <xi@resolvent.net> for PyYAML3000.
+
+RbYAML is a project originating in the JRuby project (http://jruby.sourceforge.net), to create a pure Ruby
+YAML parser for use in JRuby and SYCK cannot be used in this case. 
+Since the effort of writing a new one from scratch seemed like a major undertaking it seemed easier to
+port an existing one. 
+
+The current functionality is more or less 1.1-compliant. What's missing is the Unicode-support. The idea
+is to have the interface resemble SYCK as much as possible, but this is still work in progress, since some
+of the major architectural choices are quite different.
+
+== Use
+
+Just require 'rbyaml' and use it as you would use YAML, but in module RbYAML instead:
+   
+        require 'rbyaml'
+        
+        RbYAML.load("--- \n- A\n- b\n- c\n")       ---->   ["A","b","c"]
+        "foo".to_yaml                              ---->   "foo\n"
+
+== More information
+
+Visit http://rbyaml.ologix.com for more information and updated versions
+
+== License
+
+RbYAML is distributed with a MIT license, which can be found in the file LICENSE.

data/lib/rbyaml.rb

@@ -0,0 +1,378 @@
+
+require 'rbyaml/yaml'
+
+module RbYAML
+  def self.dump(obj, io = nil)
+    _dump(obj,io)
+  end
+
+  def self.load( io )
+    _load(io)
+  end
+
+  def self.load_file( filepath )
+    File.open( filepath ) do |f|
+      load( f )
+    end
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.parse( io )
+    #    yp = @@parser.new( :Model => :Generic ).load( io )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.parse_file( filepath )
+    #    File.open( filepath ) do |f|
+    #      parse( f )
+    #    end
+  end
+
+  def self.each_document( io, &block )
+    _load_all(io,&block)
+  end
+
+  def self.load_documents( io, &doc_proc )
+    each_document( io, &doc_proc )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.each_node( io, &doc_proc )
+    #    yp = @@parser.new( :Model => :Generic ).load_documents( io, &doc_proc )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.parse_documents( io, &doc_proc )
+    #    YAML.each_node( io, &doc_proc )
+  end
+  
+  def self.load_stream( io )
+    d = nil
+    load_documents(io) { |doc|
+      d = Stream.new( nil ) if not d
+      d.add( doc ) 
+    }
+    d
+  end
+
+  def self.dump_stream( *objs )
+    d = RbYAML::Stream.new
+    objs.each do |doc|
+      d.add( doc ) 
+    end
+    d.emit
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.add_domain_type( domain, type_re, &transfer_proc )
+    #    @@loader.add_domain_type( domain, type_re, &transfer_proc )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.add_builtin_type( type_re, &transfer_proc )
+    #    @@loader.add_builtin_type( type_re, &transfer_proc )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.add_ruby_type( type_tag, &transfer_proc )
+    #    @@loader.add_ruby_type( type, &transfer_proc )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.add_private_type( type_re, &transfer_proc )
+    #    @@loader.add_private_type( type_re, &transfer_proc )
+  end
+
+  def self.detect_implicit( val )
+    SimpleDetector.detect(val)
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.transfer( type_id, obj )
+    #    @@loader.transfer( type_id, obj )
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.try_implicit( obj )
+    #    YAML.transfer( YAML.detect_implicit( obj ), obj )
+  end
+
+  def self.read_type_class( type, obj_class )
+    scheme, domain, type, tclass = type.split( ':', 4 )
+    tclass.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tclass
+    return [ type, obj_class ]
+  end
+
+  def self.object_maker( obj_class, val )
+    if Hash === val
+      o = obj_class.allocate
+      val.each_pair { |k,v|
+        o.instance_variable_set("@#{k}", v)
+      }
+      o
+    else
+      raise YAMLError, "Invalid object explicitly tagged !ruby/Object: " + val.inspect
+    end
+  end
+
+  # this operation does not make sense in RbYAML (right now)
+  def self.quick_emit( oid, opts = {}, &e )
+  end
+
+  # 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
+
+  #
+  # 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
+
+if !Object.method_defined?(:to_yaml)
+  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
+
+  require 'date'
+
+  class Class
+    def to_yaml( opts = {} )
+      raise RbYAML::TypeError, "can't dump anonymous class %s" % self.class
+    end
+  end
+
+  class Object
+    yaml_as "tag:ruby.yaml.org,2002:object"
+    def is_complex_yaml?; true; end
+    def to_yaml_style; end
+    def to_yaml_properties; instance_variables.sort; end
+    def to_yaml( opts = {} )
+      RbYAML::_dump_ruby_object(self)
+    end
+  end
+
+  class Hash
+    yaml_as "tag:ruby.yaml.org,2002:hash"
+    yaml_as "tag:yaml.org,2002:map"
+    def is_complex_yaml?; true; end
+    def yaml_initialize( tag, val )
+      if Array === val
+        update Hash.[]( *val )		# Convert the map to a sequence
+      elsif Hash === val
+        update val
+      else
+        raise RbYAML::TypeError, "Invalid map explicitly tagged #{ tag }: " + val.inspect
+      end
+    end
+  end
+
+  class Array
+    yaml_as "tag:ruby.yaml.org,2002:array"
+    yaml_as "tag:yaml.org,2002:seq"
+    def is_complex_yaml?; true; end
+    def yaml_initialize( tag, val ); concat( val.to_a ); end
+  end
+
+  class Exception
+    yaml_as "tag:ruby.yaml.org,2002:exception"
+    def Exception.yaml_new( klass, tag, val )
+      o = RbYAML.object_maker( klass, { 'mesg' => val.delete( 'message' ) } )
+      val.each_pair do |k,v|
+        o.instance_variable_set("@#{k}", v)
+      end
+      o
+    end
+  end
+
+  class String
+    yaml_as "tag:ruby.yaml.org,2002:string"
+    yaml_as "tag:yaml.org,2002:binary"
+    yaml_as "tag:yaml.org,2002:str"
+    def is_complex_yaml?
+      to_yaml_style or not to_yaml_properties.empty? or self =~ /\n.+/
+    end
+    def is_binary_data?
+      ( self.count( "^ -~", "^\r\n" ) / self.size > 0.3 || self.count( "\x00" ) > 0 ) unless empty?
+    end
+    def String.yaml_new( klass, tag, val )
+      val = val.unpack("m")[0] if tag == "tag:yaml.org,2002:binary"
+      val = { 'str' => val } if String === val
+      if Hash === val
+        s = klass.allocate
+        # Thank you, NaHi
+        String.instance_method(:initialize).
+          bind(s).
+          call( val.delete( 'str' ) )
+        val.each { |k,v| s.instance_variable_set( k, v ) }
+        s
+      else
+        raise RbYAML::TypeError, "Invalid String: " + val.inspect
+      end
+    end
+  end
+
+  class Symbol
+    yaml_as "tag:ruby.yaml.org,2002:symbol"
+    yaml_as "tag:ruby.yaml.org,2002:sym"
+    def is_complex_yaml?; false; end
+    def Symbol.yaml_new( klass, tag, val )
+      if String === val
+        val.intern
+      else
+        raise RbYAML::TypeError, "Invalid Symbol: " + val.inspect
+      end
+    end
+  end
+
+  class Time
+    yaml_as "tag:ruby.yaml.org,2002:time"
+    yaml_as "tag:yaml.org,2002:timestamp"
+    def is_complex_yaml?; false; end
+    def Time.yaml_new( klass, tag, val )
+      if Hash === val
+        t = val.delete( 'at' )
+        val.each { |k,v| t.instance_variable_set( k, v ) }
+        t
+      else
+        raise RbYAML::TypeError, "Invalid Time: " + val.inspect
+      end
+    end
+  end
+
+  class Date
+    yaml_as "tag:yaml.org,2002:timestamp#ymd"
+    def is_complex_yaml?; false; end
+  end
+
+  class Numeric
+    def is_complex_yaml?; false; end
+  end
+
+  class Fixnum
+    yaml_as "tag:yaml.org,2002:int"
+  end
+
+  class Float
+    yaml_as "tag:yaml.org,2002:float"
+  end
+
+  class TrueClass
+    yaml_as "tag:yaml.org,2002:bool#yes"
+    def is_complex_yaml?; false; end
+  end
+
+  class FalseClass
+    yaml_as "tag:yaml.org,2002:bool#no"
+    def is_complex_yaml?; false; end
+  end
+
+  class NilClass 
+    yaml_as "tag:yaml.org,2002:null"
+    def is_complex_yaml?; false; end
+  end
+end

data/lib/rbyaml/composer.rb

@@ -0,0 +1,189 @@
+require 'rbyaml/error'
+require 'rbyaml/events'
+require 'rbyaml/nodes'
+
+module RbYAML
+  class ComposerError < MarkedYAMLError
+  end
+
+  module BaseComposer
+    @@yaml_resolvers = {}
+
+    def initialize_composer
+      @all_anchors = {}
+      @complete_anchors = {}
+      @resolver_tags = []
+      @resolver_paths = []
+    end
+
+    def check_node
+      !check_event(StreamEndEvent)
+    end
+
+    def get_node
+      compose_document if check_node
+    end
+
+    def each_node
+      yield compose_document while check_node
+    end
+
+    def compose_document
+      # Drop the STREAM-START event.
+      get_event if check_event(StreamStartEvent)
+      get_event
+      # Compose the root node.
+      node = compose_node([])
+      # Drop the DOCUMENT-END event.
+      get_event
+      @all_anchors = {}
+      @complete_anchors = {}
+      @resolver_tags = []
+      @resolver_paths = []
+      node
+    end
+
+    def increase_resolver_depth(path)
+      depth = path.length
+      tag = []
+      paths = []
+      if depth == 0
+        for resolver_path in @@yaml_resolvers.keys
+          if resolver_path
+            paths += resolver_path
+          else
+            tag = @@yaml_resolvers[resolver_path]
+          end
+        end
+      else
+        base, index = path[-1]
+        if ScalarNode === index && index.tag == DEFAULT_SCALAR_TAG
+          index = index.value
+        elsif Node === index
+          index = nil
+        end
+        if @resolver_paths[-1]
+          for resolver_path in @resolver_paths[-1]
+            resolver_index = resolver_path[depth-1]
+            if resolver_index.nil? || resolver_index == index
+              if resolver_index.length > depth
+                paths += resolver_path
+              else
+                tag = @@yaml_resolvers[resolver_path]
+              end
+            end
+          end
+        end
+      end
+
+      @resolver_tags += tag
+      @resolver_paths += paths
+    end
+
+    def decrease_resolver_depth
+      @resolver_tags.pop
+      @resolver_paths.pop
+    end
+
+    def compose_node(path)
+      if check_event(AliasEvent)
+        event = get_event
+        anchor = event.anchor
+        raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@all_anchors.include?(anchor)
+        if !@complete_anchors.include?(anchor)
+          collection_event = @all_anchors[anchor]
+          raise ComposerError.new("while composing a collection",collection_event.start_mark,"found recursive anchor #{anchor}",event.start_mark)
+        end
+        return @complete_anchors[anchor]
+      end
+      increase_resolver_depth(path)
+      event = peek_event
+      anchor = event.anchor
+      if !anchor.nil?
+        if @all_anchors.include?(anchor)
+          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @all_anchors[anchor].start_mark,"second occurence", event.start_mark)
+        end
+        @all_anchors[anchor] = event
+      end
+      if check_event(ScalarEvent)
+        node = compose_scalar_node(path)
+      elsif check_event(SequenceStartEvent)
+        node = compose_sequence_node(path)
+      elsif check_event(MappingStartEvent)
+        node = compose_mapping_node(path)
+      end
+      
+      if !anchor.nil?
+        @complete_anchors[anchor] = node
+      end
+      decrease_resolver_depth
+      node
+    end
+
+    def compose_scalar_node(path)
+      event = get_event
+      tag = resolve_scalar(path, event.tag, event.implicit, event.value)
+      ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, style=event.style)
+    end
+
+    def compose_sequence_node(path)
+      start_event = get_event
+      tag = resolve_sequence(path, start_event.tag)
+      node = SequenceNode.new(tag, [],start_event.start_mark, nil,flow_style=start_event.flow_style)
+      index = 0
+      while !check_event(SequenceEndEvent)
+        node.value << compose_node(path+[[node, index]])
+        index += 1
+      end
+      
+      end_event = get_event
+      node.end_mark = end_event.end_mark
+      node
+    end
+
+    def compose_mapping_node(path)
+      start_event = get_event
+      tag = resolve_mapping(path, start_event.tag)
+      node = MappingNode.new(tag, {},start_event.start_mark, nil,flow_style=start_event.flow_style)
+      while !check_event(MappingEndEvent)
+        key_event = peek_event
+        item_key = compose_node(path+[[node, nil]])
+        item_value = compose_node(path+[[node, item_key]])
+        if node.value.include?(item_key)
+          raise ComposerError.new("while composing a mapping", start_event.start_mark,"found duplicate key", key_event.start_mark)
+        end
+        node.value[item_key] = item_value
+      end
+      end_event = get_event
+      node.end_mark = end_event.end_mark
+      node
+    end
+
+    def resolve_scalar(path, tag, implicit, value)
+      tag = detect(value) if implicit
+      tag = resolver_tags[-1] if (tag.nil? || tag == []) && @resolver_tags[-1]
+      tag = DEFAULT_SCALAR_TAG if tag.nil? || tag == [] || tag == "!"
+      tag
+    end
+
+    def resolve_sequence(path, tag)
+      tag = resolver_tags[-1] if tag.nil? && @resolver_tags[-1]
+      tag = DEFAULT_SEQUENCE_TAG if tag.nil? || tag == "!"
+      tag
+    end
+
+    def resolve_mapping(path, tag)
+      tag = resolver_tags[-1] if tag.nil? && @resolver_tags[-1]
+      tag = DEFAULT_MAPPING_TAG if tag.nil? || tag == "!"
+      tag
+    end
+
+    def self.add_resolver(tag, path)
+      @@yaml_resolvers[path] = tag
+    end
+  end
+  
+  module Composer
+    include BaseComposer
+  end
+end