drnic-haml 2.3.0

data/lib/haml/filters.rb

@@ -0,0 +1,341 @@
+module Haml
+  # The module containing the default Haml filters,
+  # as well as the base module, {Haml::Filters::Base}.
+  #
+  # @see Haml::Filters::Base
+  module Filters
+    # @return [Hash<String, Haml::Filters::Base>] a hash of filter names to classes
+    def self.defined
+      @defined ||= {}
+    end
+
+    # The base module for Haml filters.
+    # User-defined filters should be modules including this module.
+    # The name of the filter is taken by downcasing the module name.
+    # For instance, if the module is named `FooBar`, the filter will be `:foobar`.
+    #
+    # A user-defined filter should override either \{#render} or {\#compile}.
+    # \{#render} is the most common.
+    # It takes a string, the filter source,
+    # and returns another string, the result of the filter.
+    # For example, the following will define a filter named `:sass`:
+    #
+    #     module Haml::Filters::Sass
+    #       include Haml::Filters::Base
+    #
+    #       def render(text)
+    #         ::Sass::Engine.new(text).render
+    #       end
+    #     end
+    #
+    # For details on overriding \{#compile}, see its documentation.
+    #
+    # Note that filters overriding \{#render} automatically support `#{}`
+    # for interpolating Ruby code.
+    # Those overriding \{#compile} will need to add such support manually
+    # if it's desired.
+    module Base
+      # This method is automatically called when {Base} is included in a module.
+      # It automatically defines a filter
+      # with the downcased name of that module.
+      # For example, if the module is named `FooBar`, the filter will be `:foobar`.
+      #
+      # @param base [Module, Class] The module that this is included in
+      def self.included(base)
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
+      end
+
+      # Takes the source text that should be passed to the filter
+      # and returns the result of running the filter on that string.
+      #
+      # This should be overridden in most individual filter modules
+      # to render text with the given filter.
+      # If \{#compile} is overridden, however, \{#render} doesn't need to be.
+      #
+      # @param text [String] The source text for the filter to process
+      # @return [String] The filtered result
+      # @raise [Haml::Error] if it's not overridden
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
+      end
+
+      # Same as \{#render}, but takes a {Haml::Engine} options hash as well.
+      # It's only safe to rely on options made available in {Haml::Engine#options\_for\_buffer}.
+      #
+      # @see #render
+      # @param text [String] The source text for the filter to process
+      # @return [String] The filtered result
+      # @raise [Haml::Error] if it or \{#render} isn't overridden
+      def render_with_options(text, options)
+        render(text)
+      end
+
+      # Same as \{#compile}, but requires the necessary files first.
+      # *This is used by {Haml::Engine} and is not intended to be overridden or used elsewhere.*
+      #
+      # @see #compile
+      def internal_compile(*args)
+        resolve_lazy_requires
+        compile(*args)
+      end
+
+      # This should be overridden when a filter needs to have access to the Haml evaluation context.
+      # Rather than applying a filter to a string at compile-time,
+      # \{#compile} uses the {Haml::Precompiler} instance to compile the string to Ruby code
+      # that will be executed in the context of the active Haml template.
+      #
+      # Warning: the {Haml::Precompiler} interface is neither well-documented
+      # nor guaranteed to be stable.
+      # If you want to make use of it, you'll probably need to look at the source code
+      # and should test your filter when upgrading to new Haml versions.
+      #
+      # @param precompiler [Haml::Precompiler] The precompiler instance
+      # @param text [String] The text of the filter
+      # @raise [Haml::Error] if none of \{#compile}, \{#render}, and \{#render_with_options} are overridden
+      def compile(precompiler, text)
+        resolve_lazy_requires
+        filter = self
+        precompiler.instance_eval do
+          if contains_interpolation?(text)
+            return if options[:suppress_eval]
+
+            push_script <<RUBY, :escape_html => false
+find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
+RUBY
+            return
+          end
+
+          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, precompiler.options), precompiler.options[:preserve])
+
+          if !options[:ugly]
+            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
+          else
+            push_text(rendered.rstrip)
+          end
+        end
+      end
+
+      # This becomes a class method of modules that include {Base}.
+      # It allows the module to specify one or more Ruby files
+      # that Haml should try to require when compiling the filter.
+      #
+      # The first file specified is tried first, then the second, etc.
+      # If none are found, the compilation throws an exception.
+      #
+      # For example:
+      #
+      #     module Haml::Filters::Markdown
+      #       lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+      #
+      #       ...
+      #     end
+      #
+      # @param reqs [Array<String>] The requires to run
+      def lazy_require(*reqs)
+        @lazy_requires = reqs
+      end
+
+      private
+
+      def resolve_lazy_requires
+        return unless @lazy_requires
+
+        @lazy_requires[0...-1].each do |req|
+          begin
+            @required = req
+            require @required
+            return
+          rescue LoadError; end # RCov doesn't see this, but it is run
+        end
+
+        begin
+          @required = @lazy_requires[-1]
+          require @required
+        rescue LoadError => e
+          classname = self.name.match(/\w+$/)[0]
+
+          if @lazy_requires.size == 1
+            raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
+          else
+            raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
+          end
+        end
+      end
+    end
+  end
+end
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+module Haml
+  module Filters
+    # Does not parse the filtered text.
+    # This is useful for large blocks of text without HTML tags,
+    # when you don't want lines starting with `.` or `-`
+    # to be parsed.
+    module Plain
+      include Base
+
+      # @see Base#render
+      def render(text); text; end
+    end
+
+    # Surrounds the filtered text with `<script>` and CDATA tags.
+    # Useful for including inline Javascript.
+    module Javascript
+      include Base
+
+      # @see Base#render_with_options
+      def render_with_options(text, options)
+        <<END
+<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>
+  //<![CDATA[
+    #{text.rstrip.gsub("\n", "\n    ")}
+  //]]>
+</script>
+END
+      end
+    end
+
+    # Surrounds the filtered text with CDATA tags.
+    module Cdata
+      include Base
+
+      # @see Base#render
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    # Works the same as {Plain}, but HTML-escapes the text
+    # before placing it in the document.
+    module Escaped
+      include Base
+
+      # @see Base#render
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
+    # Parses the filtered text with the normal Ruby interpreter.
+    # All output sent to `$stdout`, such as with `puts`,
+    # is output into the Haml document.
+    # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
+    # The Ruby code is evaluated in the same context as the Haml template.
+    module Ruby
+      include Base
+      lazy_require 'stringio'
+
+      # @see Base#compile
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        precompiler.instance_eval do
+          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
+            _haml_old_stdout = $stdout
+            $stdout = StringIO.new(_hamlout.buffer, 'a')
+          FIRST
+            _haml_old_stdout, $stdout = $stdout, _haml_old_stdout
+            _haml_old_stdout.close
+          LAST
+        end
+      end
+    end
+
+    # Inserts the filtered text into the template with whitespace preserved.
+    # `preserve`d blocks of text aren't indented,
+    # and newlines are replaced with the HTML escape code for newlines,
+    # to preserve nice-looking output.
+    #
+    # @see Haml::Helpers#preserve
+    module Preserve
+      include Base
+
+      # @see Base#render
+      def render(text)
+        Haml::Helpers.preserve text
+      end
+    end
+
+    # Parses the filtered text with {Sass} to produce CSS output.
+    module Sass
+      include Base
+      lazy_require 'sass/plugin'
+
+      # @see Base#render
+      def render(text)
+        ::Sass::Engine.new(text, ::Sass::Plugin.engine_options).render
+      end
+    end
+
+    # Parses the filtered text with ERB, like an RHTML template.
+    # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
+    # Embedded Ruby code is evaluated in the same context as the Haml template.
+    module ERB
+      include Base
+      lazy_require 'erb'
+
+      # @see Base#compile
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        src = ::ERB.new(text).src.sub(/^#coding:.*?\n/, '').
+          sub(/^_erbout = '';/, "").gsub("\n", ';')
+        precompiler.send(:push_silent, src)
+      end
+    end
+
+    # Parses the filtered text with [Textile](http://www.textism.com/tools/textile).
+    # Only works if [RedCloth](http://redcloth.org) is installed.
+    module Textile
+      include Base
+      lazy_require 'redcloth'
+
+      # @see Base#render
+      def render(text)
+        ::RedCloth.new(text).to_html(:textile)
+      end
+    end
+    RedCloth = Textile
+    Filters.defined['redcloth'] = RedCloth
+
+    # Parses the filtered text with [Markdown](http://daringfireball.net/projects/markdown).
+    # Only works if [RDiscount](http://github.com/rtomayko/rdiscount),
+    # [RPeg-Markdown](http://github.com/rtomayko/rpeg-markdown),
+    # [Maruku](http://maruku.rubyforge.org),
+    # or [BlueCloth](www.deveiate.org/projects/BlueCloth) are installed.
+    module Markdown
+      include Base
+      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+
+      # @see Base#render
+      def render(text)
+        engine = case @required
+                 when 'rdiscount'
+                   ::RDiscount
+                 when 'peg_markdown'
+                   ::PEGMarkdown
+                 when 'maruku'
+                   ::Maruku
+                 when 'bluecloth'
+                   ::BlueCloth
+                 end
+        engine.new(text).to_html
+      end
+    end
+
+    # Parses the filtered text with [Maruku](http://maruku.rubyforge.org),
+    # which has some non-standard extensions to Markdown.
+    module Maruku
+      include Base
+      lazy_require 'maruku'
+
+      # @see Base#render
+      def render(text)
+        ::Maruku.new(text).to_html
+      end
+    end
+  end
+end

data/lib/haml/helpers.rb

@@ -0,0 +1,560 @@
+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 = input.to_s
+      input.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 = '', &block)
+      return preserve(capture_haml(&block)) if block
+
+      input.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.
+    #
+    # @param text [String] The string to sanitize
+    # @return [String] The sanitized string
+    def html_escape(text)
+      text.to_s.gsub(/[\"><&]/) { |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)
+      text.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |s| HTML_ESCAPE[s] }
+    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
+