haml 4.0.0 → 5.0.0

data/lib/haml/engine.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'forwardable'
 
 require 'haml/parser'
@@ -7,6 +8,7 @@ require 'haml/helpers'
 require 'haml/buffer'
 require 'haml/filters'
 require 'haml/error'
+require 'haml/temple_engine'
 
 module Haml
   # This is the frontend for using Haml programmatically.
@@ -35,9 +37,6 @@ module Haml
     # @return [String]
     attr_accessor :indentation
 
-    attr_accessor :compiler
-    attr_accessor :parser
-
     # Tilt currently depends on these moved methods, provide a stable API
     def_delegators :compiler, :precompiled, :precompiled_method_return_value
 
@@ -58,19 +57,19 @@ module Haml
         raise Haml::Error.new(msg, line)
       end
 
-      initialize_encoding options[:encoding]
-
-      @parser   = @options.parser_class.new(@template, @options)
-      @compiler = @options.compiler_class.new(@options)
+      @temple_engine = TempleEngine.new(options)
+      @temple_engine.compile(@template)
+    end
 
-      @compiler.compile(@parser.parse)
+    # Deprecated API for backword compatibility
+    def compiler
+      @temple_engine
     end
 
     # Processes the template and returns the result as a string.
     #
     # `scope` is the context in which the template is evaluated.
-    # If it's a `Binding` or `Proc` object,
-    # Haml uses it as the second argument to `Kernel#eval`;
+    # If it's a `Binding`, Haml uses it as the second argument to `Kernel#eval`;
     # otherwise, Haml just uses its `#instance_eval` context.
     #
     # Note that Haml modifies the evaluation context
@@ -95,23 +94,23 @@ module Haml
     # within the template.
     #
     # Due to some Ruby quirks,
-    # if `scope` is a `Binding` or `Proc` object and a block is given,
+    # if `scope` is a `Binding` object and a block is given,
     # the evaluation context may not be quite what the user expects.
     # In particular, it's equivalent to passing `eval("self", scope)` as `scope`.
     # This won't have an effect in most cases,
     # but if you're relying on local variables defined in the context of `scope`,
     # they won't work.
     #
-    # @param scope [Binding, Proc, Object] The context in which the template is evaluated
+    # @param scope [Binding, Object] The context in which the template is evaluated
     # @param locals [{Symbol => Object}] Local variables that will be made available
     #   to the template
     # @param block [#to_proc] A block that can be yielded to within the template
     # @return [String] The rendered template
     def render(scope = Object.new, locals = {}, &block)
-      parent = scope.instance_variable_defined?('@haml_buffer') ? scope.instance_variable_get('@haml_buffer') : nil
+      parent = scope.instance_variable_defined?(:@haml_buffer) ? scope.instance_variable_get(:@haml_buffer) : nil
       buffer = Haml::Buffer.new(parent, @options.for_buffer)
 
-      if scope.is_a?(Binding) || scope.is_a?(Proc)
+      if scope.is_a?(Binding)
         scope_object = eval("self", scope)
         scope = scope_object.instance_eval{binding} if block_given?
       else
@@ -121,20 +120,16 @@ module Haml
 
       set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
 
-      scope_object.instance_eval do
-        extend Haml::Helpers
-        @haml_buffer = buffer
-      end
+      scope_object.extend(Haml::Helpers)
+      scope_object.instance_variable_set(:@haml_buffer, buffer)
       begin
-        eval(@compiler.precompiled_with_return_value, scope, @options[:filename], @options[:line])
+        eval(@temple_engine.precompiled_with_return_value, scope, @options.filename, @options.line)
       rescue ::SyntaxError => e
         raise SyntaxError, e.message
       end
     ensure
       # Get rid of the current buffer
-      scope_object.instance_eval do
-        @haml_buffer = buffer.upper if buffer
-      end
+      scope_object.instance_variable_set(:@haml_buffer, buffer.upper) if buffer
     end
     alias_method :to_html, :render
 
@@ -159,11 +154,11 @@ module Haml
     #
     # The proc doesn't take a block; any yields in the template will fail.
     #
-    # @param scope [Binding, Proc, Object] The context in which the template is evaluated
+    # @param scope [Binding, Object] The context in which the template is evaluated
     # @param local_names [Array<Symbol>] The names of the locals that can be passed to the proc
     # @return [Proc] The proc that will run the template
     def render_proc(scope = Object.new, *local_names)
