Syck::BaseEmitter

Public Instance Methods

binary_base64( value ) click to toggle source

Emit binary data

 
               # File syck/lib/syck/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 syck/lib/syck/baseemitter.rb, line 86
def double( value )
  "\"#{Syck.escape( value )}\""
end
            
fold( value ) click to toggle source

Folding paragraphs within a column

 
               # File syck/lib/syck/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 syck/lib/syck/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 syck/lib/syck/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 syck/lib/syck/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 syck/lib/syck/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 syck/lib/syck/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 =~ /#{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( Syck.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 syck/lib/syck/baseemitter.rb, line 11
def options( opt = nil )
  if opt
    @options[opt] || DEFAULTS[opt]
  else
    @options
  end
end
            
options=( opt ) click to toggle source
 
               # File syck/lib/syck/baseemitter.rb, line 19
def options=( opt )
  @options = opt
end
            
seq( type, &e ) click to toggle source

Quick sequence

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

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

If you are posting code samples in your comments, please wrap them in "<pre><code class="ruby" > ... </code></pre>" markup in order to get syntax highlighting.

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 a bug report so that it can be corrected for the next release. Thank you.

blog comments powered by Disqus