rubysl-yaml 2.0.0 → 2.0.2

data/lib/syck/stream.rb

@@ -0,0 +1,41 @@
+module Syck
+
+	#
+	# 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 )
+                  warn "#{caller[0]}: edit is deprecated" if $VERBOSE
+			@documents[ doc_num ] = doc
+		end
+
+		def emit( io = nil )
+            # opts = @options.dup
+			# opts[:UseHeader] = true if @documents.length > 1
+            out = Syck.emitter
+            out.reset( io || io2 = StringIO.new )
+            @documents.each { |v|
+                v.to_yaml( out )
+            }
+            io || ( io2.rewind; io2.read )
+		end
+
+	end
+
+end

data/lib/syck/tag.rb

@@ -0,0 +1,95 @@
+# -*- mode: ruby; ruby-indent-level: 4; tab-width: 4 -*- vim: sw=4 ts=4
+# $Id: tag.rb 27365 2010-04-16 20:31:59Z tenderlove $
+#
+# = yaml/tag.rb: methods for associating a taguri to a class.
+#
+# Author:: why the lucky stiff
+#
+module Syck
+    # 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
+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 syck_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
+                    Syck.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 != Syck.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
+        Syck.tag_class tag, self
+    ensure
+        $VERBOSE = verbose
+    end
+    remove_method :yaml_as rescue nil
+    alias :yaml_as :syck_yaml_as
+
+    # 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
+    # :startdoc:
+end

data/lib/syck/types.rb

@@ -0,0 +1,192 @@
+# -*- mode: ruby; ruby-indent-level: 4 -*- vim: sw=4
+#
+# Classes required by the full core typeset
+#
+
+module Syck
+
+    #
+    # 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 = {} )
+            Syck.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 Syck::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 Syck::Error, "Invalid !omap entry: " + val.inspect
+                    end
+                end
+            else
+                raise Syck::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 = {} )
+            Syck.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 Syck::Error, "Invalid !pairs entry: " + val.inspect
+                    end
+                end
+            else
+                raise Syck::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 = {} )
+            Syck.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/syck/yamlnode.rb

@@ -0,0 +1,54 @@
+#
+# YAML::YamlNode class
+#
+require 'syck/basenode'
+
+module Syck
+
+    #
+    # 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 {|key,val|
+                    @value[key.transform] = [key, val]
+                }
+            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
+            Syck.transfer_method( @type_id, t )
+        end
+
+    end
+
+end

data/lib/syck/ypath.rb

