rubysl-yaml 1.1.0 → 2.0.0

data/lib/yaml/stream.rb

@@ -1,40 +0,0 @@
-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

@@ -1,83 +0,0 @@
-#
-# 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/tag.rb

@@ -1,91 +0,0 @@
-# -*- 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

@@ -1,192 +0,0 @@
-# -*- 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

data/lib/yaml/yamlnode.rb

@@ -1,54 +0,0 @@
-#
-# YAML::YamlNode class
-#
-require 'yaml/basenode'
-
-module YAML
-
-    #
-    # YAML Generic Model container
-    #
-    class YamlNode
-        include BaseNode
-        attr_accessor :kind, :type_id, :value, :anchor
-        def initialize( t, v )
-            @type_id = t
-            if Hash === v
-                @kind = 'map'
-                @value = {}
-                v.each { |k,v|
-                    @value[ k.transform ] = [ k, v ]
-                }
-            elsif Array === v
-                @kind = 'seq'
-                @value = v
-            elsif String === v
-                @kind = 'scalar'
-                @value = v
-            end
-        end
-
-        #
-        # Transform this node fully into a native type
-        #
-        def transform
-            t = nil
-            if @value.is_a? Hash
-                t = {}
-                @value.each { |k,v|
-                    t[ k ] = v[1].transform
-                }
-            elsif @value.is_a? Array
-                t = []
-                @value.each { |v|
-                    t.push v.transform
-                }
-            else
-                t = @value
-            end
-            YAML.transfer_method( @type_id, t )
-        end
-
-    end
-
-end