In Files

  • yaml/baseemitter.rb

YAML::BaseEmitter

Public Instance Methods

binary_base64( value ) click to toggle source

Emit binary data

 
               # File yaml/baseemitter.rb, line 28
def binary_base64( value )
    self << "!binary "
    self.node_text( [value].pack("m"), '|' )
end
            
double( value ) click to toggle source

Emit double-quoted string

 
               # File yaml/baseemitter.rb, line 89
def double( value )
        "\"#{YAML.escape( value )}\"" 
end
            
fold( value ) click to toggle source

Folding paragraphs within a column

 
               # File yaml/baseemitter.rb, line 134
    def fold( value )
value.gsub( /(^[ \t]+.*$)|(\S.{0,#{options(:BestWidth) - 1}})(?:[ \t]+|(\n+(?=[ \t]|\Z))|$)/ ) do
    $1 || $2 + ( $3 || "\n" )
end
    end
            
indent( mod = nil ) click to toggle source

Write a current indent

 
               # File yaml/baseemitter.rb, line 113
def indent( mod = nil )
    #p [ self.id, level, mod, :INDENT ]
    if level <= 0
        mod ||= 0
    else
        mod ||= options(:Indent)
        mod += ( level - 1 ) * options(:Indent)
    end
    return " " * mod
        end
            
indent!() click to toggle source

Add indent to the buffer

 
               # File yaml/baseemitter.rb, line 127
def indent!
        self << indent
end
            
indent_text( text, mod, first_line = true ) click to toggle source

Write a text block with the current indent

 
               # File yaml/baseemitter.rb, line 103
    def indent_text( text, mod, first_line = true )
            return "" if text.to_s.empty?
spacing = indent( mod )
text = text.gsub( /\A([^\n])/, "#{ spacing }\\1" ) if first_line
            return text.gsub( /\n^([^\n])/, "\n#{spacing}\\1" )
    end
            
map( type, &e ) click to toggle source

Quick mapping

 
               # File yaml/baseemitter.rb, line 143
def map( type, &e )
    val = Mapping.new
    e.call( val )
                self << "#{type} " if type.length.nonzero?

                #
                # Empty hashes
                #
                if val.length.zero?
                        self << "{}"
        @seq_map = false
                else
        # FIXME
        # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero? 
                    #     @headless = 1 
        # end

        defkey = @options.delete( :DefaultKey )
        if defkey
            seq_map_shortcut
            self << "= : "
            defkey.to_yaml( :Emitter => self )
        end

                        #
                        # Emit the key and value
                        #
        val.each { |v|
            seq_map_shortcut
            if v[0].is_complex_yaml?
                self << "? "
            end
            v[0].to_yaml( :Emitter => self )
            if v[0].is_complex_yaml?
                self << "\n"
                indent!
            end
            self << ": " 
            v[1].to_yaml( :Emitter => self )
        }
                end
end
            
node_text( value, block = nil ) click to toggle source

Emit plain, normal flowing text

 
               # File yaml/baseemitter.rb, line 36
    def node_text( value, block = nil )
@seq_map = false
            valx = value.dup
unless block
block =
    if options(:UseBlock)
        '|'
    elsif not options(:UseFold) and valx =~ /\n[ \t]/ and not valx =~ /#{YAML::ESCAPE_CHAR}/
        '|'
    else
        '>'
    end 

    indt = $&.to_i if block =~ /\d+/
    if valx =~ /(\A\n*[ \t#]|^---\s+)/
        indt = options(:Indent) unless indt.to_i > 0
        block += indt.to_s
    end

block +=
    if valx =~ /\n\Z\n/
        "+"
    elsif valx =~ /\Z\n/
        ""
    else
        "-"
    end
end
block += "\n"
if block[0] == "
    esc_skip = ( "\t\n" unless valx =~ /^[ \t]/ ) || ""
    valx = fold( YAML::escape( valx, esc_skip ) + "\"" ).chomp
    self << '"' + indent_text( valx, indt, false )
else
    if block[0] == > 
        valx = fold( valx ) 
    end
    #p [block, indt]
    self << block + indent_text( valx, indt )
end
    end
            
options( opt = nil ) click to toggle source
 
               # File yaml/baseemitter.rb, line 13
def options( opt = nil )
    if opt
        @options[opt] || YAML::DEFAULTS[opt]
    else
        @options
    end
end
            
options=( opt ) click to toggle source
 
               # File yaml/baseemitter.rb, line 21
def options=( opt )
    @options = opt
end
            
seq( type, &e ) click to toggle source

Quick sequence

 
               # File yaml/baseemitter.rb, line 200
def seq( type, &e )
    @seq_map = false
    val = Sequence.new
    e.call( val )
                self << "#{type} " if type.length.nonzero?

                #
                # Empty arrays
                #
                if val.length.zero?
                        self << "[]"
                else
        # FIXME
        # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero? 
                    #     @headless = 1 
        # end

                        #
                        # Emit the key and value
                        #
        val.each { |v|
            self << "\n"
            indent!
            self << "- "
            @seq_map = true if v.class == Hash
            v.to_yaml( :Emitter => self )
        }
                end
end
            
seq_map_shortcut() click to toggle source
 
               # File yaml/baseemitter.rb, line 186
def seq_map_shortcut
    # FIXME: seq_map needs to work with the new anchoring system
    # if @seq_map
    #     @anchor_extras[@buffer.length - 1] = "\n" + indent
    #     @seq_map = false
    # else
        self << "\n"
        indent! 
    # end
end
            
simple( value ) click to toggle source

Emit a simple, unqouted string

 
               # File yaml/baseemitter.rb, line 81
    def simple( value )
@seq_map = false
self << value.to_s
    end
            
single( value ) click to toggle source

Emit single-quoted string

 
               # File yaml/baseemitter.rb, line 96
def single( value )
        "'#{value}'"
end