class Haml::Buffer

and helps reduce the amount of processing done within ‘instance_eval`ed code.
It’s called from within the precompiled code,
is eventually output as the resulting document.
This class is used only internally. It holds the buffer of HTML that

def active?

Returns:
  • (Boolean) -
def active?
  @active
end

def adjust_tabs(tab_change)

Parameters:
  • tab_change (Fixnum) -- The number of tabs by which to increase
def adjust_tabs(tab_change)
  @real_tabs += tab_change
end

def attributes(class_id, obj_ref, *attributes_hashes)

def attributes(class_id, obj_ref, *attributes_hashes)
  attributes = class_id
  attributes_hashes.each do |old|
    result = {}
    old.each { |k, v| result[k.to_s] = v }
    AttributeBuilder.merge_attributes!(attributes, result)
  end
  AttributeBuilder.merge_attributes!(attributes, parse_object_ref(obj_ref)) if obj_ref
  AttributeBuilder.build_attributes(
    html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
end

def fix_textareas!(input)

Other tags:
    Private: -

Other tags:
    Since: - Haml 4.0.1

Parameters:
  • input (String) -- The text to process
def fix_textareas!(input)
  return input unless input.include?('<textarea'.freeze)
  pattern = /<(textarea)([^>]*)>(\n|&#x000A;)(.*?)<\/textarea>/im
  input.gsub!(pattern) do |s|
    match = pattern.match(s)
    content = match[4]
    if match[3] == '&#x000A;'
      content.sub!(/\A /, '&#x0020;')
    else
      content.sub!(/\A[ ]*/, '')
    end
    "<#{match[1]}#{match[2]}>\n#{content}</#{match[1]}>"
  end
  input
end

def html4?

Returns:
  • (Boolean) - Whether or not the format is HTML4
def html4?
  @options[:format] == :html4
end

def html5?

Returns:
  • (Boolean) - Whether or not the format is HTML5.
def html5?
  @options[:format] == :html5
end

def html?

Returns:
  • (Boolean) - Whether or not the format is any flavor of HTML
def html?
  html4? or html5?
end

def initialize(upper = nil, options = {})

Parameters:
  • options ({Symbol => Object}) -- An options hash.
  • upper (Buffer) -- The parent buffer
def initialize(upper = nil, options = {})
  @active     = true
  @upper      = upper
  @options    = Options.buffer_defaults
  @options    = @options.merge(options) unless options.empty?
  @buffer     = new_encoded_string
  @tabulation = 0
  # The number of tabs that Engine thinks we should have
  # @real_tabs + @tabulation is the number of tabs actually output
  @real_tabs = 0
end

def new_encoded_string

def new_encoded_string
  "".encode(options[:encoding])
end

def parse_object_ref(ref)

just like you can do with `dom_id()` and `dom_class()` in Rails
The second object, if present, is used as a prefix,
one to create an attributes hash.
Takes an array of objects and uses the class and id of the first
def parse_object_ref(ref)
  prefix = ref[1]
  ref = ref[0]
  # Let's make sure the value isn't nil. If it is, return the default Hash.
  return {} if ref.nil?
  class_name =
    if ref.respond_to?(:haml_object_ref)
      ref.haml_object_ref
    else
      underscore(ref.class)
    end
  ref_id =
    if ref.respond_to?(:to_key)
      key = ref.to_key
      key.join('_') unless key.nil?
    else
      ref.id
    end
  id = "#{class_name}_#{ref_id || 'new'}"
  if prefix
    class_name = "#{ prefix }_#{ class_name}"
    id = "#{ prefix }_#{ id }"
  end
  { 'id'.freeze => id, 'class'.freeze => class_name }
end

def push_text(text, tab_change, dont_tab_up)

Parameters:
  • dont_tab_up (Boolean) -- If true, don't indent the first line of `text`
  • tab_change (Fixnum) -- The number of tabs by which to increase
  • text (String) -- The text to append
def push_text(text, tab_change, dont_tab_up)
  if @tabulation > 0
    # Have to push every line in by the extra user set tabulation.
    # Don't push lines with just whitespace, though,
    # because that screws up precompiled indentation.
    text.gsub!(/^(?!\s+$)/m, tabs)
    text.sub!(tabs, '') if dont_tab_up
  end
  @real_tabs += tab_change
  @buffer << text
end

def rstrip!

Doesn't do anything if we're at the beginning of a capture_haml block.
Remove the whitespace from the right side of the buffer string.
def rstrip!
  if capture_position.nil?
    buffer.rstrip!
    return
  end
  buffer << buffer.slice!(capture_position..-1).rstrip
end

def tabs(count = 0)

Gets `count` tabs. Mostly for internal use.
def tabs(count = 0)
  tabs = [count + @tabulation, 0].max
  @@tab_cache[tabs] ||= '  ' * tabs
end

def tabulation

Returns:
  • (Fixnum) - The current indentation level of the document
def tabulation
  @real_tabs + @tabulation
end

def tabulation=(val)

Parameters:
  • val (Fixnum) -- The new tabulation
def tabulation=(val)
  val = val - @real_tabs
  @tabulation = val > -1 ? val : 0
end

def toplevel?

Returns:
  • (Boolean) - Whether or not this buffer is a top-level template,
def toplevel?
  upper.nil?
end

def underscore(camel_cased_word)

but copied here so it'll run properly without Rails.
Based on the method of the same name in Rails' Inflector,
Changes a word from camel case to underscores.
def underscore(camel_cased_word)
  word = camel_cased_word.to_s.dup
  word.gsub!(/::/, '_')
  word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
  word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
  word.tr!('-', '_')
  word.downcase!
  word
end

def xhtml?

Returns:
  • (Boolean) - Whether or not the format is XHTML
def xhtml?
  not html?
end