module Haml::Util

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 balance(scanner, start, finish, count = 0)
  str = ''
  scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
  regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
  while scanner.scan(regexp)
    str << scanner.matched
    count += 1 if scanner.matched[-1] == start
    count -= 1 if scanner.matched[-1] == finish
    return [str.strip, scanner.rest] if count == 0
  end
end

def caller_info(entry = caller[1])
  info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
  info[1] = info[1].to_i
  # This is added by Rubinius to designate a block, but we don't care about it.
  info[2].sub!(/ \{\}\Z/, '') if info[2]
  info
end

def check_encoding(str)
  str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
end

def check_encoding(str)
  if str.valid_encoding?
    # Get rid of the Unicode BOM if possible
    if str.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?$/
      return str.gsub(Regexp.new("\\A\uFEFF".encode(str.encoding.name)), '')
    else
      return str
    end
  end
  encoding = str.encoding
  newlines = Regexp.new("\r\n|\r|\n".encode(encoding).force_encoding("binary"))
  str.force_encoding("binary").split(newlines).each_with_index do |line, i|
    begin
      line.encode(encoding)
    rescue Encoding::UndefinedConversionError => e
      yield <<MSG.rstrip, i + 1
d #{encoding.name} character #{e.error_char.dump}
    end
  end
  return str
end

def check_haml_encoding(str, &block)
  check_encoding(str, &block)
end

def check_haml_encoding(str, &block)
  str = str.dup if str.frozen?
  bom, encoding = parse_haml_magic_comment(str)
  if encoding; str.force_encoding(encoding)
  elsif bom; str.force_encoding("UTF-8")
  end
  return check_encoding(str, &block)
end

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

def handle_interpolation(str)
  scan = StringScanner.new(str)
  yield scan while scan.scan(/(.*?)(\\*)\#\{/)
  scan.rest
end

def html_safe(text)
  return unless text
  return text.html_safe if defined?(ActiveSupport::SafeBuffer)
  text.html_safe!
end

def human_indentation(indentation, was = false)
  if !indentation.include?(?\t)
    noun = 'space'
  elsif !indentation.include?(?\s)
    noun = 'tab'
  else
    return indentation.inspect + (was ? ' was' : '')
  end
  singular = indentation.length == 1
  if was
    was = singular ? ' was' : ' were'
  else
    was = ''
  end
  "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
end

def inspect_obj(obj)
  return obj.inspect unless (::RUBY_VERSION >= "1.9.2")
  return ':' + inspect_obj(obj.to_s) if obj.is_a?(Symbol)
  return obj.inspect unless obj.is_a?(String)
  '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
end

def parse_haml_magic_comment(str)
  scanner = StringScanner.new(str.dup.force_encoding("BINARY"))
  bom = scanner.scan(/\xEF\xBB\xBF/n)
  return bom unless scanner.scan(/-\s*#\s*/n)
  if coding = try_parse_haml_emacs_magic_comment(scanner)
    return bom, coding
  end
  return bom unless scanner.scan(/.*?coding[=:]\s*([\w-]+)/in)
  return bom, scanner[1]
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_xss_safe?; true; end

def rails_xss_safe?
  false
end

def scope(file)
  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 try_parse_haml_emacs_magic_comment(scanner)
  pos = scanner.pos
  return unless scanner.scan(/.*?-\*-\s*/n)
  # From Ruby's parse.y
  return unless scanner.scan(/([^\s'":;]+)\s*:\s*("(?:\\.|[^"])*"|[^"\s;]+?)[\s;]*-\*-/n)
  name, val = scanner[1], scanner[2]
  return unless name =~ /(en)?coding/in
  val = $1 if val =~ /^"(.*)"$/n
  return val
ensure
  scanner.pos = pos
end