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 26
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 86
def double( value )
  "\"#{YAML.escape( value )}\"" 
end
            
fold( value ) click to toggle source

Folding paragraphs within a column

 
               # File yaml/baseemitter.rb, line 131
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 110
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 124
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 100
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 140
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 34
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 11
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 19
def options=( opt )
  @options = opt
end
            
seq( type, &e ) click to toggle source

Quick sequence

 
               # File yaml/baseemitter.rb, line 197
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 183
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 78
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 93
def single( value )
  "'#{value}'"
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus