rubysl-yaml 0.0.1 → 1.0.1

data/lib/yaml/constants.rb

@@ -0,0 +1,45 @@
+#
+# Constants used throughout the library
+#
+module YAML
+
+	#
+	# Constants
+	#
+	VERSION = '0.60'
+	SUPPORTED_YAML_VERSIONS = ['1.0']
+
+	#
+	# Parser tokens
+	#
+	WORD_CHAR = 'A-Za-z0-9'
+	PRINTABLE_CHAR = '-_A-Za-z0-9!?/()$\'". ' 
+	NOT_PLAIN_CHAR = '\x7f\x0-\x1f\x80-\x9f'
+	ESCAPE_CHAR = '[\\x00-\\x09\\x0b-\\x1f]'
+	INDICATOR_CHAR = '*&!|\\\\^@%{}[]='
+	SPACE_INDICATORS = '-#:,?'
+	RESTRICTED_INDICATORS = '#:,}]'
+	DNS_COMP_RE = "\\w(?:[-\\w]*\\w)?"
+	DNS_NAME_RE = "(?:(?:#{DNS_COMP_RE}\\.)+#{DNS_COMP_RE}|#{DNS_COMP_RE})"
+	ESCAPES = %w{\x00   \x01	\x02	\x03	\x04	\x05	\x06	\a
+			     \x08	\t		\n		\v		\f		\r		\x0e	\x0f
+				 \x10	\x11	\x12	\x13	\x14	\x15	\x16	\x17
+				 \x18	\x19	\x1a	\e		\x1c	\x1d	\x1e	\x1f
+			    }
+	UNESCAPES = {
+				'a' => "\x07", 'b' => "\x08", 't' => "\x09", 
+				'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
+				'r' => "\x0d", 'e' => "\x1b", '\\' => '\\',
+			    }
+
+	#
+	# Default settings
+	#
+	DEFAULTS = {
+		:Indent => 2, :UseHeader => false, :UseVersion => false, :Version => '1.0',
+		:SortKeys => false, :AnchorFormat => 'id%03d', :ExplicitTypes => false,
+		:WidthType => 'absolute', :BestWidth => 80,
+		:UseBlock => false, :UseFold => false, :Encoding => :None
+	}
+
+end

data/lib/yaml/dbm.rb

@@ -0,0 +1,111 @@
+require 'yaml'
+require 'dbm'
+#
+# YAML + DBM = YDBM
+# - Same interface as DBM class
+#
+module YAML
+
+class DBM < ::DBM
+    VERSION = "0.1"
+    def []( key )
+        fetch( key )
+    end
+    def []=( key, val )
+        store( key, val )
+    end
+    def fetch( keystr, ifnone = nil )
+        begin
+            val = super( keystr )
+            return YAML::load( val ) if String === val
+        rescue IndexError
+        end
+        if block_given?
+            yield keystr
+        else
+            ifnone
+        end
+    end
+    def index( keystr )
+        super( keystr.to_yaml )
+    end
+    def values_at( *keys )
+        keys.collect { |k| fetch( k ) }
+    end
+    def delete( key )
+        v = super( key )
+        if String === v
+            v = YAML::load( v ) 
+        end
+        v
+    end
+    def delete_if
+        del_keys = keys.dup
+        del_keys.delete_if { |k| yield( k, fetch( k ) ) == false }
+        del_keys.each { |k| delete( k ) } 
+        self
+    end
+    def reject
+        hsh = self.to_hash
+        hsh.reject { |k,v| yield k, v }
+    end
+    def each_pair
+        keys.each { |k| yield k, fetch( k ) }
+        self
+    end
+    def each_value
+        super { |v| yield YAML::load( v ) }
+        self
+    end
+    def values
+        super.collect { |v| YAML::load( v ) }
+    end
+    def has_value?( val )
+        each_value { |v| return true if v == val }
+        return false
+    end
+    def invert
+        h = {}
+        keys.each { |k| h[ self.fetch( k ) ] = k }
+        h
+    end
+    def replace( hsh )
+        clear
+        update( hsh )
+    end
+    def shift
+        a = super
+        a[1] = YAML::load( a[1] ) if a
+        a
+    end
+    def select( *keys )
+        if block_given?
+            self.keys.collect { |k| v = self[k]; [k, v] if yield k, v }.compact
+        else
+            values_at( *keys )
+        end
+    end
+    def store( key, val )
+        super( key, val.to_yaml )
+        val
+    end
+    def update( hsh )
+        hsh.keys.each do |k|
+            self.store( k, hsh.fetch( k ) )
+        end
+        self
+    end
+    def to_a
+        a = []
+        keys.each { |k| a.push [ k, self.fetch( k ) ] }
+        a
+    end
+    def to_hash
+        h = {}
+        keys.each { |k| h[ k ] = self.fetch( k ) }
+        h
+    end
+    alias :each :each_pair
+end
+
+end

