haml 5.2.2 → 6.1.1

data/lib/haml/engine.rb

@@ -1,238 +1,59 @@
 # frozen_string_literal: true
-
-require 'forwardable'
-
+require 'temple'
 require 'haml/parser'
 require 'haml/compiler'
-require 'haml/options'
-require 'haml/helpers'
-require 'haml/buffer'
-require 'haml/filters'
-require 'haml/error'
-require 'haml/temple_engine'
+require 'haml/html'
+require 'haml/string_splitter'
+require 'haml/escape'
+require 'haml/escape_any'
+require 'haml/force_escape'
+require 'haml/dynamic_merger'
+require 'haml/ambles'
+require 'haml/whitespace'
 
 module Haml
-  # This is the frontend for using Haml programmatically.
-  # It can be directly used by the user by creating a
-  # new instance and calling \{#render} to render the template.
-  # For example:
-  #
-  #     template = File.read('templates/really_cool_template.haml')
-  #     haml_engine = Haml::Engine.new(template)
-  #     output = haml_engine.render
-  #     puts output
-  class Engine
-    extend Forwardable
-    include Haml::Util
-
-    # The Haml::Options instance.
-    # See {file:REFERENCE.md#options the Haml options documentation}.
-    #
-    # @return Haml::Options
-    attr_accessor :options
-
-    # The indentation used in the Haml document,
-    # or `nil` if the indentation is ambiguous
-    # (for example, for a single-level document).
-    #
-    # @return [String]
-    attr_accessor :indentation
-
-    # Tilt currently depends on these moved methods, provide a stable API
-    def_delegators :compiler, :precompiled, :precompiled_method_return_value
-
-    def options_for_buffer
-      @options.for_buffer
-    end
-
-    # Precompiles the Haml template.
-    #
-    # @param template [String] The Haml template
-    # @param options [{Symbol => Object}] An options hash;
-    #   see {file:REFERENCE.md#options the Haml options documentation}
-    # @raise [Haml::Error] if there's a Haml syntax error in the template
-    def initialize(template, options = {})
-      # Reflect changes of `Haml::Options.defaults` to `Haml::TempleEngine` options, but `#initialize_encoding`
-      # should be run against the arguemnt `options[:encoding]` for backward compatibility with old `Haml::Engine`.
-      options = Options.defaults.dup.tap { |o| o.delete(:encoding) }.merge!(options)
-      @options = Options.new(options)
-
-      @template = check_haml_encoding(template) do |msg, line|
-        raise Haml::Error.new(msg, line)
-      end
-
-      @temple_engine = TempleEngine.new(options)
-      @temple_engine.compile(@template)
-    end
-
-    # 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`, 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
-    # (either the scope object or the `self` object of the scope binding).
-    # It extends {Haml::Helpers}, and various instance variables are set
-    # (all prefixed with `haml_`).
-    # For example:
-    #
-    #     s = "foobar"
-    #     Haml::Engine.new("%p= upcase").render(s) #=> "<p>FOOBAR</p>"
-    #
-    #     # s now extends Haml::Helpers
-    #     s.respond_to?(:html_attrs) #=> true
-    #
-    # `locals` is a hash of local variables to make available to the template.
-    # For example:
-    #
-    #     Haml::Engine.new("%p= foo").render(Object.new, :foo => "Hello, world!") #=> "<p>Hello, world!</p>"
-    #
-    # If a block is passed to render,
-    # that block is run when `yield` is called
-    # within the template.
-    #
-    # Due to some Ruby quirks,
-    # 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, 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
-      buffer = Haml::Buffer.new(parent, @options.for_buffer)
-
-      if scope.is_a?(Binding)
-        scope_object = eval("self", scope)
-        scope = scope_object.instance_eval{binding} if block_given?
-      else
-        scope_object = scope
-        scope = scope_object.instance_eval{binding}
-      end
-
-      set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
-
-      scope_object.extend(Haml::Helpers)
-      scope_object.instance_variable_set(:@haml_buffer, buffer)
-      begin
-        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_variable_set(:@haml_buffer, buffer.upper) if buffer
-    end
-    alias_method :to_html, :render
-
-    # Returns a proc that, when called,
-    # renders the template and returns the result as a string.
-    #
-    # `scope` works the same as it does for render.
-    #
-    # The first argument of the returned proc is a hash of local variable names to values.
-    # However, due to an unfortunate Ruby quirk,
-    # the local variables which can be assigned must be pre-declared.
-    # This is done with the `local_names` argument.
-    # For example:
-    #
-    #     # This works
-    #     Haml::Engine.new("%p= foo").render_proc(Object.new, :foo).call :foo => "Hello!"
-    #       #=> "<p>Hello!</p>"
-    #
-    #     # This doesn't
-    #     Haml::Engine.new("%p= foo").render_proc.call :foo => "Hello!"
-    #       #=> NameError: undefined local variable or method `foo'
-    #
-    # The proc doesn't take a block; any yields in the template will fail.
-    #
-    # @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_object = eval("self", scope)
-      else
-        scope_object = scope
-        scope = scope_object.instance_eval{binding}
-      end
-
-      begin
-        str = @temple_engine.precompiled_with_ambles(local_names)
-        eval(
-          "Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {}; #{str}}\n",
-          scope,
-          @options.filename,
-          @options.line
-        )
-      rescue ::SyntaxError => e
-        raise SyntaxError, e.message
-      end
-    end
-
-    # Defines a method on `object` with the given name
-    # that renders the template and returns the result as a string.
-    #
-    # If `object` is a class or module,
-    # the method will instead be defined as an instance method.
-    # For example:
-    #
-    #     t = Time.now
-    #     Haml::Engine.new("%p\n  Today's date is\n  .date= self.to_s").def_method(t, :render)
-    #     t.render #=> "<p>\n  Today's date is\n  <div class='date'>Fri Nov 23 18:28:29 -0800 2007</div>\n</p>\n"
-    #
-    #     Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
-    #     "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
-    #
-    # The first argument of the defined method is a hash of local variable names to values.
-    # However, due to an unfortunate Ruby quirk,
-    # the local variables which can be assigned must be pre-declared.
-    # This is done with the `local_names` argument.
-    # For example:
-    #
-    #     # This works
-    #     obj = Object.new
-    #     Haml::Engine.new("%p= foo").def_method(obj, :render, :foo)
-    #     obj.render(:foo => "Hello!") #=> "<p>Hello!</p>"
-    #
-    #     # This doesn't
-    #     obj = Object.new
-    #     Haml::Engine.new("%p= foo").def_method(obj, :render)
-    #     obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
-    #
-    # Note that Haml modifies the evaluation context
-    # (either the scope object or the `self` object of the scope binding).
-    # It extends {Haml::Helpers}, and various instance variables are set
-    # (all prefixed with `haml_`).
-    #
-    # @param object [Object, Module] The object on which to define the method
-    # @param name [String, Symbol] The name of the method to define
-    # @param local_names [Array<Symbol>] The names of the locals that can be passed to the proc
-    def def_method(object, name, *local_names)
-      method = object.is_a?(Module) ? :module_eval : :instance_eval
+  class Engine < Temple::Engine
+    define_options(
+      :buffer_class,
+      generator:    Temple::Generators::StringBuffer,
+      format:       :html,
+      attr_quote:   "'",
+      escape_html:  true,
+      escape_attrs: true,
+      autoclose:    %w(area base basefont br col command embed frame
+                       hr img input isindex keygen link menuitem meta
+                       param source track wbr),
+      filename:     "",
+      disable_capture: false,
+      remove_whitespace: false,
+    )
+
+    use Parser
+    use Compiler
+    use HTML
+    use StringSplitter
+    filter :StaticAnalyzer
+    use Escape
+    use EscapeAny
+    use ForceEscape
+    filter :ControlFlow
+    use Ambles
+    filter :MultiFlattener
+    use Whitespace
+    filter :StaticMerger
+    use DynamicMerger
+    use :Generator, -> { options[:generator] }
+  end
 
