syck 1.0.0

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/stringio.rb

@@ -0,0 +1,85 @@
+warn "#{caller[0]}: yaml/stringio is deprecated" if $VERBOSE
+
+#
+# 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 Syck.make_stream( io )
+        if String === io
+            io = StringIO.new( io )
+        elsif not IO === io
+            raise Syck::Error, "YAML stream must be an IO or String object."
+        end
+        if Syck::unicode
+            def io.readline
+                Syck.utf_to_internal( readline( @ln_sep ), @utf_encoding )
+            end
+            def io.check_unicode
+                @utf_encoding = Syck.sniff_encoding( read( 4 ) )
+                @ln_sep = Syck.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/syck/syck.rb

@@ -0,0 +1,16 @@
+#
+# YAML::Syck module
+# .. glues syck and yaml.rb together ..
+#
+require 'syck/basenode'
+
+module Syck
+
+  #
+  # Mixin BaseNode functionality
+  #
+  class Node
+    include Syck::BaseNode
+  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$
+#
+# = 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