haml 5.2.2 → 6.0.0.beta.1

data/lib/haml/html.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class HTML < Temple::HTML::Fast
+    DEPRECATED_FORMATS = %i[html4 html5].freeze
+
+    def initialize(opts = {})
+      if DEPRECATED_FORMATS.include?(opts[:format])
+        opts = opts.dup
+        opts[:format] = :html
+      end
+      super(opts)
+    end
+
+    # This dispatcher supports Haml's "revealed" conditional comment.
+    def on_html_condcomment(condition, content, revealed = false)
+      on_html_comment [:multi,
+                       [:static, "[#{condition}]>#{'<!-->' if revealed}"],
+                       content,
+                       [:static, "#{'<!--' if revealed}<![endif]"]]
+    end
+  end
+end

data/lib/haml/identity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Haml
+  class Identity
+    def initialize
+      @unique_id = 0
+    end
+
+    def generate
+      @unique_id += 1
+      "_haml_compiler#{@unique_id}"
+    end
+  end
+end

data/lib/haml/object_ref.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Haml
+  module ObjectRef
+    class << self
+      def parse(args)
+        object, prefix = args
+        return {} unless object
+
+        suffix = underscore(object.class)
+        {
+          'class' => [prefix, suffix].compact.join('_'),
+          'id'    => [prefix, suffix, object.id || 'new'].compact.join('_'),
+        }
+      end
+
+      private
+
+      # Haml::Buffer.underscore
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '_')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+    end
+  end
+end

data/lib/haml/parser.rb

@@ -2,6 +2,8 @@
 
 require 'ripper'
 require 'strscan'
+require 'haml/haml_error'
+require 'haml/util'
 
 module Haml
   class Parser
@@ -95,7 +97,7 @@ module Haml
     METHOD_CALL_PREFIX = 'a('
 
     def initialize(options)
-      @options = Options.wrap(options)
+      @options = ParserOptions.new(options)
       # Record the indent levels of "if" statements to validate the subsequent
       # elsif and else statements are indented at the appropriate level.
       @script_level_stack = []
@@ -104,6 +106,10 @@ module Haml
     end
 
     def call(template)
+      template = Haml::Util.check_haml_encoding(template) do |msg, line|
+        raise Haml::Error.new(msg, line)
+      end
+
       match = template.rstrip.scan(/(([ \t]+)?(.*?))(?:\Z|\r\n|\r|\n)/m)
       # discard the last match which is always blank
       match.pop
@@ -119,7 +125,7 @@ module Haml
       @indentation = nil
       @line = next_line
 
-      raise SyntaxError.new(Error.message(:indenting_at_start), @line.index) if @line.tabs != 0
+      raise HamlSyntaxError.new(HamlError.message(:indenting_at_start), @line.index) if @line.tabs != 0
 
       loop do
         next_line
@@ -142,7 +148,7 @@ module Haml
         end
 
         if !flat? && @next_line.tabs - @line.tabs > 1
-          raise SyntaxError.new(Error.message(:deeper_indenting, @next_line.tabs - @line.tabs), @next_line.index)
+          raise HamlSyntaxError.new(HamlError.message(:deeper_indenting, @next_line.tabs - @line.tabs), @next_line.index)
         end
 
         @line = @next_line
@@ -150,9 +156,9 @@ module Haml
       # Close all the open tags
       close until @parent.type == :root
       @root
-    rescue Haml::Error => e
+    rescue Haml::HamlError => e
       e.backtrace.unshift "#{@options.filename}:#{(e.line ? e.line + 1 : @line.index + 1) + @options.line - 1}"
-      raise
+      error_with_lineno(e)
     end
 
     def compute_tabs(line)
@@ -162,7 +168,7 @@ module Haml
         @indentation = line.whitespace
 
         if @indentation.include?(?\s) && @indentation.include?(?\t)
