rubysl-yaml 0.0.1 → 1.0.1

data/lib/yaml/store.rb

@@ -0,0 +1,43 @@
+#
+# YAML::Store
+#
+require 'yaml'
+require 'pstore'
+
+class YAML::Store < PStore
+  def initialize( *o )
+    @opt = YAML::DEFAULTS.dup
+    if String === o.first
+      super(o.shift)
+    end
+    if o.last.is_a? Hash
+      @opt.update(o.pop)
+    end
+  end
+
+  def dump(table)
+    @table.to_yaml(@opt)
+  end
+
+  def load(content)
+    table = YAML::load(content)
+    if table == false
+      {}
+    else
+      table
+    end
+  end
+
+  def marshal_dump_supports_canonical_option?
+    false
+  end
+
+  EMPTY_MARSHAL_DATA = {}.to_yaml
+  EMPTY_MARSHAL_CHECKSUM = Digest::MD5.digest(EMPTY_MARSHAL_DATA)
+  def empty_marshal_data
+    EMPTY_MARSHAL_DATA
+  end
+  def empty_marshal_checksum
+    EMPTY_MARSHAL_CHECKSUM
+  end
+end

data/lib/yaml/stream.rb

@@ -0,0 +1,40 @@
+module YAML
+
+	#
+	# YAML::Stream -- for emitting many documents
+	#
+	class Stream
+
+		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 emit( io = nil )
+            # opts = @options.dup
+			# opts[:UseHeader] = true if @documents.length > 1
+            out = YAML.emitter
+            out.reset( io || io2 = StringIO.new )
+            @documents.each { |v|
+                v.to_yaml( out )
+            }
+            io || ( io2.rewind; io2.read )
+		end
+
+	end
+
+end

data/lib/yaml/stringio.rb

@@ -0,0 +1,83 @@
+#
+# Limited StringIO if no core lib is available
+#
+begin
+require 'stringio'
+rescue LoadError
+    # StringIO based on code by MoonWolf
+    class StringIO
+        def initialize(string="")
+            @string=string
+            @pos=0
+            @eof=(string.size==0)
+        end
+        def pos
+            @pos
+        end    
+        def eof
+            @eof
+        end
+        alias eof? eof
+        def readline(rs=$/)
+            if @eof
+                raise EOFError
+            else
+                if p = @string[@pos..-1]=~rs
+                    line = @string[@pos,p+1]
+                else
+                    line = @string[@pos..-1]
+                end
+                @pos+=line.size
+                @eof =true if @pos==@string.size
+                $_ = line
+            end
+        end
+        def rewind
+            seek(0,0)
+        end
+        def seek(offset,whence)
+            case whence
+            when 0
+                @pos=offset
+            when 1
+                @pos+=offset
+            when 2
+                @pos=@string.size+offset
+            end
+            @eof=(@pos>=@string.size)
+            0
+        end
+    end
+
+	#
+	# Class method for creating streams
+	#
+	def YAML.make_stream( io )
+        if String === io
+            io = StringIO.new( io )
+        elsif not IO === io
+            raise YAML::Error, "YAML stream must be an IO or String object."
+        end
+        if YAML::unicode
+            def io.readline
+                YAML.utf_to_internal( readline( @ln_sep ), @utf_encoding )
+            end
+            def io.check_unicode
+                @utf_encoding = YAML.sniff_encoding( read( 4 ) )
+                @ln_sep = YAML.enc_separator( @utf_encoding )
+                seek( -4, IO::SEEK_CUR )
+            end
+		    def io.utf_encoding
+		    	@utf_encoding
+		    end
+            io.check_unicode
+        else
+            def io.utf_encoding
+                :None
+            end
+        end
+        io
+	end
+
+end
+

data/lib/yaml/syck.rb

@@ -0,0 +1,44 @@
+#
+# YAML::Syck module
+# .. glues syck and yaml.rb together ..
+#
+require 'syck/syck'
+require 'yaml/basenode'
+
+module YAML
+    module Syck
+
+        #
+        # Mixin BaseNode functionality
+        #
+        class Node
+            include YAML::BaseNode
+        end
+
+        #--
+        # For Rubinius, replaces the rb_iterate call to syck_set_ivars.
+        #++
+        def self.set_ivars(hsh, obj)
+          hsh.each do |key, value|
+            obj.instance_variable_set :"@#{key}", value
+          end
+        end
+
+        #--
+        # For Rubinius, replaces the rb_iterate call to syck_merge_i.
+        #++
+        def self.merge_i(ary, hsh)
+          ary.each do |entry|
+            begin
+              entry = Rubinius::Type.coerce_to entry, Hash, :to_hash
+              hsh.update entry
+            rescue
+              # ignore coercion errors
+            end
+          end
+
+          nil
+        end
+
+    end
+end

data/lib/yaml/tag.rb

@@ -0,0 +1,91 @@
+# -*- mode: ruby; ruby-indent-level: 4; tab-width: 4 -*- vim: sw=4 ts=4
+# $Id: tag.rb 11708 2007-02-12 23:01:19Z shyouhei $
+#
+# = yaml/tag.rb: methods for associating a taguri to a class.
+#
+# Author:: why the lucky stiff
+# 
+module YAML
+    # 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 YAML.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 YAML.tagged_classes
+        @@tagged_classes
+    end
+end
+
+class Module
+    # :stopdoc:
+
+    # Adds a taguri _tag_ to a class, used when dumping or loading the class
+    # in YAML.  See YAML::tag_class for detailed information on typing and
+    # taguris.
+    def yaml_as( tag, sc = true )
+        verbose, $VERBOSE = $VERBOSE, nil
+        class_eval <<-"end;", __FILE__, __LINE__+1
+            attr_writer :taguri
+            def taguri
+                if respond_to? :to_yaml_type
+                    YAML::tagurize( to_yaml_type[1..-1] )
+                else
+                    return @taguri if defined?(@taguri) and @taguri
+                    tag = #{ tag.dump }
+                    if self.class.yaml_tag_subclasses? and self.class != YAML::tagged_classes[tag]
+                        tag = "\#{ tag }:\#{ self.class.yaml_tag_class_name }"
+                    end
+                    tag
+                end
+            end
+            def self.yaml_tag_subclasses?; #{ sc ? 'true' : 'false' }; end
+        end;
+        YAML::tag_class tag, self
+    ensure
+        $VERBOSE = verbose
+    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/yaml/types.rb