-      if scope.is_a?(Binding) || scope.is_a?(Proc)
+      if scope.is_a?(Binding)
         scope_object = eval("self", scope)
       else
         scope_object = scope
@@ -171,8 +166,8 @@ module Haml
       end
 
       begin
-        eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
-             compiler.precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
+        eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" <<
+             @temple_engine.precompiled_with_ambles(local_names) << "}\n", scope, @options.filename, @options.line)
       rescue ::SyntaxError => e
         raise SyntaxError, e.message
       end
@@ -182,7 +177,7 @@ module Haml
     # that renders the template and returns the result as a string.
     #
     # If `object` is a class or module,
-    # the method will instead by defined as an instance method.
+    # the method will instead be defined as an instance method.
     # For example:
     #
     #     t = Time.now
@@ -219,25 +214,14 @@ module Haml
     def def_method(object, name, *local_names)
       method = object.is_a?(Module) ? :module_eval : :instance_eval
 
-      object.send(method, "def #{name}(_haml_locals = {}); #{compiler.precompiled_with_ambles(local_names)}; end",
-                  @options[:filename], @options[:line])
+      object.send(method, "def #{name}(_haml_locals = {}); #{@temple_engine.precompiled_with_ambles(local_names)}; end",
+                  @options.filename, @options.line)
     end
 
     private
 
-    if RUBY_VERSION < "1.9"
-      def initialize_encoding(given_value)
-      end
-    else
-      def initialize_encoding(given_value)
-        unless given_value
-          @options.encoding = Encoding.default_internal || @template.encoding
-        end
-      end
-    end
-
     def set_locals(locals, scope, scope_object)
-      scope_object.send(:instance_variable_set, '@_haml_locals', locals)
+      scope_object.instance_variable_set :@_haml_locals, locals
       set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")
       eval(set_locals, scope)
     end

data/lib/haml/error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # An exception raised by Haml code.
   class Error < StandardError
@@ -58,4 +59,6 @@ END
   # It's not particularly interesting,
   # except in that it's a subclass of {Haml::Error}.
   class SyntaxError < Error; end
+
+  class InvalidAttributeNameError < SyntaxError; end
 end

data/lib/haml/escapable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Haml
+  # Like Temple::Filters::Escapable, but with support for escaping by
+  # Haml::Herlpers.html_escape and Haml::Herlpers.escape_once.
+  class Escapable < Temple::Filter
+    def initialize(*)
+      super
+      @escape_code = "::Haml::Helpers.html_escape((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+      @once_escape_code = "::Haml::Helpers.escape_once((%s))"
+      @once_escaper = eval("proc {|v| #{@once_escape_code % 'v'} }")
+      @escape = false
+    end
+
+    def on_escape(flag, exp)
+      old = @escape
+      @escape = flag
+      compile(exp)
+    ensure
+      @escape = old
+    end
+
+    # The same as Haml::AttributeBuilder.build_attributes
+    def on_static(value)
+      [:static,
+       if @escape == :once
+         @once_escaper[value]
+       elsif @escape
+         @escaper[value]
+       else
+         value
+       end
+      ]
+    end
+
+    # The same as Haml::AttributeBuilder.build_attributes
+    def on_dynamic(value)
+      [:dynamic,
+       if @escape == :once
+         @once_escape_code % value
+       elsif @escape
+         @escape_code % value
+       else
+         "(#{value}).to_s"
+       end
+      ]
+    end
+  end
+end

data/lib/haml/exec.rb

@@ -1,5 +1,5 @@
+# frozen_string_literal: true
 require 'optparse'
-require 'fileutils'
 require 'rbconfig'
 require 'pp'
 
@@ -212,11 +212,6 @@ END
           @options[:output] = StringIO.new
         end
 
-        opts.on('-t', '--style NAME',
-                'Output style. Can be indented (default) or ugly.') do |name|
-          @options[:for_engine][:ugly] = true if name.to_sym == :ugly
-        end
-
         opts.on('-f', '--format NAME',
                 'Output format. Can be html5 (default), xhtml, or html4.') do |name|
           @options[:for_engine][:format] = name.to_sym
@@ -237,6 +232,11 @@ END
           @options[:for_engine][:attr_wrapper] = '"'
         end
 