-      object.send(method, "def #{name}(_haml_locals = {}); #{@temple_engine.precompiled_with_ambles(local_names)}; end",
-                  @options.filename, @options.line)
+  # For backward compatibility of Tilt integration. TODO: We should deprecate this
+  # and let Tilt have a native support of Haml 6. At least it generates warnings now.
+  class TempleEngine < Engine
+    def compile(template)
+      @precompiled = call(template)
     end
 
-    private
-
-    def set_locals(locals, scope, scope_object)
-      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)
+    def precompiled_with_ambles(_local_names, after_preamble:)
+      "#{after_preamble.tr("\n", ';')}#{@precompiled}".dup
     end
   end
 end

data/lib/haml/error.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
-
 module Haml
-  # An exception raised by Haml code.
   class Error < StandardError
-
     MESSAGES = {
       bad_script_indent:            '"%s" is indented at wrong level: expected %d, but was at %d.',
       cant_run_filter:              'Can\'t run "%s" filter; you must require its dependencies first',
@@ -61,5 +58,9 @@ END
   # except in that it's a subclass of {Haml::Error}.
   class SyntaxError < Error; end
 
-  class InvalidAttributeNameError < SyntaxError; end
+  # An invalid filter name was used.
+  class FilterNotFound < Error; end
+
+  # InternalError means that you hit a bug of Haml itself.
+  class InternalError < Error; end
 end

data/lib/haml/escape.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'haml/util'
+
+module Haml
+  class Escape < Temple::Filters::Escapable
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] ||
+        "::Haml::Util.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+  end
+end

