module Haml::Helpers

def self.action_view?
  @@action_view_defined
end

def block_is_haml?(block)
  eval('!!defined?(_hamlout)', block.binding)
end

def capture_haml(*args, &block)
  buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer
  with_haml_buffer(buffer) do
    position = haml_buffer.buffer.length
    haml_buffer.capture_position = position
    value = block.call(*args)
    captured = haml_buffer.buffer.slice!(position..-1)
    if captured == '' and value != haml_buffer.buffer
      captured = (value.is_a?(String) ? value : nil)
    end
    captured
  end
ensure
  haml_buffer.capture_position = nil
end

def escape_once(text)
  text = text.to_s
  text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
end

def find_and_preserve(input = nil, tags = haml_buffer.options[:preserve], &block)
  return find_and_preserve(capture_haml(&block), input || tags) if block
  tags = tags.each_with_object('') do |t, s|
    s << '|' unless s.empty?
    s << Regexp.escape(t)
  end
  re = /<(#{tags})([^>]*)>(.*?)(<\/\1>)/im
  input.to_s.gsub(re) do |s|
    s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
    "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
  end
end

def haml_bind_proc(&proc)
  _hamlout = haml_buffer
  #double assignment is to avoid warnings
  _erbout = _erbout = _hamlout.buffer
  proc { |*args| proc.call(*args) }
end

def haml_buffer
  @haml_buffer if defined? @haml_buffer
end

def haml_concat(text = "")
  haml_internal_concat text
  ErrorReturn.new("haml_concat")
end

def haml_indent
  '  ' * haml_buffer.tabulation
end

def haml_internal_concat(text = "", newline = true, indent = true)
  if haml_buffer.tabulation == 0
    haml_buffer.buffer << "#{text}#{"\n" if newline}"
  else
    haml_buffer.buffer << %[#{haml_indent if indent}#{text.to_s.gsub("\n", "\n#{haml_indent}")}#{"\n" if newline}]
  end
end

def haml_tag(name, *rest, &block)
  ret = ErrorReturn.new("haml_tag")
  text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
  flags = []
  flags << rest.shift while rest.first.is_a? Symbol
  attrs = (rest.shift || {})
  attrs.keys.each {|key| attrs[key.to_s] = attrs.delete(key)} unless attrs.empty?
  name, attrs = merge_name_and_attributes(name.to_s, attrs)
  attributes = Haml::AttributeBuilder.build_attributes(haml_buffer.html?,
    haml_buffer.options[:attr_wrapper],
    haml_buffer.options[:escape_attrs],
    haml_buffer.options[:hyphenate_data_attrs],
    attrs)
  if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
    haml_internal_concat_raw "<#{name}#{attributes}#{' /' if haml_buffer.options[:format] == :xhtml}>"
    return ret
  end
  if flags.include?(:/)
    raise Error.new(Error.message(:self_closing_content)) if text
    raise Error.new(Error.message(:illegal_nesting_self_closing)) if block
  end
  tag = "<#{name}#{attributes}>"
  end_tag = "</#{name}>"
  if block.nil?
    text = text.to_s
    if text.include?("\n")
      haml_internal_concat_raw tag
      tab_up
      haml_internal_concat text
      tab_down
      haml_internal_concat_raw end_tag
    else
      haml_internal_concat_raw tag, false
      haml_internal_concat text, false, false
      haml_internal_concat_raw end_tag, true, false
    end
    return ret
  end
  if text
    raise Error.new(Error.message(:illegal_nesting_line, name))
  end
  if flags.include?(:<)
    haml_internal_concat_raw tag, false
    haml_internal_concat "#{capture_haml(&block).strip}", false, false
    haml_internal_concat_raw end_tag, true, false
    return ret
  end
  haml_internal_concat_raw tag
  tab_up
  block.call
  tab_down
  haml_internal_concat_raw end_tag
  ret
end

def haml_tag_if(condition, *tag)
  if condition
    haml_tag(*tag){ yield }
  else
    yield
  end
  ErrorReturn.new("haml_tag_if")
end

def html_attrs(lang = 'en-US')
  if haml_buffer.options[:format] == :xhtml
    {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
  else
    {:lang => lang}
  end
end

def html_escape(text)
  ERB::Util.html_escape(text)
end

def init_haml_helpers
  @haml_buffer = Haml::Buffer.new(haml_buffer, Options.new.for_buffer)
  nil
end

def is_haml?
  !@haml_buffer.nil? && @haml_buffer.active?
end

def list_of(enum, opts={}, &block)
  opts_attributes = opts.each_with_object('') {|(k, v), s| s << " #{k}='#{v}'"}
  enum.each_with_object('') do |i, ret|
    result = capture_haml(i, &block)
    if result.count("\n") > 1
      result.gsub!("\n", "\n  ")
      result = "\n  #{result.strip!}\n"
    else
      result.strip!
    end
    ret << "\n" unless ret.empty?
    ret << %Q!<li#{opts_attributes}>#{result}</li>!
  end
end

def merge_name_and_attributes(name, attributes_hash = {})
  # skip merging if no ids or classes found in name
  return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
  return $1 || "div", AttributeBuilder.merge_attributes!(
    Haml::Parser.parse_class_and_id($2), attributes_hash)
end

def non_haml
  was_active = @haml_buffer.active?
  @haml_buffer.active = false
  yield
ensure
  @haml_buffer.active = was_active
end

def precede(str, &block)
  "#{str}#{capture_haml(&block).chomp}\n"
end

def preserve(input = nil, &block)
  return preserve(capture_haml(&block)) if block
  s = input.to_s.chomp("\n")
  s.gsub!(/\n/, '
')
  s.delete!("\r")
  s
end

def succeed(str, &block)
  "#{capture_haml(&block).chomp}#{str}\n"
end

def surround(front, back = front, &block)
  output = capture_haml(&block)
  "#{front}#{output.chomp}#{back}\n"
end

def tab_down(i = 1)
  haml_buffer.tabulation -= i
end

def tab_up(i = 1)
  haml_buffer.tabulation += i
end

def with_haml_buffer(buffer)
  @haml_buffer, old_buffer = buffer, @haml_buffer
  old_buffer.active, old_was_active = false, old_buffer.active? if old_buffer
  @haml_buffer.active, was_active = true, @haml_buffer.active?
  yield
ensure
  @haml_buffer.active = was_active
  old_buffer.active = old_was_active if old_buffer
  @haml_buffer = old_buffer
end

def with_tabs(i)
  old_tabs = haml_buffer.tabulation
  haml_buffer.tabulation = i
  yield
ensure
  haml_buffer.tabulation = old_tabs
end