module Haml::Util

def assert_html_safe!(text)
  return unless rails_xss_safe? && text && !text.to_s.html_safe?
  raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
end

def av_template_class(name)
  return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
  return ActionView::Template.const_get(name.to_s)
end

def def_static_method(klass, name, args, *vars)
  erb = vars.pop
  powerset(vars).each do |set|
    context = StaticConditionalContext.new(set).instance_eval {binding}
    klass.class_eval(<<METHOD)
#{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
ERB.new(erb).result(context)}
OD
  end
end

def enum_with_index(enum)
  ruby1_8? ? enum.enum_with_index : enum.each_with_index
end

def has?(attr, klass, method)
  klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
end

def map_hash(hash, &block)
  to_hash(hash.map(&block))
end

def map_keys(hash)
  to_hash(hash.map {|k, v| [yield(k), v]})
end

def map_vals(hash)
  to_hash(hash.map {|k, v| [k, yield(v)]})
end

def merge_adjacent_strings(enum)
  e = enum.inject([]) do |a, e|
    if e.is_a?(String) && a.last.is_a?(String)
      a.last << e
    else
      a << e
    end
    a
  end
end

def powerset(arr)
  arr.inject([Set.new].to_set) do |powerset, el|
    new_powerset = Set.new
    powerset.each do |subset|
      new_powerset << subset
      new_powerset << subset + [el]
    end
    new_powerset
  end
end

def rails_root
  return Rails.root.to_s if defined?(Rails.root)
  return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
  return nil
end

def rails_xss_safe?
  false
end

def ruby1_8?
  Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
end

def scope(file)
  File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
end

def silence_warnings
  the_real_stderr, $stderr = $stderr, StringIO.new
  yield
ensure
  $stderr = the_real_stderr
end

def static_method_name(name, *vars)
  "#{name}_#{vars.map {|v| !!v}.join('_')}"
end

def to_hash(arr)
  arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
end