data/lib/haml/escape_any.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'haml/escape'
+
+module Haml
+  # This module allows Temple::Filter to dispatch :fescape on `#compile`.
+  module EscapeanyDispathcer
+    def on_escapeany(flag, exp)
+      [:escapeany, flag, compile(exp)]
+    end
+  end
+  ::Temple::Filter.include EscapeanyDispathcer
+
+  # Unlike Haml::Escape, this calls to_s when not escaped.
+  class EscapeAny < Escape
+    alias_method :on_escapeany, :on_escape
+
+    def on_dynamic(value)
+      [:dynamic, @escape ? @escape_code % value : "(#{value}).to_s"]
+    end
+  end
+end

data/lib/haml/filters/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require 'haml/util'
+
+module Haml
+  class Filters
+    class Base
+      def initialize(options = {})
+        @format = options[:format]
+      end
+    end
+  end
+end

data/lib/haml/filters/cdata.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Cdata < TextBase
+      def compile(node)
+        compile_cdata(node)
+      end
+
+      private
+
+      def compile_cdata(node)
+        temple = [:multi]
+        temple << [:static, "<![CDATA[\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n]]>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/coffee.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Coffee < TiltBase
+      def compile(node)
+        require 'tilt/coffee' if explicit_require?('coffee')
+        temple = [:multi]
+        temple << [:static, "<script>\n"]
+        temple << compile_with_tilt(node, 'coffee', indent_width: 2)
+        temple << [:static, "</script>"]
+        temple
+      end
+    end
+
+    CoffeeScript = Coffee
+  end
+end

data/lib/haml/filters/css.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Css < TextBase
+      def compile(node)
+        case @format
+        when :xhtml
+          compile_xhtml(node)
+        else
+          compile_html(node)
+        end
+      end
+
+      private
+
+      def compile_html(node)
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        compile_text!(temple, node, '  ')
+        temple << [:static, "\n</style>"]
+        temple
+      end
+
+      def compile_xhtml(node)
+        temple = [:multi]
+        temple << [:static, "<style type='text/css'>\n  /*<![CDATA[*/\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n  /*]]>*/\n</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/erb.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Erb < TiltBase
+      def compile(node)
+        precompiled_with_tilt(node, 'erb')
+      end
+    end
+  end
+end

data/lib/haml/filters/escaped.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Escaped < Base
+      def compile(node)
+        text = node.value[:text].rstrip
+        temple = compile_text(text)
+        [:escape, true, temple]
+      end
+
+      private
+
+      def compile_text(text)
+        if ::Haml::Util.contains_interpolation?(text)
+          [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/javascript.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Javascript < TextBase
+      def compile(node)
+        case @format
+        when :xhtml
+          compile_xhtml(node)
+        else
+          compile_html(node)
+        end
+      end
+
+      private
+
+      def compile_html(node)
+        temple = [:multi]
+        temple << [:static, "<script>\n"]
+        compile_text!(temple, node, '  ')
+        temple << [:static, "\n</script>"]
+        temple
+      end
+
+      def compile_xhtml(node)
+        temple = [:multi]
+        temple << [:static, "<script type='text/javascript'>\n  //<![CDATA[\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n  //]]>\n</script>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/less.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# LESS support is deprecated since it requires therubyracer.gem,
+# which is hard to maintain.
+#
+# It's not supported in Sprockets 3.0+ too.
+# https://github.com/sstephenson/sprockets/pull/547
+module Haml
+  class Filters
+    class Less < TiltBase
+      def compile(node)
+        require 'tilt/less' if explicit_require?('less')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'less', indent_width: 2)
+        temple << [:static, '</style>']
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/markdown.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Markdown < TiltBase
+      def compile(node)
+        require 'tilt/redcarpet' if explicit_require?('markdown')
+        compile_with_tilt(node, 'markdown')
+      end
+    end
+  end
+end

data/lib/haml/filters/plain.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'haml/string_splitter'
+
+module Haml
+  class Filters
+    class Plain < Base
+      def compile(node)
+        text = node.value[:text]
+        text = text.rstrip unless ::Haml::Util.contains_interpolation?(text) # for compatibility
+        [:multi, *compile_plain(text)]
+      end
+
+      private
+
+      def compile_plain(text)
+        string_literal = ::Haml::Util.unescape_interpolation(text)
+        StringSplitter.compile(string_literal).map do |temple|
+          type, str = temple
+          case type
+          when :dynamic
+            [:escape, false, [:dynamic, str]]
+          else
+            temple
+          end
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/preserve.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Preserve < Base
+      def compile(node)
+        text = node.value[:text].rstrip + "\n"
+        text = text.gsub("\n", '&#x000A;')
+        compile_text(text)
+      end
+
+      private
+
+      def compile_text(text)
+        if ::Haml::Util.contains_interpolation?(text)
+          [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Ruby < Base
+      def compile(node)
+        [:code, node.value[:text]]
+      end
+    end
+  end
+end

data/lib/haml/filters/sass.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Sass < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('sass')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'sass', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/scss.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Scss < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('scss')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'scss', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/text_base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class TextBase < Base
+      def compile_text!(temple, node, prefix)
+        text = node.value[:text].rstrip.gsub(/^/, prefix)
+        if ::Haml::Util.contains_interpolation?(node.value[:text])
+          # original: Haml::Filters#compile
+          text = ::Haml::Util.unescape_interpolation(text).gsub(/(\\+)n/) do |s|
+            escapes = $1.size
+            next s if escapes % 2 == 0
+            "#{'\\' * (escapes - 1)}\n"
+          end
+          text.prepend("\n")
+          temple << [:dynamic, text]
+        else
+          node.value[:text].split("\n").size.times do
+            temple << [:newline]
+          end
+          temple << [:static, text]
+        end
+      end
+    end
+  end
+end