+        opts.on('--remove-whitespace',
+                'Remove whitespace surrounding and within tags') do
+          @options[:for_engine][:remove_whitespace] = true
+        end
+
         opts.on('--cdata',
                 'Always add CDATA sections to javascript and css blocks.') do
           @options[:for_engine][:cdata] = true
@@ -260,15 +260,13 @@ END
           @options[:load_paths] << path
         end
 
-        unless RUBY_VERSION < "1.9"
-          opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
-            external, internal = encoding.split(':')
-            Encoding.default_external = external if external && !external.empty?
-            Encoding.default_internal = internal if internal && !internal.empty?
-          end
+        opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+          external, internal = encoding.split(':')
+          Encoding.default_external = external if external && !external.empty?
+          Encoding.default_internal = internal if internal && !internal.empty?
         end
 
-        opts.on('-d', '--debug', "Print out the precompiled Ruby source.") do
+        opts.on('-d', '--debug', "Print out the precompiled Ruby source, and show syntax errors in the Ruby code.") do
           @options[:debug] = true
         end
 
@@ -294,20 +292,28 @@ END
 
         begin
 
-          engine = ::Haml::Engine.new(template, @options[:for_engine])
-          if @options[:check_syntax]
-            puts "Syntax OK"
+          if @options[:parse]
+            parser = ::Haml::Parser.new(::Haml::Options.new(@options))
+            pp parser.call(template)
             return
           end
 
-          if @options[:parse]
-            pp engine.parser.root
+          engine = ::Haml::Engine.new(template, @options[:for_engine])
+
+          if @options[:check_syntax]
+            puts "Syntax OK"
             return
           end
 
           if @options[:debug]
             puts engine.precompiled
-            puts '=' * 100
+            error = validate_ruby(engine.precompiled)
+            if error
+              puts '=' * 100
+              puts error.message.split("\n")[0]
+              exit 1
+            end
+            return
           end
 
           result = engine.to_html
@@ -324,6 +330,14 @@ END
         output.write(result)
         output.close() if output.is_a? File
       end
+
+      def validate_ruby(code)
+        begin
+          eval("BEGIN {return nil}; #{code}")
+        rescue ::SyntaxError # Not to be confused with Haml::SyntaxError
+          $!
+        end
+      end
     end
   end
 end

data/lib/haml/filters.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require "tilt"
 
 module Haml
@@ -59,7 +60,7 @@ module Haml
     end
 
     # Removes a filter from Haml. If the filter was removed, it returns
-    # the that was remove Module upon success, or nil on failure. If you try
+    # the Module that was removed upon success, or nil on failure. If you try
     # to redefine a filter, Haml will raise an error. Use this method first to
     # explicitly remove the filter before redefining it.
     # @return Module The filter module that has been removed
@@ -163,10 +164,10 @@ module Haml
           if contains_interpolation?(text)
             return if options[:suppress_eval]
 
-            text = unescape_interpolation(text).gsub(/(\\+)n/) do |s|
+            text = unescape_interpolation(text, options[:escape_html]).gsub(/(\\+)n/) do |s|
               escapes = $1.size
               next s if escapes % 2 == 0
-              ("\\" * (escapes - 1)) + "\n"
+              "#{'\\' * (escapes - 1)}\n"
             end
             # We need to add a newline at the beginning to get the
             # filter lines to line up (since the Haml filter contains
@@ -174,7 +175,7 @@ module Haml
             # filter name). Then we need to escape the trailing
             # newline so that the whole filter block doesn't take up
             # too many.
-            text = "\n" + text.sub(/\n"\Z/, "\\n\"")
+            text = %[\n#{text.sub(/\n"\Z/, "\\n\"")}]
             push_script <<RUBY.rstrip, :escape_html => false
 find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _hamlout.options))
 RUBY
@@ -182,12 +183,8 @@ RUBY
           end
 
           rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, compiler.options), compiler.options[:preserve])
-
-          if options[:ugly]
-            push_text(rendered.rstrip)
-          else
-            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
-          end
+          rendered.rstrip!
+          push_text("#{rendered}\n")
         end
       end
     end
@@ -216,13 +213,10 @@ RUBY
           type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
         end
 
-        str = "<script#{type}>\n"
-        str << "  //<![CDATA[\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  //]]>\n" if options[:cdata]
-        str << "</script>"
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
 