-          raise SyntaxError.new(Error.message(:cant_use_tabs_and_spaces), line.index)
+          raise HamlSyntaxError.new(HamlError.message(:cant_use_tabs_and_spaces), line.index)
         end
 
         @flat_spaces = @indentation * (@template_tabs+1) if flat?
@@ -173,15 +179,25 @@ module Haml
       return tabs if line.whitespace == @indentation * tabs
       return @template_tabs + 1 if flat? && line.whitespace =~ /^#{@flat_spaces}/
 
-      message = Error.message(:inconsistent_indentation,
+      message = HamlError.message(:inconsistent_indentation,
         human_indentation(line.whitespace),
         human_indentation(@indentation)
       )
-      raise SyntaxError.new(message, line.index)
+      raise HamlSyntaxError.new(message, line.index)
     end
 
     private
 
+    def error_with_lineno(error)
+      return error if error.line
+
+      trace = error.backtrace.first
+      return error unless trace
+
+      line = trace.match(/\d+\z/).to_s.to_i
+      HamlSyntaxError.new(error.message, line)
+    end
+
     # @private
     Line = Struct.new(:whitespace, :text, :full, :index, :parser, :eod) do
       alias_method :eod?, :eod
@@ -221,7 +237,7 @@ module Haml
         self[:old] = value
       end
 
-      # This will be a literal for Haml::Buffer#attributes's last argument, `attributes_hashes`.
+      # This will be a literal for Haml::HamlBuffer#attributes's last argument, `attributes_hashes`.
       def to_literal
         [new, stripped_old].compact.join(', ')
       end
@@ -304,20 +320,20 @@ module Haml
 
     def plain(line, escape_html = nil)
       if block_opened?
-        raise SyntaxError.new(Error.message(:illegal_nesting_plain), @next_line.index)
+        raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_plain), @next_line.index)
       end
 
-      unless contains_interpolation?(line.text)
+      unless Util.contains_interpolation?(line.text)
         return ParseNode.new(:plain, line.index + 1, :text => line.text)
       end
 
       escape_html = @options.escape_html && @options.mime_type != 'text/plain' if escape_html.nil?
-      line.text = unescape_interpolation(line.text, escape_html)
-      script(line, false)
+      line.text = Util.unescape_interpolation(line.text)
+      script(line, false).tap { |n| n.value[:escape_interpolation] = true if escape_html }
     end
 
     def script(line, escape_html = nil, preserve = false)
-      raise SyntaxError.new(Error.message(:no_ruby_code, '=')) if line.text.empty?
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, '=')) if line.text.empty?
       line = handle_ruby_multiline(line)
       escape_html = @options.escape_html if escape_html.nil?
 
@@ -329,12 +345,12 @@ module Haml
     end
 
     def flat_script(line, escape_html = nil)
-      raise SyntaxError.new(Error.message(:no_ruby_code, '~')) if line.text.empty?
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, '~')) if line.text.empty?
       script(line, escape_html, :preserve)
     end
 
     def silent_script(line)
-      raise SyntaxError.new(Error.message(:no_end), line.index) if line.text[1..-1].strip == 'end'
+      raise HamlSyntaxError.new(HamlError.message(:no_end), line.index) if line.text[1..-1].strip == 'end'
 
       line = handle_ruby_multiline(line)
       keyword = block_keyword(line.text)
@@ -343,7 +359,7 @@ module Haml
 
       if ["else", "elsif", "when"].include?(keyword)
         if @script_level_stack.empty?
-          raise Haml::SyntaxError.new(Error.message(:missing_if, keyword), @line.index)
+          raise Haml::HamlSyntaxError.new(HamlError.message(:missing_if, keyword), @line.index)
         end
 
         if keyword == 'when' and !@script_level_stack.last[2]
@@ -354,8 +370,8 @@ module Haml
         end
 
         if @script_level_stack.last[1] != @line.tabs