data/lib/yaml/encoding.rb

@@ -0,0 +1,33 @@
+#
+# Handle Unicode-to-Internal conversion
+#
+
+module YAML
+
+	#
+	# Escape the string, condensing common escapes
+	#
+	def YAML.escape( value, skip = "" )
+		value.gsub( /\\/, "\\\\\\" ).
+              gsub( /"/, "\\\"" ).
+              gsub( /([\x00-\x1f])/ ) do |x|
+                 skip[x] || ESCAPES[ x.unpack("C")[0] ]
+             end
+	end
+
+	#
+	# Unescape the condenses escapes
+	#
+	def YAML.unescape( value )
+		value.gsub( /\\(?:([nevfbart\\])|0?x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/ ) { |x| 
+			if $3
+				["#$3".hex ].pack('U*')
+			elsif $2
+				[$2].pack( "H2" ) 
+			else
+				UNESCAPES[$1] 
+			end
+		}
+	end
+
+end

data/lib/yaml/error.rb

@@ -0,0 +1,34 @@
+#
+# Error messages and exception class
+#
+
+module YAML
+
+	#
+	# Error messages
+	#
+
+	ERROR_NO_HEADER_NODE = "With UseHeader=false, the node Array or Hash must have elements"
+	ERROR_NEED_HEADER = "With UseHeader=false, the node must be an Array or Hash"
+	ERROR_BAD_EXPLICIT = "Unsupported explicit transfer: '%s'"
+    ERROR_MANY_EXPLICIT = "More than one explicit transfer"
+	ERROR_MANY_IMPLICIT = "More than one implicit request"
+	ERROR_NO_ANCHOR = "No anchor for alias '%s'"
+	ERROR_BAD_ANCHOR = "Invalid anchor: %s"
+	ERROR_MANY_ANCHOR = "More than one anchor"
+	ERROR_ANCHOR_ALIAS = "Can't define both an anchor and an alias"
+	ERROR_BAD_ALIAS = "Invalid alias: %s"
+	ERROR_MANY_ALIAS = "More than one alias"
+	ERROR_ZERO_INDENT = "Can't use zero as an indentation width"
+	ERROR_UNSUPPORTED_VERSION = "This release of YAML.rb does not support YAML version %s"
+	ERROR_UNSUPPORTED_ENCODING = "Attempt to use unsupported encoding: %s"
+
+	#
+	# YAML Error classes
+	#
+    
+	class Error < StandardError; end
+	class ParseError < Error; end
+    class TypeError < StandardError; end
+
+end

data/lib/yaml/loader.rb

@@ -0,0 +1,14 @@
+#
+# YAML::Loader class
+# .. type handling ..
+#
+module YAML
+    class Loader
+        TRANSFER_DOMAINS = {
+            'yaml.org,2002' => {},
+            'ruby.yaml.org,2002' => {}
+        }
+        PRIVATE_TYPES = {}
+        IMPLICIT_TYPES = [ 'null', 'bool', 'time', 'int', 'float' ]
+    end
+end

data/lib/yaml/rubytypes.rb

@@ -0,0 +1,409 @@
+# -*- mode: ruby; ruby-indent-level: 4; tab-width: 4 -*- vim: sw=4 ts=4
+require 'date'
+
+class Class
+	def to_yaml( opts = {} )
+		raise TypeError, "can't dump anonymous class %s" % self.class
+	end
+end
+
+class Object
+    yaml_as "tag:ruby.yaml.org,2002:object"
+    def to_yaml_style; end
+    def to_yaml_properties; instance_variables.sort; end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            out.map( taguri, to_yaml_style ) do |map|
+				to_yaml_properties.each do |m|
+                    map.add( m[1..-1], instance_variable_get( m ) )
+                end
+            end
+        end
+	end
+end
+
+class Hash
+    yaml_as "tag:ruby.yaml.org,2002:hash"
+    yaml_as "tag:yaml.org,2002:map"
+    def yaml_initialize( tag, val )
+        if Array === val
+            update Hash.[]( *val )		# Convert the map to a sequence
+        elsif Hash === val
+            update val
+        else
+            raise YAML::TypeError, "Invalid map explicitly tagged #{ tag }: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            out.map( taguri, to_yaml_style ) do |map|
+                each do |k, v|
+                    map.add( k, v )
+                end
+            end
+        end
+	end
+end
+
+class Struct
+    yaml_as "tag:ruby.yaml.org,2002:struct"
+    def self.yaml_tag_class_name; self.name.gsub( "Struct::", "" ); end
+    def self.yaml_tag_read_class( name ); "Struct::#{ name }"; end
+    def self.yaml_new( klass, tag, val )
+        if Hash === val
+            struct_type = nil
+
+            #
+            # Use existing Struct if it exists
+            #
+            props = {}
+            val.delete_if { |k,v| props[k] = v if k =~ /^@/ }
+            begin
+                struct_name, struct_type = YAML.read_type_class( tag, Struct )
+            rescue NameError
+            end
+            if not struct_type
+                struct_def = [ tag.split( ':', 4 ).last ]
+                struct_type = Struct.new( *struct_def.concat( val.keys.collect { |k| k.intern } ) ) 
+            end
+
+            #
+            # Set the Struct properties
+            #
+            st = YAML::object_maker( struct_type, {} )
+            st.members.each do |m|
+                st.send( "#{m}=", val[m] )
+            end
+            props.each do |k,v|
+                st.instance_variable_set(k, v)
+            end
+            st
+        else
+            raise YAML::TypeError, "Invalid Ruby Struct: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+			#
+			# Basic struct is passed as a YAML map
+			#
+            out.map( taguri, to_yaml_style ) do |map|
+				self.members.each do |m|
+                    map.add( m, self[m] )
+                end
+				self.to_yaml_properties.each do |m|
+                    map.add( m, instance_variable_get( m ) )
+                end
+            end
+        end
+	end
+end
+
+class Array
+    yaml_as "tag:ruby.yaml.org,2002:array"
+    yaml_as "tag:yaml.org,2002:seq"
+    def yaml_initialize( tag, val ); concat( val.to_a ); end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            out.seq( taguri, to_yaml_style ) do |seq|
+                each do |x|
+                    seq.add( x )
+                end
+            end
+        end
+	end
+end
+
+class Exception
+    yaml_as "tag:ruby.yaml.org,2002:exception"
+    def Exception.yaml_new( klass, tag, val )
+        o = YAML.object_maker( klass, { 'mesg' => val.delete( 'message' ) } )
+        val.each_pair do |k,v|
+            o.instance_variable_set("@#{k}", v)
+        end
+        o
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            out.map( taguri, to_yaml_style ) do |map|
+                map.add( 'message', message )
+				to_yaml_properties.each do |m|
+                    map.add( m[1..-1], instance_variable_get( m ) )
+                end
+            end
+        end
+	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?
+        # It's binary if it's got a null.
+        index(0)
+    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 YAML::TypeError, "Invalid String: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( is_complex_yaml? ? self : nil, opts ) do |out|
+            if is_binary_data?
+                out.scalar( "tag:yaml.org,2002:binary", [self].pack("m"), :literal )
+            elsif to_yaml_properties.empty?
+                out.scalar( taguri, self, self =~ /^:/ ? :quote2 : to_yaml_style )
+            else
+                out.map( taguri, to_yaml_style ) do |map|
+                    map.add( 'str', "#{self}" )
+                    to_yaml_properties.each do |m|
+                        map.add( m, instance_variable_get( m ) )
+                    end
+                end
+            end
+        end
+	end
+end
+
+class Symbol
+    yaml_as "tag:ruby.yaml.org,2002:symbol"
+    yaml_as "tag:ruby.yaml.org,2002:sym"
+    def Symbol.yaml_new( klass, tag, val )
+        if String === val
+            val = YAML::load( val ) if val =~ /\A(["']).*\1\z/
+            val.intern
+        else
+            raise YAML::TypeError, "Invalid Symbol: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            out.scalar( "tag:yaml.org,2002:str", self.inspect, :plain )
+        end
+	end
+end
+
+class Range
+    yaml_as "tag:ruby.yaml.org,2002:range"
+    def Range.yaml_new( klass, tag, val )
+        inr = %r'(\w+|[+-]?\d+(?:\.\d+)?(?:e[+-]\d+)?|"(?:[^\\"]|\\.)*")'
+        opts = {}
+        if String === val and val =~ /^#{inr}(\.{2,3})#{inr}$/o
+            r1, rdots, r2 = $1, $2, $3
+            opts = {
+                'begin' => YAML.load( "--- #{r1}" ),
+                'end' => YAML.load( "--- #{r2}" ),
+                'excl' => rdots.length == 3
+            }
+            val = {}
+        elsif Hash === val
+            opts['begin'] = val.delete('begin')
+            opts['end'] = val.delete('end')
+            opts['excl'] = val.delete('excl')
+        end
+        if Hash === opts
+            r = YAML::object_maker( klass, {} )
+            # Thank you, NaHi
+            Range.instance_method(:initialize).
+                  bind(r).
+                  call( opts['begin'], opts['end'], opts['excl'] )
+            val.each { |k,v| r.instance_variable_set( k, v ) }
+            r
+        else
+            raise YAML::TypeError, "Invalid Range: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            # if self.begin.is_complex_yaml? or self.begin.respond_to? :to_str or
+            #   self.end.is_complex_yaml? or self.end.respond_to? :to_str or
+            #   not to_yaml_properties.empty?
+                out.map( taguri, to_yaml_style ) do |map|
+                    map.add( 'begin', self.begin )
+                    map.add( 'end', self.end )
+                    map.add( 'excl', self.exclude_end? )
+                    to_yaml_properties.each do |m|
+                        map.add( m, instance_variable_get( m ) )
+                    end
+                end
+            # else
+            #     out.scalar( taguri ) do |sc|
+            #         sc.embed( self.begin )
+            #         sc.concat( self.exclude_end? ? "..." : ".." )
+            #         sc.embed( self.end )
+            #     end
+            # end
+        end
+	end
+end
+
+class Regexp
+    yaml_as "tag:ruby.yaml.org,2002:regexp"
+    def Regexp.yaml_new( klass, tag, val )
+        if String === val and val =~ /^\/(.*)\/([mix]*)$/
+            val = { 'regexp' => $1, 'mods' => $2 }
+        end
+        if Hash === val
+            mods = nil
+            unless val['mods'].to_s.empty?
+                mods = 0x00
+                mods |= Regexp::EXTENDED if val['mods'].include?( 'x' )
+                mods |= Regexp::IGNORECASE if val['mods'].include?( 'i' )
+                mods |= Regexp::MULTILINE if val['mods'].include?( 'm' )
+            end
+            val.delete( 'mods' )
+            r = YAML::object_maker( klass, {} )
+            Regexp.instance_method(:initialize).
+                  bind(r).
+                  call( val.delete( 'regexp' ), mods )
+            val.each { |k,v| r.instance_variable_set( k, v ) }
+            r
+        else
+            raise YAML::TypeError, "Invalid Regular expression: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            if to_yaml_properties.empty?
+                out.scalar( taguri, self.inspect, :plain )
+            else
+                out.map( taguri, to_yaml_style ) do |map|
+                    src = self.inspect
+                    if src =~ /\A\/(.*)\/([a-z]*)\Z/
+                        map.add( 'regexp', $1 )
+                        map.add( 'mods', $2 )
+                    else
+		                raise YAML::TypeError, "Invalid Regular expression: " + src
+                    end
+                    to_yaml_properties.each do |m|
+                        map.add( m, instance_variable_get( m ) )
+                    end
+                end
+            end
+        end
+	end
+end
+
+class Time
+    yaml_as "tag:ruby.yaml.org,2002:time"
+    yaml_as "tag:yaml.org,2002:timestamp"
+    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 YAML::TypeError, "Invalid Time: " + val.inspect
+        end
+    end
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            tz = "Z"
+            # from the tidy Tobias Peters <t-peters@gmx.de> Thanks!
+            unless self.utc?
+                utc_same_instant = self.dup.utc
+                utc_same_writing = Time.utc(year,month,day,hour,min,sec,usec)
+                difference_to_utc = utc_same_writing - utc_same_instant
+                if (difference_to_utc < 0) 
+                    difference_sign = '-'
+                    absolute_difference = -difference_to_utc
+                else
+                    difference_sign = '+'
+                    absolute_difference = difference_to_utc
+                end
+                difference_minutes = (absolute_difference/60).round
+                tz = "%s%02d:%02d" % [ difference_sign, difference_minutes / 60, difference_minutes % 60]
+            end
+            standard = self.strftime( "%Y-%m-%d %H:%M:%S" )
+            standard += ".%06d" % [usec] if usec.nonzero?
+            standard += " %s" % [tz]
+            if to_yaml_properties.empty?
+                out.scalar( taguri, standard, :plain )
+            else
+                out.map( taguri, to_yaml_style ) do |map|
+                    map.add( 'at', standard )
+                    to_yaml_properties.each do |m|
+                        map.add( m, instance_variable_get( m ) )
+                    end
+                end
+            end
+        end
+	end
+end
+
+class Date
+    yaml_as "tag:yaml.org,2002:timestamp#ymd"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( self, opts ) do |out|
+            out.scalar( "tag:yaml.org,2002:timestamp", self.to_s, :plain )
+        end
+	end
+end
+
+class Integer
+    yaml_as "tag:yaml.org,2002:int"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            out.scalar( "tag:yaml.org,2002:int", self.to_s, :plain )
+        end
+	end
+end
+
+class Float
+    yaml_as "tag:yaml.org,2002:float"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            str = self.to_s
+            if str == "Infinity"
+                str = ".Inf"
+            elsif str == "-Infinity"
+                str = "-.Inf"
+            elsif str == "NaN"
+                str = ".NaN"
+            end
+            out.scalar( "tag:yaml.org,2002:float", str, :plain )
+        end
+	end
+end
+
+class TrueClass
+    yaml_as "tag:yaml.org,2002:bool#yes"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            out.scalar( taguri, "true", :plain )
+        end
+	end
+end
+
+class FalseClass
+    yaml_as "tag:yaml.org,2002:bool#no"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            out.scalar( taguri, "false", :plain )
+        end
+	end
+end
+
+class NilClass 
+    yaml_as "tag:yaml.org,2002:null"
+	def to_yaml( opts = {} )
+		YAML::quick_emit( nil, opts ) do |out|
+            out.scalar( taguri, "", :plain )
+        end
+	end
+end
+