# module Syck::BaseEmitter

### Public Instance Methods

binary_base64( value ) click to toggle source

Emit binary data

    # File 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 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 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 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 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 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 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 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 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 lib/syck/baseemitter.rb, line 19
    def options=( opt )
      @options = opt
    end

seq( type, &e ) click to toggle source

Quick sequence

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