-          message = Error.message(:bad_script_indent, keyword, @script_level_stack.last[1], @line.tabs)
-          raise Haml::SyntaxError.new(message, @line.index)
+          message = HamlError.message(:bad_script_indent, keyword, @script_level_stack.last[1], @line.tabs)
+          raise Haml::HamlSyntaxError.new(message, @line.index)
         end
       end
 
@@ -400,7 +416,8 @@ module Haml
       when '='
         parse = true
         if value[0] == ?=
-          value = unescape_interpolation(value[1..-1].strip, escape_html)
+          value = Util.unescape_interpolation(value[1..-1].strip)
+          escape_interpolation = true if escape_html
           escape_html = false
         end
       when '&', '!'
@@ -408,19 +425,21 @@ module Haml
           parse = true
           preserve_script = (value[0] == ?~)
           if value[1] == ?=
-            value = unescape_interpolation(value[2..-1].strip, escape_html)
+            value = Util.unescape_interpolation(value[2..-1].strip)
+            escape_interpolation = true if escape_html
             escape_html = false
           else
             value = value[1..-1].strip
           end
-        elsif contains_interpolation?(value)
-          value = unescape_interpolation(value, escape_html)
+        elsif Util.contains_interpolation?(value)
+          value = Util.unescape_interpolation(value)
+          escape_interpolation = true if escape_html
           parse = true
           escape_html = false
         end
       else
-        if contains_interpolation?(value)
-          value = unescape_interpolation(value, escape_html)
+        if Util.contains_interpolation?(value)
+          value = Util.unescape_interpolation(value, escape_html)
           parse = true
           escape_html = false
         end
@@ -431,22 +450,22 @@ module Haml
 
       if attributes_hashes[:new]
         static_attributes, attributes_hash = attributes_hashes[:new]
-        AttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
+        AttributeMerger.merge_attributes!(attributes, static_attributes) if static_attributes
         dynamic_attributes.new = attributes_hash
       end
 
       if attributes_hashes[:old]
         static_attributes = parse_static_hash(attributes_hashes[:old])
-        AttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
+        AttributeMerger.merge_attributes!(attributes, static_attributes) if static_attributes
         dynamic_attributes.old = attributes_hashes[:old] unless static_attributes || @options.suppress_eval
       end
 
-      raise SyntaxError.new(Error.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
-      raise SyntaxError.new(Error.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
-      raise SyntaxError.new(Error.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
+      raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
+      raise HamlSyntaxError.new(HamlError.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
 
       if block_opened? && !value.empty? && !is_ruby_multiline?(value)
-        raise SyntaxError.new(Error.message(:illegal_nesting_line, tag_name), @next_line.index)
+        raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_line, tag_name), @next_line.index)
       end
 
       self_closing ||= !!(!block_opened? && value.empty? && @options.autoclose.any? {|t| t === tag_name})
@@ -459,7 +478,8 @@ module Haml
         :nuke_inner_whitespace => nuke_inner_whitespace,
         :nuke_outer_whitespace => nuke_outer_whitespace, :object_ref => object_ref,
         :escape_html => escape_html, :preserve_tag => preserve_tag,
-        :preserve_script => preserve_script, :parse => parse, :value => line.text)
+        :preserve_script => preserve_script, :parse => parse, :value => line.text,
+        :escape_interpolation => escape_interpolation)
     end
 
     # Renders a line that creates an XHTML tag and has an implicit div because of
@@ -481,15 +501,15 @@ module Haml
       conditional, text = balance(text, ?[, ?]) if text[0] == ?[
       text.strip!
 
-      if contains_interpolation?(text)
+      if Util.contains_interpolation?(text)
         parse = true
-        text = unescape_interpolation(text)
+        text = Util.unescape_interpolation(text)
       else
         parse = false
       end
 
       if block_opened? && !text.empty?
-        raise SyntaxError.new(Haml::Error.message(:illegal_nesting_content), @next_line.index)
+        raise HamlSyntaxError.new(Haml::HamlError.message(:illegal_nesting_content), @next_line.index)
       end
 
       ParseNode.new(:comment, @line.index + 1, :conditional => conditional, :text => text, :revealed => revealed, :parse => parse)
@@ -497,13 +517,13 @@ module Haml
 
     # Renders an XHTML doctype or XML shebang.
     def doctype(text)
-      raise SyntaxError.new(Error.message(:illegal_nesting_header), @next_line.index) if block_opened?
+      raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_header), @next_line.index) if block_opened?
       version, type, encoding = text[3..-1].strip.downcase.scan(DOCTYPE_REGEX)[0]
       ParseNode.new(:doctype, @line.index + 1, :version => version, :type => type, :encoding => encoding)
     end
 
     def filter(name)
