class Haml::Buffer

def self.merge_attrs(to, from)
  from['id'] = Compiler.filter_and_join(from['id'], '_') if from['id']
  if to['id'] && from['id']
    to['id'] << '_' << from.delete('id').to_s
  elsif to['id'] || from['id']
    from['id'] ||= to['id']
  end
  from['class'] = Compiler.filter_and_join(from['class'], ' ') if from['class']
  if to['class'] && from['class']
    # Make sure we don't duplicate class names
    from['class'] = (from['class'].to_s.split(' ') | to['class'].split(' ')).sort.join(' ')
  elsif to['class'] || from['class']
    from['class'] ||= to['class']
  end
  from_data = from.delete('data') || {}
  to_data = to.delete('data') || {}
  # forces to_data & from_data into a hash
  from_data = { nil => from_data } unless from_data.is_a?(Hash)
  to_data = { nil => to_data } unless to_data.is_a?(Hash)
  merged_data = to_data.merge(from_data)
  to['data'] = merged_data unless merged_data.empty?
  to.merge!(from)
end

def active?
  @active
end

def adjust_tabs(tab_change)
  @real_tabs += tab_change
end

def attributes(class_id, obj_ref, *attributes_hashes)
  attributes = class_id
  attributes_hashes.each do |old|
    self.class.merge_attrs(attributes, Hash[old.map {|k, v| [k.to_s, v]}])
  end
  self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
  Compiler.build_attributes(
    html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
end

def html4?
  @options[:format] == :html4
end

def html5?
  @options[:format] == :html5
end

def html?
  html4? or html5?
end

def initialize(upper = nil, options = {})
  @active     = true
  @upper      = upper
  @options    = options
  @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
  @preserve_pattern = /<[\s]*#{@options[:preserve].join("|")}/i
end

def new_encoded_string
  ""
end

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

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' => id, 'class' => class_name}
end

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
  @buffer << text
  @real_tabs += tab_change
end

def rstrip!
  if capture_position.nil?
    buffer.rstrip!
    return
  end
  buffer << buffer.slice!(capture_position..-1).rstrip
end

def tabs(count = 0)
  tabs = [count + @tabulation, 0].max
  @@tab_cache[tabs] ||= '  ' * tabs
end

def tabulation
  @real_tabs + @tabulation
end

def tabulation=(val)
  val = val - @real_tabs
  @tabulation = val > -1 ? val : 0
end

def toplevel?
  upper.nil?
end

def underscore(camel_cased_word)
  camel_cased_word.to_s.gsub(/::/, '_').
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').
    tr("-", "_").
    downcase
end

def xhtml?
  not html?
end