YAML (Module)

In: yaml.rb
                                                                                              vim:sw=4:ts=4

$Id: yaml.rb,v 1.8 2003/07/11 22:52:14 why Exp $

  YAML.rb

  Loads the parser/loader and emitter/writer.

Public Class methods

Load a single document from the current stream

[Source]

# File yaml.rb, line 29
        def YAML.dump( obj, io = nil )
        io ||= ""
        io << obj.to_yaml
        io
        end

Load a single document from the current stream

[Source]

# File yaml.rb, line 38
        def YAML.load( io )
                yp = @@parser.new.load( io )
        end

Parse a single document from the current stream

[Source]

# File yaml.rb, line 45
        def YAML.parse( io )
                yp = @@parser.new( :Model => :Generic ).load( io )
        end

Load all documents from the current stream

[Source]

# File yaml.rb, line 52
        def YAML.each_document( io, &doc_proc )
                yp = @@parser.new.load_documents( io, &doc_proc )
    end

Identical to each_document

[Source]

# File yaml.rb, line 59
        def YAML.load_documents( io, &doc_proc )
                YAML.each_document( io, &doc_proc )
    end

Parse all documents from the current stream

[Source]

# File yaml.rb, line 66
        def YAML.each_node( io, &doc_proc )
                yp = @@parser.new( :Model => :Generic ).load_documents( io, &doc_proc )
    end

Parse all documents from the current stream

[Source]

# File yaml.rb, line 73
        def YAML.parse_documents( io, &doc_proc )
                YAML.each_node( io, &doc_proc )
    end

Load all documents from the current stream

[Source]

# File yaml.rb, line 80
        def YAML.load_stream( io )
                yp = @@parser.new
                d = nil
                yp.load_documents( io ) { |doc|
                        d = YAML::Stream.new( yp.options ) if not d
                        d.add( doc ) 
                }
                return d
        end

Add a transfer method to a domain

[Source]

# File yaml.rb, line 93
        def YAML.add_domain_type( domain, type_re, &transfer_proc )
        @@loader.add_domain_type( domain, type_re, &transfer_proc )
        end

Add a transfer method for a builtin type

[Source]

# File yaml.rb, line 100
        def YAML.add_builtin_type( type_re, &transfer_proc )
            @@loader.add_builtin_type( type_re, &transfer_proc )
        end

Add a transfer method for a builtin type

[Source]

# File yaml.rb, line 107
        def YAML.add_ruby_type( type, &transfer_proc )
        @@loader.add_ruby_type( type, &transfer_proc )
        end

Add a private document type

[Source]

# File yaml.rb, line 114
        def YAML.add_private_type( type_re, &transfer_proc )
            @@loader.add_private_type( type_re, &transfer_proc )
        end

Detect typing of a string

[Source]

# File yaml.rb, line 121
    def YAML.detect_implicit( val )
        @@loader.detect_implicit( val )
    end

Apply a transfer method to a Ruby object

[Source]

# File yaml.rb, line 128
    def YAML.transfer( type_id, obj )
        @@loader.transfer( type_id, obj )
    end

Apply any implicit a node may qualify for

[Source]

# File yaml.rb, line 135
        def YAML.try_implicit( obj )
                YAML.transfer( YAML.detect_implicit( obj ), obj )
        end

Method to extract colon-seperated type and class, returning the type and the constant of the class

[Source]

# File yaml.rb, line 143
    def YAML.read_type_class( type, obj_class )
        scheme, domain, type, tclass = type.split( ':', 4 )
        tclass.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tclass
        return [ type, obj_class ]
    end

Allocate blank object

[Source]

# File yaml.rb, line 152
    def YAML.object_maker( obj_class, val, is_attr = false )
        if Hash === val
            name = obj_class.name
            ostr = sprintf( "\004\006o:%c%s\000", name.length + 5, name )
            if is_attr
                ostr[ -1, 1 ] = Marshal.dump( val ).sub( /^[^{]+\{/, '' )
                                p ostr
            end
            o = ::Marshal.load( ostr )
            unless is_attr
                val.each_pair { |k,v|
                    o.instance_eval "@#{k} = v"
                }
            end
            o
        else
            raise YAML::Error, "Invalid object explicitly tagged !ruby/Object: " + val.inspect
        end
    end

Allocate an Emitter if needed

[Source]

# File yaml.rb, line 175
        def YAML.quick_emit( oid, opts = {}, &e )
                old_opt = nil
                if opts[:Emitter].is_a? @@emitter
                        out = opts.delete( :Emitter )
                        old_opt = out.options.dup
                        out.options.update( opts )
                else
                        out = @@emitter.new( opts )
                end
        aidx = out.start_object( oid )
        if aidx
            out.simple( "*#{ aidx }" )
        else
            e.call( out )
        end
                if old_opt.is_a? Hash
                        out.options = old_opt
                end 
                out.end_object
        end

[Validate]