Class: String

Inherits:

Object

• Object
• String

Defined in:

lib/vendor/puppet/util/zaml.rb,
lib/vendor/puppet/util/monkey_patches.rb

Constant Summary

ZAML_ESCAPES =

{
  "\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
  "\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
}

ASCII_ENCODING =

Encoding.find("ASCII-8BIT")

Instance Method Summary

• #lines(separator = $/) ⇒ Object
• #to_ascii8bit ⇒ Object
• #to_zaml(z) ⇒ Object

Instance Method Details

#lines(separator = $/) ⇒ Object

# File 'lib/vendor/puppet/util/monkey_patches.rb', line 151

def lines(separator = $/)
  lines = split(separator)
  block_given? and lines.each {|line| yield line }
  lines
end

#to_ascii8bit ⇒ Object

# File 'lib/vendor/puppet/util/zaml.rb', line 328

def to_ascii8bit
  if self.encoding == ASCII_ENCODING
    self
  else
    self.dup.force_encoding(ASCII_ENCODING)
  end
end

#to_zaml(z) ⇒ Object

# File 'lib/vendor/puppet/util/zaml.rb', line 279

def to_zaml(z)
  z.with_structured_prefix(self) do
    case
    when self == ''
      z.emit('""')
    when self.to_ascii8bit !~ /\A(?: # ?: non-capturing group (grouping with no back references)
               [\x09\x0A\x0D\x20-\x7E]            # ASCII
             | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
             |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
             | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
             |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
             |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
             | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
             |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
             )*\z/mnx
      # Emit the binary tag, then recurse. Ruby splits BASE64 output at the 60
      # character mark when packing strings, and we can wind up a multi-line
      # string here.  We could reimplement the multi-line string logic,
      # but why would we - this does just as well for producing solid output.
      z.emit("!binary ")
      [self].pack("m*").to_zaml(z)

    # Only legal UTF-8 characters can make it this far, so we are safe
    # against emitting something dubious. That means we don't need to mess
    # about, just emit them directly. --daniel 2012-07-14
    when ((self =~ /\A[a-zA-Z\/][-\[\]_\/.a-zA-Z0-9]*\z/) and
        (self !~ /^(?:true|false|yes|no|on|null|off)$/i))
      # simple string literal, safe to emit unquoted.
      z.emit(self)
    when (self =~ /\n/ and self !~ /\A\s/ and self !~ /\s\z/)
      # embedded newline, split line-wise in quoted string block form.
      if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
      z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
    else
      # ...though we still have to escape unsafe characters.
      escaped = gsub(/[\\"\x00-\x1F]/) do |c|
        ZAML_ESCAPES[c] || "\\x#{c[0].ord.to_s(16)}"
      end
      z.emit("\"#{escaped}\"")
    end
  end
end