rubysl-yaml 1.1.0 → 2.0.0

data/lib/yaml/basenode.rb

@@ -1,216 +0,0 @@
-#
-# YAML::BaseNode class
-#
-require 'yaml/ypath'
-
-module YAML
-
-    #
-    # YAML Generic Model container
-    #
-    module BaseNode
-
-        #
-        # Search for YPath entry and return
-        # qualified nodes.
-        #
-        def select( ypath_str )
-            matches = match_path( ypath_str )
-
-            #
-            # Create a new generic view of the elements selected
-            #
-            if matches
-                result = []
-                matches.each { |m|
-                    result.push m.last
-                }
-                YAML.transfer( 'seq', result )
-            end
-        end
-
-        #
-        # Search for YPath entry and return
-        # transformed nodes.
-        #
-        def select!( ypath_str )
-            matches = match_path( ypath_str )
-
-            #
-            # Create a new generic view of the elements selected
-            #
-            if matches
-                result = []
-                matches.each { |m|
-                    result.push m.last.transform
-                }
-                result
-            end
-        end
-
-        #
-        # Search for YPath entry and return a list of
-        # qualified paths.
-        #
-        def search( ypath_str )
-            matches = match_path( ypath_str )
-
-            if matches
-                matches.collect { |m|
-                    path = []
-                    m.each_index { |i|
-                        path.push m[i] if ( i % 2 ).zero?
-                    }
-                    "/" + path.compact.join( "/" )
-                }
-            end
-        end
-
-        def at( seg )
-            if Hash === @value
-                self[seg]
-            elsif Array === @value and seg =~ /\A\d+\Z/ and @value[seg.to_i]
-                @value[seg.to_i]
-            end
-        end
-
-        #
-        # YPath search returning a complete depth array
-        #
-        def match_path( ypath_str )
-            depth = 0
-            matches = []
-            YPath.each_path( ypath_str ) do |ypath|
-                seg = match_segment( ypath, 0 )
-                matches += seg if seg
-            end
-            matches.uniq
-        end
-
-        #
-        # Search a node for a single YPath segment
-        #
-        def match_segment( ypath, depth )
-            deep_nodes = []
-            seg = ypath.segments[ depth ]
-            if seg == "/"
-                unless String === @value
-                    idx = -1
-                    @value.collect { |v|
-                        idx += 1
-                        if Hash === @value
-                            match_init = [v[0].transform, v[1]]
-                            match_deep = v[1].match_segment( ypath, depth )
-                        else
-                            match_init = [idx, v]
-                            match_deep = v.match_segment( ypath, depth )
-                        end
-                        if match_deep
-                            match_deep.each { |m|
-                                deep_nodes.push( match_init + m )
-                            }
-                        end
-                    }
-                end
-                depth += 1
-                seg = ypath.segments[ depth ]
-            end
-            match_nodes =
-                case seg
-                when "."
-                    [[nil, self]]
-                when ".."
-                    [["..", nil]]
-                when "*"
-                    if @value.is_a? Enumerable
-                        idx = -1
-                        @value.collect { |h|
-                            idx += 1
-                            if Hash === @value
-                                [h[0].transform, h[1]]
-                            else
-                                [idx, h]
-                            end
-                        }
-                    end
-                else
-                    if seg =~ /^"(.*)"$/
-                        seg = $1
-                    elsif seg =~ /^'(.*)'$/
-                        seg = $1
-                    end
-                    if ( v = at( seg ) )
-                        [[ seg, v ]]
-                    end
-                end
-            return deep_nodes unless match_nodes
-            pred = ypath.predicates[ depth ]
-            if pred
-                case pred
-                when /^\.=/
-                    pred = $'   # '
-                    match_nodes.reject! { |n|
-                        n.last.value != pred
-                    }
-                else
-                    match_nodes.reject! { |n|
-                        n.last.at( pred ).nil?
-                    }
-                end
-            end
-            return match_nodes + deep_nodes unless ypath.segments.length > depth + 1
-
-            #puts "DEPTH: #{depth + 1}"
-            deep_nodes = []
-            match_nodes.each { |n|
-                if n[1].is_a? BaseNode
-                    match_deep = n[1].match_segment( ypath, depth + 1 )
-                    if match_deep
-                        match_deep.each { |m|
-                            deep_nodes.push( n + m )
-                        }
-                    end
-                else
-                    deep_nodes = []
-                end
-            }
-            deep_nodes = nil if deep_nodes.length == 0
-            deep_nodes
-        end
-
-        #
-        # We want the node to act like as Hash
-        # if it is.
-        #
-        def []( *key )
-            if Hash === @value
-                v = @value.detect { |k,| k.transform == key.first }
-                v[1] if v
-            elsif Array === @value
-                @value.[]( *key )
-            end
-        end
-
-        def children
-            if Hash === @value
-                @value.values.collect { |c| c[1] }
-            elsif Array === @value
-                @value
-            end
-        end
-
-        def children_with_index
-            if Hash === @value
-                @value.keys.collect { |i| [self[i], i] }
-            elsif Array === @value
-                i = -1; @value.collect { |v| i += 1; [v, i] }
-            end
-        end
-
-        def emit
-            transform.to_yaml
-        end
-    end
-
-end
-

data/lib/yaml/constants.rb

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

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

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

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

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