# 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.

## Methods

add_builtin_type add_domain_type add_private_type add_ruby_type detect_implicit dump each_document each_node load load_documents load_stream object_maker parse parse_documents quick_emit read_type_class transfer try_implicit

## Public Class methods

dump( obj, io = nil )

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( io )

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( io )

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

each_document( io, &doc_proc )

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

load_documents( io, &doc_proc )

Identical to each_document

[Source]

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

each_node( io, &doc_proc )

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_documents( io, &doc_proc )

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_stream( io )

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_domain_type( domain, type_re, &transfer_proc )

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_builtin_type( type_re, &transfer_proc )

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_ruby_type( type, &transfer_proc )

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_private_type( type_re, &transfer_proc )

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_implicit( val )

Detect typing of a string

[Source]

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

transfer( type_id, obj )

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

try_implicit( obj )

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

read_type_class( type, obj_class )

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

object_maker( obj_class, val, is_attr = false )

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

quick_emit( oid, opts = {}, &e )

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]