@@ -0,0 +1,54 @@
+#
+# YAML::YPath
+#
+
+warn "#{caller[0]}: YAML::YPath is deprecated" if $VERBOSE
+
+module Syck
+
+    class YPath
+        attr_accessor :segments, :predicates, :flags
+        def initialize( str )
+            @segments = []
+            @predicates = []
+            @flags = nil
+            while str =~ /^\/?(\/|[^\/\[]+)(?:\[([^\]]+)\])?/
+                @segments.push $1
+                @predicates.push $2
+                str = $'
+            end
+            unless str.to_s.empty?
+                @segments += str.split( "/" )
+            end
+            if @segments.length == 0
+                @segments.push "."
+            end
+        end
+        def self.each_path( str )
+            #
+            # Find choices
+            #
+            paths = []
+            str = "(#{ str })"
+            while str.sub!( /\(([^()]+)\)/, "\n#{ paths.length }\n" )
+                paths.push $1.split( '|' )
+            end
+
+            #
+            # Construct all possible paths
+            #
+            all = [ str ]
+            ( paths.length - 1 ).downto( 0 ) do |i|
+                all = all.collect do |a|
+                    paths[i].collect do |p|
+                        a.gsub( /\n#{ i }\n/, p )
+                    end
+                end.flatten.uniq
+            end
+            all.collect do |path|
+                yield YPath.new( path )
+            end
+        end
+    end
+
+end

data/lib/yaml/dbm.rb

@@ -15,34 +15,43 @@ module YAML
 #
 # See the documentation for ::DBM and ::YAML for more information.
 class DBM < ::DBM
-    VERSION = "0.1"
+    VERSION = "0.1" # :nodoc:
 
+    # :call-seq:
+    #   ydbm[key] -> value
+    #
     # Return value associated with +key+ from database.
     #
     # Returns +nil+ if there is no such +key+.
+    #
+    # See #fetch for more information.
     def []( key )
         fetch( key )
     end
 
     # :call-seq:
-    #   []=( key, value )
+    #   ydbm[key] = value
     #
     # Set +key+ to +value+ in database.
     #
     # +value+ will be converted to YAML before storage.
+    #
+    # See #store for more information.
     def []=( key, val )
         store( key, val )
     end
 
     # :call-seq:
-    #   fetch( key, ifnone = nil )
-    #   fetch( key, &block )
+    #   ydbm.fetch( key, ifnone = nil )
+    #   ydbm.fetch( key ) { |key| ... }
     #
     # Return value associated with +key+.
     #
     # If there is no value for +key+ and no block is given, returns +ifnone+.
     #
     # Otherwise, calls block passing in the given +key+.
+    #
+    # See ::DBM#fetch for more information.
     def fetch( keystr, ifnone = nil )
         begin
             val = super( keystr )
@@ -57,15 +66,35 @@ class DBM < ::DBM
     end
 
     # Deprecated, used YAML::DBM#key instead.
+    # ----
+    # Note:
+    # YAML::DBM#index makes warning from internal of ::DBM#index.
+    # It says 'DBM#index is deprecated; use DBM#key', but DBM#key
+    # behaves not same as DBM#index.
+    #
     def index( keystr )
         super( keystr.to_yaml )
     end
 
+    # :call-seq:
+    #   ydbm.key(value) -> string
+    #
+    # Returns the key for the specified value.
+    def key( keystr )
+        invert[keystr]
+    end
+
+    # :call-seq:
+    #   ydbm.values_at(*keys)
+    #
     # Returns an array containing the values associated with the given keys.
     def values_at( *keys )
         keys.collect { |k| fetch( k ) }
     end
 
+    # :call-seq:
+    #   ydbm.delete(key)
+    #
     # Deletes value from database associated with +key+.
     #
     # Returns value or +nil+.
@@ -77,6 +106,9 @@ class DBM < ::DBM
         v
     end
 
+    # :call-seq:
+    #   ydbm.delete_if { |key, value| ... }
+    #
     # Calls the given block once for each +key+, +value+ pair in the database.
     # Deletes all entries for which the block returns true.
     #
@@ -88,6 +120,9 @@ class DBM < ::DBM
         self
     end
 
+    # :call-seq:
+    #   ydbm.reject { |key, value| ... }
+    #
     # Converts the contents of the database to an in-memory Hash, then calls
     # Hash#reject with the specified code block, returning a new Hash.
     def reject
@@ -95,6 +130,9 @@ class DBM < ::DBM
         hsh.reject { |k,v| yield k, v }
     end
 
+    # :call-seq:
+    #   ydbm.each_pair { |key, value| ... }
+    #
     # Calls the given block once for each +key+, +value+ pair in the database.
     #
     # Returns +self+.
@@ -103,6 +141,9 @@ class DBM < ::DBM
         self
     end
 
+    # :call-seq:
+    #   ydbm.each_value { |value| ... }
+    #
     # Calls the given block for each value in database.
     #
     # Returns +self+.
@@ -111,17 +152,26 @@ class DBM < ::DBM
         self
     end
 
+    # :call-seq:
+    #   ydbm.values
+    #
     # Returns an array of values from the database.
     def values
         super.collect { |v| YAML.load( v ) }
     end
 
-    # Returns true if specified value is found in the database.
+    # :call-seq:
+    #   ydbm.has_value?(value)
+    #
+    # Returns true if specified +value+ is found in the database.
     def has_value?( val )
         each_value { |v| return true if v == val }
         return false
     end
 
+    # :call-seq:
+    #   ydbm.invert -> hash
+    #
     # Returns a Hash (not a DBM database) created by using each value in the
     # database as a key, with the corresponding key as its value.
     #
@@ -133,6 +183,9 @@ class DBM < ::DBM
         h
     end
 
+    # :call-seq:
+    #   ydbm.replace(hash) -> ydbm
+    #
     # Replaces the contents of the database with the contents of the specified
     # object. Takes any object which implements the each_pair method, including
     # Hash and DBM objects.
@@ -141,6 +194,9 @@ class DBM < ::DBM
         update( hsh )
     end
 
+    # :call-seq:
+    #   ydbm.shift -> [key, value]
+    #
     # Removes a [key, value] pair from the database, and returns it.
     # If the database is empty, returns +nil+.
     #
@@ -152,8 +208,8 @@ class DBM < ::DBM
     end
 
     # :call-seq:
-    #   select( &block )
-    #   select( *keys )
+    #   ydbm.select { |key, value| ... }
+    #   ydbm.select(*keys)
     #
     # If a block is provided, returns a new array containing [key, value] pairs
     # for which the block returns true.
@@ -168,29 +224,35 @@ class DBM < ::DBM
     end
 
     # :call-seq:
-    #   store( key, value )
+    #   ydbm.store(key, value) -> value
     #
-    #Stores +value+ in database with +key+ as the index. +value+ is converted
-    #to YAML before being stored.
+    # Stores +value+ in database with +key+ as the index. +value+ is converted
+    # to YAML before being stored.
     #
-    #Returns +value+
+    # Returns +value+
     def store( key, val )
         super( key, val.to_yaml )
         val
     end
 
+    # :call-seq:
+    #   ydbm.update(hash) -> ydbm
+    #
     # Updates the database with multiple values from the specified object.
     # Takes any object which implements the each_pair method, including
     # Hash and DBM objects.
     #
     # Returns +self+.
     def update( hsh )
-        hsh.keys.each do |k|
-            self.store( k, hsh.fetch( k ) )
+        hsh.each_pair do |k,v|
+            self.store( k, v )
         end
         self
     end
 
+    # :call-seq:
+    #   ydbm.to_a -> array
+    #
     # Converts the contents of the database to an array of [key, value] arrays,
     # and returns it.
     def to_a
@@ -200,6 +262,9 @@ class DBM < ::DBM
     end
 
 
+    # :call-seq:
+    #   ydbm.to_hash -> hash
+    #
     # Converts the contents of the database to an in-memory Hash object, and
     # returns it.
     def to_hash