-        str
+        %!<script#{type}>\n#{"  //<![CDATA[\n" if options[:cdata]}#{indent}#{text}\n#{"  //]]>\n" if options[:cdata]}</script>!
       end
     end
 
@@ -240,13 +234,10 @@ RUBY
           type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
         end
 
-        str = "<style#{type}>\n"
-        str << "  /*<![CDATA[*/\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  /*]]>*/\n" if options[:cdata]
-        str << "</style>"
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
 
-        str
+        %(<style#{type}>\n#{"  /*<![CDATA[*/\n" if options[:cdata]}#{indent}#{text}\n#{"  /*]]>*/\n" if options[:cdata]}</style>)
       end
     end
 
@@ -256,7 +247,10 @@ RUBY
 
       # @see Base#render
       def render(text)
-        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+        text = "\n#{text}"
+        text.rstrip!
+        text.gsub!("\n", "\n    ")
+        "<![CDATA[#{text}\n]]>"
       end
     end
 
@@ -288,7 +282,7 @@ RUBY
       def compile(compiler, text)
         return if compiler.options[:suppress_eval]
         compiler.instance_eval do
-          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
+          push_silent <<-FIRST.tr("\n", ';') + text + <<-LAST.tr("\n", ';')
             begin
               haml_io = StringIO.new(_hamlout.buffer, 'a')
           FIRST
@@ -385,6 +379,8 @@ RUBY
     module Erb
       class << self
         def precompiled(text)
+          #workaround for https://github.com/rtomayko/tilt/pull/183
+          require 'erubis' if (defined?(::Erubis) && !defined?(::Erubis::Eruby))
           super.sub(/^#coding:.*?\n/, '')
         end
       end

data/lib/haml/generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Haml
+  # Ruby code generator, which is a limited version of Temple::Generator.
+  # Limit methods since Haml doesn't need most of them.
+  class Generator
+    include Temple::Mixins::CompiledDispatcher
+    include Temple::Mixins::Options
+
+    define_options freeze_static: RUBY_VERSION >= '2.1'
+
+    def call(exp)
+      compile(exp)
+    end
+
+    def on_multi(*exp)
+      exp.map { |e| compile(e) }.join('; ')
+    end
+
+    def on_static(text)
+      concat(options[:freeze_static] ? "#{Util.inspect_obj(text)}.freeze" : Util.inspect_obj(text))
+    end
+
+    def on_dynamic(code)
+      concat(code)
+    end
+
+    def on_code(exp)
+      exp
+    end
+
+    def on_newline
+      "\n"
+    end
+
+    private
+
+    def concat(str)
+      "_hamlout.buffer << (#{str});"
+    end
+  end
+end

data/lib/haml/helpers/action_view_extensions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   module Helpers
     @@action_view_defined = true
@@ -32,7 +33,7 @@ module Haml
       #
       # @return [String] The class name for the current page
       def page_class
-        controller.controller_name + " " + controller.action_name
+        "#{controller.controller_name} #{controller.action_name}"
       end
       alias_method :generate_content_class_names, :page_class
 
@@ -45,8 +46,8 @@ module Haml
       # @yield A block in which all input to `#haml_concat` is treated as raw.
       # @see Haml::Util#rails_xss_safe?
       def with_raw_haml_concat
+        old = instance_variable_defined?(:@_haml_concat_raw) ? @_haml_concat_raw : false
         @_haml_concat_raw = true
-        old = @_haml_concat_raw
         yield
       ensure
         @_haml_concat_raw = old

data/lib/haml/helpers/action_view_mods.rb

@@ -1,60 +1,48 @@
-module ActionView
-  class Base
-    def render_with_haml(*args, &block)
-      options = args.first
-
-      # If render :layout is used with a block, it concats rather than returning
-      # a string so we need it to keep thinking it's Haml until it hits the
-      # sub-render.
-      if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
-        return non_haml { render_without_haml(*args, &block) }
+# frozen_string_literal: true
+module Haml
+  module Helpers
+    module ActionViewMods
+      def render(*args, &block)
+        options = args.first
+
+        # If render :layout is used with a block, it concats rather than returning
+        # a string so we need it to keep thinking it's Haml until it hits the
+        # sub-render.
+        if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
+          return non_haml { super }
+        end
+        super
       end
-      render_without_haml(*args, &block)
-    end
-    alias_method :render_without_haml, :render
-    alias_method :render, :render_with_haml
 
-    def output_buffer_with_haml
-      return haml_buffer.buffer if is_haml?
-      output_buffer_without_haml
-    end
-    alias_method :output_buffer_without_haml, :output_buffer
-    alias_method :output_buffer, :output_buffer_with_haml
+      def output_buffer
+        return haml_buffer.buffer if is_haml?
+        super
+      end
 
-    def set_output_buffer_with_haml(new_buffer)
-      if is_haml?
-        if Haml::Util.rails_xss_safe? && new_buffer.is_a?(ActiveSupport::SafeBuffer)
-          new_buffer = String.new(new_buffer)
+      def output_buffer=(new_buffer)
+        if is_haml?
+          if Haml::Util.rails_xss_safe? && new_buffer.is_a?(ActiveSupport::SafeBuffer)
+            new_buffer = String.new(new_buffer)
+          end
+          haml_buffer.buffer = new_buffer
+        else
+          super
         end
-        haml_buffer.buffer = new_buffer
-      else
-        set_output_buffer_without_haml new_buffer
       end
     end
-    alias_method :set_output_buffer_without_haml, :output_buffer=
-    alias_method :output_buffer=, :set_output_buffer_with_haml
+    ActionView::Base.send(:prepend, ActionViewMods)
   end
+end
 
+module ActionView
   module Helpers
     module CaptureHelper
       def capture_with_haml(*args, &block)
         if Haml::Helpers.block_is_haml?(block)
           #double assignment is to avoid warnings
           _hamlout = _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
-          value = nil
-          buffer = capture_haml(*args) { value = yield(*args) }
-          str =
-            if !buffer.empty?
-              buffer
-            elsif value.is_a?(String)
-              value
-            else
-              ''
-            end
-          # NonCattingString is present in Rails less than 3.1.0. When support
-          # for 3.0 is dropped, this can be removed.
-          return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
-          return str
+
+          capture_haml(*args, &block)
         else
           capture_without_haml(*args, &block)
         end
@@ -67,7 +55,7 @@ module ActionView
       def content_tag_with_haml(name, *args, &block)
         return content_tag_without_haml(name, *args, &block) unless is_haml?
 
-        preserve = haml_buffer.options[:preserve].include?(name.to_s)
+        preserve = haml_buffer.options.fetch(:preserve, %w[textarea pre code]).include?(name.to_s)
 
         if block_given? && block_is_haml?(block) && preserve
           return content_tag_without_haml(name, *args) {preserve(&block)}
@@ -82,8 +70,7 @@ module ActionView
       alias_method :content_tag, :content_tag_with_haml
     end
 
-    class InstanceTag
-      # Already includes TagHelper
+    module HamlSupport
       include Haml::Helpers
 
       def haml_buffer
@@ -93,6 +80,16 @@ module ActionView
       def is_haml?
         @template_object.send :is_haml?
       end
+    end
+
+    module Tags
+      class TextArea
+        include HamlSupport
+      end
+    end
+
+    class InstanceTag
+      include HamlSupport
 
       def content_tag(*args, &block)
         html_tag = content_tag_with_haml(*args, &block)
@@ -114,7 +111,7 @@ module ActionView
               with_tabs(1) {oldproc.call(*args)}
             end
           end
-          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
+          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) << "\n"
           res << "\n" if wrap_block
           res
         else
@@ -124,24 +121,5 @@ module ActionView
       alias_method :form_tag_without_haml, :form_tag
       alias_method :form_tag, :form_tag_with_haml
     end
-
-    module FormHelper
-      def form_for_with_haml(object_name, *args, &proc)
-        wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-        if wrap_block
-          oldproc = proc
-          proc = proc {|*subargs| with_tabs(1) {oldproc.call(*subargs)}}
-        end
-        res = form_for_without_haml(object_name, *args, &proc)
-        res << "\n" if wrap_block
-        res
-      end
-      alias_method :form_for_without_haml, :form_for
-      alias_method :form_for, :form_for_with_haml
-    end
   end
 end
-
-if ((ActionPack::VERSION::MAJOR == 3) && (ActionPack::VERSION::MINOR >= 2) && (ActionPack::VERSION::TINY >= 3) || (ActionPack::VERSION::MAJOR == 4))
-  require "haml/helpers/rails_323_textarea_fix"
-end

data/lib/haml/helpers/action_view_xss_mods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActionView
   module Helpers
     module CaptureHelper