In Files

  • syck/lib/syck/baseemitter.rb

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