haml 5.2.2 → 6.0.0.beta.1

data/lib/haml/engine.rb

@@ -1,238 +1,53 @@
 # 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/escapable'
+require 'haml/force_escapable'
+require 'haml/dynamic_merger'
+require 'haml/ambles'
 
 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::ArrayBuffer,
+      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,
+    )
+
+    use Parser
+    use Compiler
+    use HTML
+    filter :StringSplitter
+    filter :StaticAnalyzer
+    use Escapable
+    use ForceEscapable
+    filter :ControlFlow
+    use Ambles
+    filter :MultiFlattener
+    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,65 +1,16 @@
 # frozen_string_literal: true
-
 module Haml
-  # An exception raised by Haml code.
+  # TODO: unify Haml::Error (former Hamlit::Error) and Haml::HamlError (former Haml::Error)
   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',
-      cant_use_tabs_and_spaces:     "Indentation can't use both tabs and spaces.",
-      deeper_indenting:             "The line was indented %d levels deeper than the previous line.",
-      filter_not_defined:           'Filter "%s" is not defined.',
-      gem_install_filter_deps:      '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
-      illegal_element:              "Illegal element: classes and ids must have values.",
-      illegal_nesting_content:      "Illegal nesting: nesting within a tag that already has content is illegal.",
-      illegal_nesting_header:       "Illegal nesting: nesting within a header command is illegal.",
-      illegal_nesting_line:         "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
-      illegal_nesting_plain:        "Illegal nesting: nesting within plain text is illegal.",
-      illegal_nesting_self_closing: "Illegal nesting: nesting within a self-closing tag is illegal.",
-      inconsistent_indentation:     "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
-      indenting_at_start:           "Indenting at the beginning of the document is illegal.",
-      install_haml_contrib:         'To use the "%s" filter, please install the haml-contrib gem.',
-      invalid_attribute_list:       'Invalid attribute list: %s.',
-      invalid_filter_name:          'Invalid filter name ":%s".',
-      invalid_tag:                  'Invalid tag: "%s".',
-      missing_if:                   'Got "%s" with no preceding "if"',
-      no_ruby_code:                 "There's no Ruby code for %s to evaluate.",
-      self_closing_content:         "Self-closing tags can't have content.",
-      unbalanced_brackets:          'Unbalanced brackets.',
-      no_end:                       <<-END
-You don't need to use "- end" in Haml. Un-indent to close a block:
-- if foo?
-  %strong Foo!
-- else
-  Not foo.
-%p This line is un-indented, so it isn't part of the "if" block
-END
-    }.freeze
-
-    def self.message(key, *args)
-      string = MESSAGES[key] or raise "[HAML BUG] No error messages for #{key}"
-      (args.empty? ? string : string % args).rstrip
-    end
-
-    # The line of the template on which the error occurred.
-    #
-    # @return [Fixnum]
     attr_reader :line
 
-    # @param message [String] The error message
-    # @param line [Fixnum] See \{#line}
     def initialize(message = nil, line = nil)
       super(message)
       @line = line
     end
   end
 
-  # SyntaxError is the type of exception raised when Haml encounters an
-  # ill-formatted document.
-  # It's not particularly interesting,
-  # except in that it's a subclass of {Haml::Error}.
   class SyntaxError < Error; end
-
-  class InvalidAttributeNameError < SyntaxError; end
+  class InternalError < Error; end
+  class FilterNotFound < Error; end
 end

data/lib/haml/escapable.rb

@@ -1,77 +1,13 @@
 # frozen_string_literal: true
+require 'haml/util'
 
 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
-    # Special value of `flag` to ignore html_safe?
-    EscapeSafeBuffer = Struct.new(:value)
-
-    def initialize(*)
+  class Escapable < Temple::Filters::Escapable
+    def initialize(opts = {})
       super
-      @escape = false
-      @escape_safe_buffer = false
-    end
-
-    def on_escape(flag, exp)
-      old_escape, old_escape_safe_buffer = @escape, @escape_safe_buffer
-      @escape_safe_buffer = flag.is_a?(EscapeSafeBuffer)
-      @escape = @escape_safe_buffer ? flag.value : flag
-      compile(exp)
-    ensure
-      @escape, @escape_safe_buffer = old_escape, old_escape_safe_buffer
-    end
-
-    # The same as Haml::AttributeBuilder.build_attributes
-    def on_static(value)
-      [:static,
-       if @escape == :once
-         escape_once(value)
-       elsif @escape
-         escape(value)
-       else
-         value
-       end
-      ]
-    end
-
-    # The same as Haml::AttributeBuilder.build_attributes
-    def on_dynamic(value)
-      [:dynamic,
-       if @escape == :once
-         escape_once_code(value)
-       elsif @escape
-         escape_code(value)
-       else
-         "(#{value}).to_s"
-       end
-      ]
-    end
-
-    private
-
-    def escape_once(value)
-      if @escape_safe_buffer
-        ::Haml::Helpers.escape_once_without_haml_xss(value)
-      else
-        ::Haml::Helpers.escape_once(value)
-      end
-    end
-
-    def escape(value)
-      if @escape_safe_buffer
-        ::Haml::Helpers.html_escape_without_haml_xss(value)
-      else
-        ::Haml::Helpers.html_escape(value)
-      end
-    end
-
-    def escape_once_code(value)
-      "::Haml::Helpers.escape_once#{('_without_haml_xss' if @escape_safe_buffer)}((#{value}))"
-    end
-
-    def escape_code(value)
-      "::Haml::Helpers.html_escape#{('_without_haml_xss' if @escape_safe_buffer)}((#{value}))"
+      @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/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)
+        compile_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