-      raise Error.new(Error.message(:invalid_filter_name, name)) unless name =~ /^\w+$/
+      raise HamlError.new(HamlError.message(:invalid_filter_name, name)) unless name =~ /^\w+$/
 
       if filter_opened?
         @flat = true
@@ -552,7 +572,7 @@ module Haml
 
     alias :close_script :close_silent_script
 
-    # This is a class method so it can be accessed from {Haml::Helpers}.
+    # This is a class method so it can be accessed from {Haml::HamlHelpers}.
     #
     # Iterates through the classes and ids supplied through `.`
     # and `#` syntax, and returns a hash with them as attributes,
@@ -576,8 +596,8 @@ module Haml
       attributes
     end
 
-    # This method doesn't use Haml::AttributeParser because currently it depends on Ripper and Rubinius doesn't provide it.
-    # Ideally this logic should be placed in Haml::AttributeParser instead of here and this method should use it.
+    # This method doesn't use Haml::HamlAttributeParser because currently it depends on Ripper and Rubinius doesn't provide it.
+    # Ideally this logic should be placed in Haml::HamlAttributeParser instead of here and this method should use it.
     #
     # @param  [String] text - Hash literal or text inside old attributes
     # @return [Hash,nil] - Return nil if text is not static Hash literal
@@ -601,12 +621,12 @@ module Haml
     # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value
     def parse_tag(text)
       match = text.scan(/%([-:\w]+)([-:\w.#\@]*)(.+)?/)[0]
-      raise SyntaxError.new(Error.message(:invalid_tag, text)) unless match
+      raise HamlSyntaxError.new(HamlError.message(:invalid_tag, text)) unless match
 
       tag_name, attributes, rest = match
 
       if !attributes.empty? && (attributes =~ /[.#](\.|#|\z)/)
-        raise SyntaxError.new(Error.message(:illegal_element))
+        raise HamlSyntaxError.new(HamlError.message(:illegal_element))
       end
 
       new_attributes_hash = old_attributes_hash = last_line = nil
@@ -665,8 +685,8 @@ module Haml
         # 1 more :on_embexpr_end (the last '}') than :on_embexpr_beg, and resurrects '{' afterwards.
         balanced, rest = balance_tokens(text.sub(?{, METHOD_CALL_PREFIX), :on_embexpr_beg, :on_embexpr_end, count: 1)
         attributes_hash = balanced.sub(METHOD_CALL_PREFIX, ?{)
-      rescue SyntaxError => e
-        if e.message == Error.message(:unbalanced_brackets) && !@template.empty?
+      rescue HamlSyntaxError => e
+        if e.message == HamlError.message(:unbalanced_brackets) && !@template.empty?
           text << "\n#{@next_line.text}"
           last_line += 1
           next_line
@@ -695,7 +715,7 @@ module Haml
         if name == false
           scanned = Haml::Util.balance(text, ?(, ?))
           text = scanned ? scanned.first : text
-          raise Haml::SyntaxError.new(Error.message(:invalid_attribute_list, text.inspect), last_line - 1)
+          raise Haml::HamlSyntaxError.new(HamlError.message(:invalid_attribute_list, text.inspect), last_line - 1)
         end
         attributes[name] = value
         scanner.scan(/\s*/)
@@ -714,7 +734,7 @@ module Haml
         if type == :static
           static_attributes[name] = val
         else
-          dynamic_attributes << "#{inspect_obj(name)} => #{val},"
+          dynamic_attributes << "#{Util.inspect_obj(name)} => #{val},"
         end
       end
       dynamic_attributes << "}"
@@ -749,7 +769,7 @@ module Haml
 
       return name, [:static, content.first[1]] if content.size == 1
       return name, [:dynamic,
-        %!"#{content.each_with_object(''.dup) {|(t, v), s| s << (t == :str ? inspect_obj(v)[1...-1] : "\#{#{v}}")}}"!]
+        %!"#{content.each_with_object(''.dup) {|(t, v), s| s << (t == :str ? Util.inspect_obj(v)[1...-1] : "\#{#{v}}")}}"!]
     end
 
     def next_line
@@ -817,7 +837,7 @@ module Haml
     end
 
     def balance(*args)
-      Haml::Util.balance(*args) or raise(SyntaxError.new(Error.message(:unbalanced_brackets)))
+      Haml::Util.balance(*args) or raise(HamlSyntaxError.new(HamlError.message(:unbalanced_brackets)))
     end
 
     # Unlike #balance, this balances Ripper tokens to balance something like `{ a: "}" }` correctly.
@@ -836,7 +856,7 @@ module Haml
           return text, buf.sub(text, '')
         end
       end
-      raise SyntaxError.new(Error.message(:unbalanced_brackets))
+      raise HamlSyntaxError.new(HamlError.message(:unbalanced_brackets))
     end
 
     def block_opened?
@@ -852,5 +872,115 @@ module Haml
     def flat?
       @flat
     end
+
+    class << AttributeMerger = Object.new
+      # Merges two attribute hashes.
+      # This is the same as `to.merge!(from)`,
+      # except that it merges id, class, and data attributes.
+      #
+      # ids are concatenated with `"_"`,
+      # and classes are concatenated with `" "`.
+      # data hashes are simply merged.
+      #
+      # Destructively modifies `to`.
+      #
+      # @param to [{String => String,Hash}] The attribute hash to merge into
+      # @param from [{String => Object}] The attribute hash to merge from
+      # @return [{String => String,Hash}] `to`, after being merged
+      def merge_attributes!(to, from)
+        from.keys.each do |key|
+          to[key] = merge_value(key, to[key], from[key])
+        end
+        to
+      end
+
+      private
+
+      # @return [String, nil]
+      def filter_and_join(value, separator)
+        return '' if (value.respond_to?(:empty?) && value.empty?)
+
+        if value.is_a?(Array)
+          value = value.flatten
+          value.map! {|item| item ? item.to_s : nil}
+          value.compact!
+          value = value.join(separator)
+        else
+          value = value ? value.to_s : nil
+        end
+        !value.nil? && !value.empty? && value
+      end
+
+      # Merge a couple of values to one attribute value. No destructive operation.
+      #
+      # @param to [String,Hash,nil]
+      # @param from [Object]
+      # @return [String,Hash]
+      def merge_value(key, to, from)
+        if from.kind_of?(Hash) || to.kind_of?(Hash)
+          from = { nil => from } if !from.is_a?(Hash)
+          to   = { nil => to }   if !to.is_a?(Hash)
+          to.merge(from)
+        elsif key == 'id'
+          merged_id = filter_and_join(from, '_')
+          if to && merged_id
+            merged_id = "#{to}_#{merged_id}"
+          elsif to || merged_id
+            merged_id ||= to
+          end
+          merged_id
+        elsif key == 'class'
+          merged_class = filter_and_join(from, ' ')
+          if to && merged_class
+            merged_class = (to.split(' ') | merged_class.split(' ')).join(' ')
+          elsif to || merged_class
+            merged_class ||= to
+          end
+          merged_class
+        else
+          from
+        end
+      end
+    end
+    private_constant :AttributeMerger
+
+    class ParserOptions
+      # A list of options that are actually used in the parser
+      AVAILABLE_OPTIONS = %i[
+        autoclose
+        escape_html
+        filename
+        line
+        mime_type
+        preserve
+        remove_whitespace
+        suppress_eval
+      ].each do |option|
+        attr_reader option
+      end
+
+      DEFAULTS = {
+        autoclose:         %w(area base basefont br col command embed frame
+                              hr img input isindex keygen link menuitem meta
+                              param source track wbr),
+        escape_html:       false,
+        filename:          '(haml)',
+        line:              1,
+        mime_type:         'text/html',
+        preserve:          %w(textarea pre code),
+        remove_whitespace: false,
+        suppress_eval:     false,
+      }
+
+      def initialize(values = {})
+        DEFAULTS.each {|k, v| instance_variable_set :"@#{k}", v}
+        AVAILABLE_OPTIONS.each do |key|
+          if values.key?(key)
+            instance_variable_set :"@#{key}", values[key]
+          end
+        end
+      end
+    end
+    private_constant :ParserOptions
   end
 end

data/lib/haml/rails_helpers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: false
+require 'haml/helpers'
+
+# Currently this Haml::Helpers depends on
+# ActionView internal implementation. (not desired)
+module Haml
+  module RailsHelpers
+    include Helpers
+    extend self
+
+    DEFAULT_PRESERVE_TAGS = %w[textarea pre code].freeze
+
+    def find_and_preserve(input = nil, tags = DEFAULT_PRESERVE_TAGS, &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 preserve(input = nil, &block)
+      return preserve(capture_haml(&block)) if block
+      super.html_safe
+    end
+
+    def surround(front, back = front, &block)
+      output = capture_haml(&block)
+
+      "#{escape_once(front)}#{output.chomp}#{escape_once(back)}\n".html_safe
+    end
+
+    def precede(str, &block)
+      "#{escape_once(str)}#{capture_haml(&block).chomp}\n".html_safe
+    end
+
+    def succeed(str, &block)
+      "#{capture_haml(&block).chomp}#{escape_once(str)}\n".html_safe
+    end
+
+    def capture_haml(*args, &block)
+      capture(*args, &block)
+    end
+  end
+end

data/lib/haml/rails_template.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'temple'
+require 'haml/engine'
+require 'haml/rails_helpers'
+require 'haml/util'
+
+module Haml
+  class RailsTemplate
+    # Compatible with: https://github.com/judofyr/temple/blob/v0.7.7/lib/temple/mixins/options.rb#L15-L24
+    class << self
+      def options
+        @options ||= {
+          generator:     Temple::Generators::RailsOutputBuffer,
+          use_html_safe: true,
+          streaming:     true,
+          buffer_class:  'ActionView::OutputBuffer',
+          disable_capture: true,
+        }
+      end
+
+      def set_options(opts)
+        options.update(opts)
+      end
+    end
+
+    def call(template, source = nil)
+      source ||= template.source
+      options = RailsTemplate.options
+
+      # https://github.com/haml/haml/blob/4.0.7/lib/haml/template/plugin.rb#L19-L20
+      # https://github.com/haml/haml/blob/4.0.7/lib/haml/options.rb#L228
+      if template.respond_to?(:type) && template.type == 'text/xml'
+        options = options.merge(format: :xhtml)
+      end
+
+      if ActionView::Base.try(:annotate_rendered_view_with_filenames) && template.format == :html
+        options = options.merge(
+          preamble: "<!-- BEGIN #{template.short_identifier} -->\n",
+          postamble: "<!-- END #{template.short_identifier} -->\n",
+        )
+      end
+
+      Engine.new(options).call(source)
+    end
+
+    def supports_streaming?
+      RailsTemplate.options[:streaming]
+    end
+  end
+  ActionView::Template.register_template_handler(:haml, RailsTemplate.new)
+end
+
+# Haml extends Haml::Helpers in ActionView each time.
+# It costs much, so Haml includes a compatible module at first.
+ActionView::Base.send :include, Haml::RailsHelpers