@@ -0,0 +1,192 @@
+# -*- mode: ruby; ruby-indent-level: 4 -*- vim: sw=4
+#
+# Classes required by the full core typeset
+#
+
+module YAML
+
+    #
+    # Default private type
+    #
+    class PrivateType
+        def self.tag_subclasses?; false; end
+        verbose, $VERBOSE = $VERBOSE, nil
+        def initialize( type, val )
+            @type_id = type; @value = val
+            @value.taguri = "x-private:#{ @type_id }"
+        end
+        def to_yaml( opts = {} )
+            @value.to_yaml( opts )
+        end
+    ensure
+        $VERBOSE = verbose
+    end
+
+    #
+    # Default domain type
+    #
+    class DomainType
+        def self.tag_subclasses?; false; end
+        verbose, $VERBOSE = $VERBOSE, nil
+        def initialize( domain, type, val )
+            @domain = domain; @type_id = type; @value = val
+            @value.taguri = "tag:#{ @domain }:#{ @type_id }"
+        end
+        def to_yaml( opts = {} )
+            @value.to_yaml( opts )
+        end
+    ensure
+        $VERBOSE = verbose
+    end
+
+    #
+    # Unresolved objects
+    #
+    class Object
+        def self.tag_subclasses?; false; end
+        def to_yaml( opts = {} )
+            YAML::quick_emit( self, opts ) do |out|
+                out.map( "tag:ruby.yaml.org,2002:object:#{ @class }", to_yaml_style ) do |map|
+                    @ivars.each do |k,v|
+                        map.add( k, v )
+                    end
+                end
+            end
+        end
+    end
+
+    #
+    # YAML Hash class to support comments and defaults
+    #
+    class SpecialHash < ::Hash 
+        attr_accessor :default
+        def inspect
+            self.default.to_s
+        end
+        def to_s
+            self.default.to_s
+        end
+        def update( h )
+            if YAML::SpecialHash === h
+                @default = h.default if h.default
+            end
+            super( h )
+        end
+        def to_yaml( opts = {} )
+            opts[:DefaultKey] = self.default
+            super( opts )
+        end
+    end
+
+    #
+    # Builtin collection: !omap
+    #
+    class Omap < ::Array
+        yaml_as "tag:yaml.org,2002:omap"
+        def yaml_initialize( tag, val )
+            if Array === val
+                val.each do |v|
+                    if Hash === v
+                        concat( v.to_a )		# Convert the map to a sequence
+                    else
+                        raise YAML::Error, "Invalid !omap entry: " + val.inspect
+                    end
+                end
+            else
+                raise YAML::Error, "Invalid !omap: " + val.inspect
+            end
+            self
+        end
+        def self.[]( *vals )
+            o = Omap.new
+            0.step( vals.length - 1, 2 ) do |i|
+                o[vals[i]] = vals[i+1]
+            end
+            o
+        end
+        def []( k )
+            self.assoc( k ).to_a[1]
+        end
+        def []=( k, *rest )
+            val, set = rest.reverse
+            if ( tmp = self.assoc( k ) ) and not set
+                tmp[1] = val
+            else
+                self << [ k, val ] 
+            end
+            val
+        end
+        def has_key?( k )
+            self.assoc( k ) ? true : false
+        end
+        def is_complex_yaml?
+            true
+        end
+        def to_yaml( opts = {} )
+            YAML::quick_emit( self, opts ) do |out|
+                out.seq( taguri, to_yaml_style ) do |seq|
+                    self.each do |v|
+                        seq.add( Hash[ *v ] )
+                    end
+                end
+            end
+        end
+    end
+
+    #
+    # Builtin collection: !pairs
+    #
+    class Pairs < ::Array
+        yaml_as "tag:yaml.org,2002:pairs"
+        def yaml_initialize( tag, val )
+            if Array === val
+                val.each do |v|
+                    if Hash === v
+                        concat( v.to_a )		# Convert the map to a sequence
+                    else
+                        raise YAML::Error, "Invalid !pairs entry: " + val.inspect
+                    end
+                end
+            else
+                raise YAML::Error, "Invalid !pairs: " + val.inspect
+            end
+            self
+        end
+        def self.[]( *vals )
+            p = Pairs.new
+            0.step( vals.length - 1, 2 ) { |i|
+                p[vals[i]] = vals[i+1]
+            }
+            p
+        end
+        def []( k )
+            self.assoc( k ).to_a
+        end
+        def []=( k, val )
+            self << [ k, val ] 
+            val
+        end
+        def has_key?( k )
+            self.assoc( k ) ? true : false
+        end
+        def is_complex_yaml?
+            true
+        end
+        def to_yaml( opts = {} )
+            YAML::quick_emit( self, opts ) do |out|
+                out.seq( taguri, to_yaml_style ) do |seq|
+                    self.each do |v|
+                        seq.add( Hash[ *v ] )
+                    end
+                end
+            end
+        end
+    end
+
+    #
+    # Builtin collection: !set
+    #
+    class Set < ::Hash
+        yaml_as "tag:yaml.org,2002:set"
+    end
+end