middleman 0.12.0.pre → 0.12.0.pre2

data/lib/middleman/vendor/gems/gems/haml-2.2.14/Rakefile

@@ -1,379 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-# ----- Benchmarking -----
-
-desc <<END
-Benchmark haml against ERb.
-  TIMES=n sets the number of runs. Defaults to 1000.
-END
-task :benchmark do
-  sh "ruby test/benchmark.rb #{ENV['TIMES']}"
-end
-
-# ----- Default: Testing ------
-
-if ENV["RUN_CODE_RUN"] == "true"
-  task :default => :"test:rails_compatibility"
-else
-  task :default => :test
-end
-
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  test_files = FileList['test/**/*_test.rb']
-  test_files.exclude('test/rails/*')
-  test_files.exclude('test/plugins/*')
-  test_files.exclude('test/haml/spec/*')
-  t.test_files = test_files
-  t.verbose = true
-end
-Rake::Task[:test].send(:add_comment, <<END)
-To run with an alternate version of Rails, make test/rails a symlink to that version.
-END
-
-# ----- Packaging -----
-
-require 'rake/gempackagetask'
-load    'haml.gemspec'
-
-Rake::GemPackageTask.new(HAML_GEMSPEC) do |pkg|
-  if Rake.application.top_level_tasks.include?('release')
-    pkg.need_tar_gz  = true
-    pkg.need_tar_bz2 = true
-    pkg.need_zip     = true
-  end
-end
-
-task :revision_file do
-  require 'lib/haml'
-
-  release = Rake.application.top_level_tasks.include?('release') || File.exist?('EDGE_GEM_VERSION')
-  if Haml.version[:rev] && !release
-    File.open('REVISION', 'w') { |f| f.puts Haml.version[:rev] }
-  elsif release
-    File.open('REVISION', 'w') { |f| f.puts "(release)" }
-  else
-    File.open('REVISION', 'w') { |f| f.puts "(unknown)" }
-  end
-end
-Rake::Task[:package].prerequisites.insert(0, :revision_file)
-
-# We also need to get rid of this file after packaging.
-at_exit { File.delete('REVISION') rescue nil }
-
-desc "Install Haml as a gem."
-task :install => [:package] do
-  sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
-  gem  = RUBY_PLATFORM =~ /java/  ? 'jgem' : 'gem' 
-  sh %{#{sudo} #{gem} install --no-ri pkg/haml-#{File.read('VERSION').strip}}
-end
-
-desc "Release a new Haml package to Rubyforge."
-task :release => [:check_release, :release_elpa, :package] do
-  name = File.read("VERSION_NAME").strip
-  version = File.read("VERSION").strip
-  sh %{rubyforge login}
-  sh %{rubyforge add_release haml haml "#{name} (v#{version})" pkg/haml-#{version}.gem}
-  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.gz}
-  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.bz2}
-  sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.zip}
-  sh %{gem push pkg/haml-#{version}.gem}
-end
-
-# Releases haml-mode.el and sass-mode.el to ELPA.
-task :release_elpa do
-  require 'tlsmail'
-  require 'time'
-
-  version = File.read("VERSION").strip
-
-  haml_unchanged = mode_unchanged?(:haml, version)
-  sass_unchanged = mode_unchanged?(:sass, version)
-  next if haml_unchanged && sass_unchanged
-  raise "haml-mode.el and sass-mode.el are out of sync." if haml_unchanged ^ sass_unchanged
-
-  if sass_unchanged && File.read("extra/sass-mode.el").
-      include?(";; Package-Requires: ((haml-mode #{sass_unchanged.inspect}))")
-    raise "sass-mode.el doesn't require the same version of haml-mode."
-  end
-
-  rev = File.read('.git/HEAD').strip
-  if rev =~ /^ref: (.*)$/
-    rev = File.read(".git/#{$1}").strip
-  end
-
-  from = `git config user.email`.strip
-  raise "Don't know how to send emails except via Gmail" unless from =~ /@gmail.com$/
-
-  to = "elpa@tromey.com"
-  Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
-  Net::SMTP.start('smtp.gmail.com', 587, 'gmail.com', from, read_password("GMail Password"), :login) do |smtp|
-    smtp.send_message(<<CONTENT, from, to)
-From: Nathan Weizenbaum <#{from}>
-To: #{to}
-Subject: Submitting haml-mode and sass-mode #{version}
-Date: #{Time.now.rfc2822}
-
-haml-mode and sass-mode #{version} are packaged and ready to be included in ELPA.
-They can be downloaded from:
-
-  http://github.com/nex3/haml/raw/#{rev}/extra/haml-mode.el
-  http://github.com/nex3/haml/raw/#{rev}/extra/sass-mode.el
-CONTENT
-  end
-end
-
-# Ensures that the version have been updated for a new release.
-task :check_release do
-  version = File.read("VERSION").strip
-  raise "There have been changes since current version (#{version})" if changed_since?(version)
-  raise "VERSION_NAME must not be 'Bleeding Edge'" if File.read("VERSION_NAME") == "Bleeding Edge"
-end
-
-# Reads a password from the command line.
-#
-# @param name [String] The prompt to use to read the password
-def read_password(prompt)
-  require 'readline'
-  system "stty -echo"
-  Readline.readline("#{prompt}: ").strip
-ensure
-  system "stty echo"
-  puts
-end
-
-# Returns whether or not the repository, or specific files,
-# has/have changed since a given revision.
-#
-# @param rev [String] The revision to check against
-# @param files [Array<String>] The files to check.
-#   If this is empty, checks the entire repository
-def changed_since?(rev, *files)
-  IO.popen("git diff --exit-code #{rev} #{files.join(' ')}") {}
-  return !$?.success?
-end
-
-# Returns whether or not the given Emacs mode file (haml or sass)
-# has changed since the given version.
-#
-# @param mode [String, Symbol] The name of the mode
-# @param version [String] The version number
-# @return [String, nil] The version number if the version has changed
-def mode_unchanged?(mode, version)
-  mode_version = File.read("extra/#{mode}-mode.el").scan(/^;; Version: (.*)$/).first.first
-  return false if mode_version == version
-  return mode_version unless changed_since?(mode_version, "extra/#{mode}-mode.el")
-  raise "#{mode}-mode.el version is #{version.inspect}, but it has changed as of #{version.inspect}"
-  return false
-end
-
-task :release_edge do
-  ensure_git_cleanup do
-    puts "#{'=' * 50} Running rake release_edge"
-
-    sh %{git checkout edge-gem}
-    sh %{git reset --hard origin/edge-gem}
-    sh %{git merge origin/master}
-
-    # Get the current master branch version
-    version = File.read('VERSION').strip.split('.').map {|n| n.to_i}
-    unless version[1] % 2 == 1 && version[2] == 0
-      raise "#{version.join('.')} is not a development version" 
-    end
-
-    # Bump the edge gem version
-    edge_version = File.read('EDGE_GEM_VERSION').strip.split('.').map {|n| n.to_i}
-    if edge_version[0..1] != version[0..1]
-      # A new master branch version was released, reset the edge gem version
-      edge_version[0..1] = version[0..1]
-      edge_version[2] = 0
-    else
-      # Just bump the teeny version
-      edge_version[2] += 1
-    end
-    edge_version = edge_version.join('.')
-    File.open('EDGE_GEM_VERSION', 'w') {|f| f.puts(edge_version)}
-    sh %{git commit -m "Bump edge gem version to #{edge_version}." EDGE_GEM_VERSION}
-    sh %{git push origin edge-gem}
-
-    # Package the edge gem with the proper version
-    File.open('VERSION', 'w') {|f| f.puts(edge_version)}
-    sh %{rake package}
-    sh %{git checkout VERSION}
-
-    sh %{rubyforge login}
-    sh %{rubyforge add_release haml haml-edge "Bleeding Edge (v#{edge_version})" pkg/haml-edge-#{edge_version}.gem}
-  end
-end
-
-task :watch_for_update do
-  sh %{ruby extra/update_watch.rb}
-end
-
-# ----- Documentation -----
-
-task :rdoc do
-  puts '=' * 100, <<END, '=' * 100
-Haml uses the YARD documentation system (http://github.com/lsegal/yard).
-Install the yard gem and then run "rake doc".
-END
-end
-
-begin
-  require 'yard'
-
-  YARD::Rake::YardocTask.new do |t|
-    t.files = FileList.new('lib/**/*.rb') do |list|
-      list.exclude('lib/haml/template/*.rb')
-      list.exclude('lib/haml/helpers/action_view_mods.rb')
-    end.to_a
-    t.options << '--use-cache' if Rake.application.top_level_tasks.include?('redoc')
-    t.options += FileList.new('yard/*.rb').to_a.map {|f| ['-e', f]}.flatten
-    files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
-    t.options << '--files' << files.join(',')
-  end
-  Rake::Task['yardoc'].instance_variable_set('@comment', nil)
-
-  desc "Generate Documentation"
-  task :doc => :yardoc
-  task :redoc => :yardoc
-rescue LoadError
-  desc "Generate Documentation"
-  task :doc => :rdoc
-  task :yardoc => :rdoc
-end
-
-task :pages do
-  ensure_git_cleanup do
-    puts "#{'=' * 50} Running rake pages PROJ=#{ENV["PROJ"].inspect}"
-    raise 'No ENV["PROJ"]!' unless proj = ENV["PROJ"]
-    sh %{git checkout #{proj}-pages}
-    sh %{git reset --hard origin/#{proj}-pages}
-
-    sh %{rake build --trace}
-    sh %{rsync -av --delete site/ /var/www/#{proj}-pages}
-  end
-end
-
-# ----- Coverage -----
-
-begin
-  require 'rcov/rcovtask'
-
-  Rcov::RcovTask.new do |t|
-    t.test_files = FileList['test/**/*_test.rb']
-    t.rcov_opts << '-x' << '"^\/"'
-    if ENV['NON_NATIVE']
-      t.rcov_opts << "--no-rcovrt"
-    end
-    t.verbose = true
-  end
-rescue LoadError; end
-
-# ----- Profiling -----
-
-begin
-  require 'ruby-prof'
-
-  desc <<END
-Run a profile of haml.
-  ENGINE=str sets the engine to be profiled. Defaults to Haml.
-  TIMES=n sets the number of runs. Defaults to 1000.
-  FILE=str sets the file to profile.
-    Defaults to 'standard' for Haml and 'complex' for Sass.
-  OUTPUT=str sets the ruby-prof output format.
-    Can be Flat, CallInfo, or Graph. Defaults to Flat. Defaults to Flat.
-END
-  task :profile do
-    engine = (ENV['ENGINE'] || 'haml').downcase
-    times  = (ENV['TIMES'] || '1000').to_i
-    file   = ENV['FILE']
-
-    if engine == 'sass'
-      require 'lib/sass'
-
-      file = File.read("#{File.dirname(__FILE__)}/test/sass/templates/#{file || 'complex'}.sass")
-      result = RubyProf.profile { times.times { Sass::Engine.new(file).render } }
-    else
-      require 'lib/haml'
-
-      file = File.read("#{File.dirname(__FILE__)}/test/haml/templates/#{file || 'standard'}.haml")
-      obj = Object.new
-      Haml::Engine.new(file).def_method(obj, :render)
-      result = RubyProf.profile { times.times { obj.render } }
-    end
-
-    RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
-  end
-rescue LoadError; end
-
-# ----- Testing Multiple Rails Versions -----
-
-rails_versions = [
-  "v2.3.4",
-  "v2.2.2",
-  "v2.1.2",
-]
-rails_versions << "v2.0.5" if RUBY_VERSION =~ /^1\.8/
-
-namespace :test do
-  desc "Test all supported versions of rails. This takes a while."
-  task :rails_compatibility do
-    `rm -rf test/rails`
-    puts "Checking out rails. Please wait."
-    `git clone git://github.com/rails/rails.git test/rails` rescue nil
-    begin
-      rails_versions.each do |version|
-        Dir.chdir "test/rails" do
-          `git checkout #{version}`
-        end
-        puts "Testing Rails #{version}"
-        Rake::Task['test'].reenable
-        Rake::Task['test'].execute
-      end
-    ensure
-      `rm -rf test/rails`
-    end
-  end
-end
-
-# ----- Handling Updates -----
-
-def ensure_git_cleanup
-  yield
-ensure
-  sh %{git reset --hard HEAD}
-  sh %{git clean -xdf}
-  sh %{git checkout master}
-end
-
-task :handle_update do
-  unless ENV["REF"] =~ %r{^refs/heads/(master|(?:haml|sass)-pages)$}
-    puts "#{'=' * 20} Ignoring rake handle_update REF=#{ENV["REF"].inspect}"
-    next
-  end
-  branch = $1
-
-  puts
-  puts
-  puts '=' * 150
-  puts "Running rake handle_update REF=#{ENV["REF"].inspect}"
-
-  sh %{git checkout master}
-  sh %{git fetch origin}
-  sh %{git reset --hard origin/master}
-
-  if branch == "master"
-    sh %{rake release_edge --trace}
-    sh %{rake pages --trace PROJ=haml}
-    sh %{rake pages --trace PROJ=sass}
-  elsif branch =~ /^(haml|sass)-pages$/
-    sh %{rake pages --trace PROJ=#{$1}}
-  end
-
-  puts 'Done running handle_update'
-  puts '=' * 150
-end

data/lib/middleman/vendor/gems/gems/haml-2.2.14/VERSION

@@ -1 +0,0 @@
-2.2.14

data/lib/middleman/vendor/gems/gems/haml-2.2.14/lib/haml/helpers.rb

@@ -1,563 +0,0 @@
-if defined?(ActionView)
-  require 'haml/helpers/action_view_mods'
-  require 'haml/helpers/action_view_extensions'
-end
-
-module Haml
-  # This module contains various helpful methods to make it easier to do various tasks.
-  # {Haml::Helpers} is automatically included in the context
-  # that a Haml template is parsed in, so all these methods are at your
-  # disposal from within the template.
-  module Helpers
-    # An object that raises an error when \{#to\_s} is called.
-    # It's used to raise an error when the return value of a helper is used
-    # when it shouldn't be.
-    class ErrorReturn
-      # @param message [String] The error message to raise when \{#to\_s} is called
-      def initialize(method)
-        @message = <<MESSAGE
-#{method} outputs directly to the Haml template.
-Disregard its return value and use the - operator,
-or use capture_haml to get the value as a String.
-MESSAGE
-      end
-
-      # Raises an error.
-      #
-      # @raise [Haml::Error] The error
-      def to_s
-        raise Haml::Error.new(@message)
-      rescue Haml::Error => e
-        e.backtrace.shift
-
-        # If the ErrorReturn is used directly in the template,
-        # we don't want Haml's stuff to get into the backtrace,
-        # so we get rid of the format_script line.
-        #
-        # We also have to subtract one from the Haml line number
-        # since the value is passed to format_script the line after
-        # it's actually used.
-        if e.backtrace.first =~ /^\(eval\):\d+:in `format_script/
-          e.backtrace.shift
-          e.backtrace.first.gsub!(/^\(haml\):(\d+)/) {|s| "(haml):#{$1.to_i - 1}"}
-        end
-        raise e
-      end
-
-      # @return [String] A human-readable string representation
-      def inspect
-        "Haml::Helpers::ErrorReturn(#{@message.inspect})"
-      end
-    end
-
-    self.extend self
-
-    @@action_view_defined = defined?(ActionView)
-    @@force_no_action_view = false
-
-    # @return [Boolean] Whether or not ActionView is loaded
-    def self.action_view?
-      @@action_view_defined
-    end
-
-    # Note: this does **not** need to be called when using Haml helpers
-    # normally in Rails.
-    #
-    # Initializes the current object as though it were in the same context
-    # as a normal ActionView instance using Haml.
-    # This is useful if you want to use the helpers in a context
-    # other than the normal setup with ActionView.
-    # For example:
-    #
-    #     context = Object.new
-    #     class << context
-    #       include Haml::Helpers
-    #     end
-    #     context.init_haml_helpers
-    #     context.haml_tag :p, "Stuff"
-    #
-    def init_haml_helpers
-      @haml_buffer = Haml::Buffer.new(@haml_buffer, Haml::Engine.new('').send(:options_for_buffer))
-      nil
-    end
-
-    # Runs a block of code in a non-Haml context
-    # (i.e. \{#is\_haml?} will return false).
-    #
-    # This is mainly useful for rendering sub-templates such as partials in a non-Haml language,
-    # particularly where helpers may behave differently when run from Haml.
-    #
-    # Note that this is automatically applied to Rails partials.
-    #
-    # @yield A block which won't register as Haml
-    def non_haml
-      was_active = @haml_buffer.active?
-      @haml_buffer.active = false
-      yield
-    ensure
-      @haml_buffer.active = was_active
-    end
-
-    # Uses \{#preserve} to convert any newlines inside whitespace-sensitive tags
-    # into the HTML entities for endlines.
-    #
-    # @param tags [Array<String>] Tags that should have newlines escaped
-    #
-    # @overload find_and_preserve(input, tags = haml_buffer.options[:preserve])
-    #   Escapes newlines within a string.
-    #
-    #   @param input [String] The string within which to escape newlines
-    # @overload find_and_preserve(tags = haml_buffer.options[:preserve])
-    #   Escapes newlines within a block of Haml code.
-    #
-    #   @yield The block within which to escape newlines
-    def find_and_preserve(input = nil, tags = haml_buffer.options[:preserve], &block)
-      return find_and_preserve(capture_haml(&block), input || tags) if block
-      input.to_s.gsub(/<(#{tags.map(&Regexp.method(:escape)).join('|')})([^>]*)>(.*?)(<\/\1>)/im) do
-        "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
-      end
-    end
-
-    # Takes any string, finds all the newlines, and converts them to
-    # HTML entities so they'll render correctly in
-    # whitespace-sensitive tags without screwing up the indentation.
-    #
-    # @overload perserve(input)
-    #   Escapes newlines within a string.
-    #
-    #   @param input [String] The string within which to escape all newlines
-    # @overload perserve
-    #   Escapes newlines within a block of Haml code.
-    #
-    #   @yield The block within which to escape newlines
-    def preserve(input = nil, &block)
-      return preserve(capture_haml(&block)) if block
-      input.to_s.chomp("\n").gsub(/\n/, '&#x000A;').gsub(/\r/, '')
-    end
-    alias_method :flatten, :preserve
-
-    # Takes an `Enumerable` object and a block
-    # and iterates over the enum,
-    # yielding each element to a Haml block
-    # and putting the result into `<li>` elements.
-    # This creates a list of the results of the block.
-    # For example:
-    #
-    #     = list_of([['hello'], ['yall']]) do |i|
-    #       = i[0]
-    #
-    # Produces:
-    #
-    #     <li>hello</li>
-    #     <li>yall</li>
-    #
-    # And
-    #
-    #     = list_of({:title => 'All the stuff', :description => 'A book about all the stuff.'}) do |key, val|
-    #       %h3= key.humanize
-    #       %p= val
-    #
-    # Produces:
-    #
-    #     <li>
-    #       <h3>Title</h3>
-    #       <p>All the stuff</p>
-    #     </li>
-    #     <li>
-    #       <h3>Description</h3>
-    #       <p>A book about all the stuff.</p>
-    #     </li>
-    #
-    # @param enum [Enumerable] The list of objects to iterate over
-    # @yield [item] A block which contains Haml code that goes within list items
-    # @yieldparam item An element of `enum`
-    def list_of(enum, &block)
-      to_return = enum.collect do |i|
-        result = capture_haml(i, &block)
-
-        if result.count("\n") > 1
-          result.gsub!("\n", "\n  ")
-          result = "\n  #{result.strip}\n"
-        else
-          result.strip!
-        end
-
-        "<li>#{result}</li>"
-      end
-      to_return.join("\n")
-    end
-
-    # Returns a hash containing default assignments for the `xmlns`, `lang`, and `xml:lang`
-    # attributes of the `html` HTML element.
-    # For example,
-    #
-    #     %html{html_attrs}
-    #
-    # becomes
-    #
-    #     <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
-    #
-    # @param lang [String] The value of `xml:lang` and `lang`
-    # @return [Hash<#to_s, String>] The attribute hash
-    def html_attrs(lang = 'en-US')
-      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
-    end
-
-    # Increments the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    # For example:
-    #
-    #     %h1 foo
-    #     - tab_up
-    #     %p bar
-    #     - tab_down
-    #     %strong baz
-    #
-    # Produces:
-    #
-    #     <h1>foo</h1>
-    #       <p>bar</p>
-    #     <strong>baz</strong>
-    #
-    # @param i [Fixnum] The number of tabs by which to increase the indentation
-    # @see #tab_down
-    def tab_up(i = 1)
-      haml_buffer.tabulation += i
-    end
-
-    # Decrements the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    #
-    # @param i [Fixnum] The number of tabs by which to decrease the indentation
-    # @see #tab_up
-    def tab_down(i = 1)
-      haml_buffer.tabulation -= i
-    end
-
-    # Surrounds a block of Haml code with strings,
-    # with no whitespace in between.
-    # For example:
-    #
-    #     = surround '(', ')' do
-    #       %a{:href => "food"} chicken
-    #
-    # Produces:
-    #
-    #     (<a href='food'>chicken</a>)
-    #
-    # and
-    #
-    #     = surround '*' do
-    #       %strong angry
-    #
-    # Produces:
-    #
-    #     *<strong>angry</strong>*
-    #
-    # @param front [String] The string to add before the Haml
-    # @param back [String] The string to add after the Haml
-    # @yield A block of Haml to surround
-    def surround(front, back = front, &block)
-      output = capture_haml(&block)
-
-      "#{front}#{output.chomp}#{back}\n"
-    end
-
-    # Prepends a string to the beginning of a Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #     = precede '*' do
-    #       %span.small Not really
-    #
-    # Produces:
-    #
-    #     *<span class='small'>Not really</span>
-    #
-    # @param str [String] The string to add before the Haml
-    # @yield A block of Haml to prepend to
-    def precede(str, &block)
-      "#{str}#{capture_haml(&block).chomp}\n"
-    end
-
-    # Appends a string to the end of a Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #     click
-    #     = succeed '.' do
-    #       %a{:href=>"thing"} here
-    #
-    # Produces:
-    #
-    #     click
-    #     <a href='thing'>here</a>.
-    #
-    # @param str [String] The string to add after the Haml
-    # @yield A block of Haml to append to
-    def succeed(str, &block)
-      "#{capture_haml(&block).chomp}#{str}\n"
-    end
-
-    # Captures the result of a block of Haml code,
-    # gets rid of the excess indentation,
-    # and returns it as a string.
-    # For example, after the following,
-    #
-    #     .foo
-    #       - foo = capture_haml(13) do |a|
-    #         %p= a
-    #
-    # the local variable `foo` would be assigned to `"<p>13</p>\n"`.
-    #
-    # @param args [Array] Arguments to pass into the block
-    # @yield [args] A block of Haml code that will be converted to a string
-    # @yieldparam args [Array] `args`
-    def capture_haml(*args, &block)
-      buffer = eval('_hamlout', block.binding) rescue haml_buffer
-      with_haml_buffer(buffer) do
-        position = haml_buffer.buffer.length
-
-        haml_buffer.capture_position = position
-        block.call(*args)
-
-        captured = haml_buffer.buffer.slice!(position..-1).split(/^/)
-
-        min_tabs = nil
-        captured.each do |line|
-          tabs = line.index(/[^ ]/) || line.length
-          min_tabs ||= tabs
-          min_tabs = min_tabs > tabs ? tabs : min_tabs
-        end
-
-        captured.map do |line|
-          line[min_tabs..-1]
-        end.join
-      end
-    ensure
-      haml_buffer.capture_position = nil
-    end
-
-    # @deprecated This will be removed in version 2.4.
-    # @see \{#haml\_concat}
-    def puts(*args)
-      warn <<END
-DEPRECATION WARNING:
-The Haml #puts helper is deprecated and will be removed in version 2.4.
-Use the #haml_concat helper instead.
-END
-      haml_concat(*args)
-    end
-
-    # Outputs text directly to the Haml buffer, with the proper indentation.
-    #
-    # @param text [#to_s] The text to output
-    def haml_concat(text = "")
-      haml_buffer.buffer << haml_indent << text.to_s << "\n"
-      ErrorReturn.new("haml_concat")
-    end
-
-    # @return [String] The indentation string for the current line
-    def haml_indent
-      '  ' * haml_buffer.tabulation
-    end
-
-    # Creates an HTML tag with the given name and optionally text and attributes.
-    # Can take a block that will run between the opening and closing tags.
-    # If the block is a Haml block or outputs text using \{#haml\_concat},
-    # the text will be properly indented.
-    #
-    # `flags` is a list of symbol flags
-    # like those that can be put at the end of a Haml tag
-    # (`:/`, `:<`, and `:>`).
-    # Currently, only `:/` and `:<` are supported.
-    #
-    # `haml_tag` outputs directly to the buffer;
-    # its return value should not be used.
-    # If you need to get the results as a string,
-    # use \{#capture\_haml\}.
-    #
-    # For example,
-    #
-    #     haml_tag :table do
-    #       haml_tag :tr do
-    #         haml_tag :td, {:class => 'cell'} do
-    #           haml_tag :strong, "strong!"
-    #           haml_concat "data"
-    #         end
-    #         haml_tag :td do
-    #           haml_concat "more_data"
-    #         end
-    #       end
-    #     end
-    #
-    # outputs
-    #
-    #     <table>
-    #       <tr>
-    #         <td class='cell'>
-    #           <strong>
-    #             strong!
-    #           </strong>
-    #           data
-    #         </td>
-    #         <td>
-    #           more_data
-    #         </td>
-    #       </tr>
-    #     </table>
-    #
-    # @param name [#to_s] The name of the tag
-    # @param flags [Array<Symbol>] Haml end-of-tag flags
-    #
-    # @overload haml_tag(name, *flags, attributes = {})
-    #   @yield The block of Haml code within the tag
-    # @overload haml_tag(name, text, *flags, attributes = {})
-    #   @param text [#to_s] The text within the tag
-    def haml_tag(name, *rest, &block)
-      ret = ErrorReturn.new("haml_tag")
-
-      name = name.to_s
-      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
-      attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
-                                                      haml_buffer.options[:attr_wrapper],
-                                                      rest.shift || {})
-
-      if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
-        haml_concat "<#{name}#{attributes} />"
-        return ret
-      end
-
-      if flags.include?(:/)
-        raise Error.new("Self-closing tags can't have content.") if text
-        raise Error.new("Illegal nesting: nesting within a self-closing tag is illegal.") if block
-      end
-
-      tag = "<#{name}#{attributes}>"
-      if block.nil?
-        tag << text.to_s << "</#{name}>"
-        haml_concat tag
-        return ret
-      end
-
-      if text
-        raise Error.new("Illegal nesting: content can't be both given to haml_tag :#{name} and nested within it.")
-      end
-
-      if flags.include?(:<)
-        tag << capture_haml(&block).strip << "</#{name}>"
-        haml_concat tag
-        return ret
-      end
-
-      haml_concat tag
-      tab_up
-      block.call
-      tab_down
-      haml_concat "</#{name}>"
-
-      ret
-    end
-
-    # Characters that need to be escaped to HTML entities from user input
-    HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
-
-    # Returns a copy of `text` with ampersands, angle brackets and quotes
-    # escaped into HTML entities.
-    #
-    # Note that if ActionView is loaded and XSS protection is enabled
-    # (as is the default for Rails 3.0+, and optional for version 2.3.5+),
-    # this won't escape text declared as "safe".
-    #
-    # @param text [String] The string to sanitize
-    # @return [String] The sanitized string
-    def html_escape(text)
-      text.to_s.gsub(/[\"><&]/n) {|s| HTML_ESCAPE[s]}
-    end
-
-    # Escapes HTML entities in `text`, but without escaping an ampersand
-    # that is already part of an escaped entity.
-    #
-    # @param text [String] The string to sanitize
-    # @return [String] The sanitized string
-    def escape_once(text)
-      Haml::Util.silence_warnings do
-        text.to_s.gsub(/[\"><]|&(?!(?:[a-zA-Z]+|(#\d+));)/n) {|s| HTML_ESCAPE[s]}
-      end
-    end
-
-    # Returns whether or not the current template is a Haml template.
-    #
-    # This function, unlike other {Haml::Helpers} functions,
-    # also works in other `ActionView` templates,
-    # where it will always return false.
-    #
-    # @return [Boolean] Whether or not the current template is a Haml template
-    def is_haml?
-      !@haml_buffer.nil? && @haml_buffer.active?
-    end
-
-    # Returns whether or not `block` is defined directly in a Haml template.
-    #
-    # @param block [Proc] A Ruby block
-    # @return [Boolean] Whether or not `block` is defined directly in a Haml template
-    def block_is_haml?(block)
-      eval('_hamlout', block.binding)
-      true
-    rescue
-      false
-    end
-
-    private
-
-    # Runs a block of code with the given buffer as the currently active buffer.
-    #
-    # @param buffer [Haml::Buffer] The Haml buffer to use temporarily
-    # @yield A block in which the given buffer should be used
-    def with_haml_buffer(buffer)
-      @haml_buffer, old_buffer = buffer, @haml_buffer
-      old_buffer.active, was_active = false, old_buffer.active? if old_buffer
-      @haml_buffer.active = true
-      yield
-    ensure
-      @haml_buffer.active = false
-      old_buffer.active = was_active if old_buffer
-      @haml_buffer = old_buffer
-    end
-
-    # The current {Haml::Buffer} object.
-    #
-    # @return [Haml::Buffer]
-    def haml_buffer
-      @haml_buffer
-    end
-
-    # Gives a proc the same local `_hamlout` and `_erbout` variables
-    # that the current template has.
-    #
-    # @param proc [#call] The proc to bind
-    # @return [Proc] A new proc with the new variables bound
-    def haml_bind_proc(&proc)
-      _hamlout = haml_buffer
-      _erbout = _hamlout.buffer
-      proc { |*args| proc.call(*args) }
-    end
-
-    include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
-  end
-end
-
-class Object
-  # Haml overrides various `ActionView` helpers,
-  # which call an \{#is\_haml?} method
-  # to determine whether or not the current context object
-  # is a proper Haml context.
-  # Because `ActionView` helpers may be included in non-`ActionView::Base` classes,
-  # it's a good idea to define \{#is\_haml?} for all objects.
-  def is_haml?
-    false
-  end
-end
-