haml 5.2.2 → 6.3.0

data/lib/haml/filters/tilt_base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'tilt'
+
+module Haml
+  class Filters
+    class TiltBase < Base
+      def self.render(name, source, indent_width: 0)
+        text = ::Tilt["t.#{name}"].new { source }.render
+        return text if indent_width == 0
+        if text.frozen?
+          text.gsub(/^/, ' ' * indent_width)
+        else
+          text.gsub!(/^/, ' ' * indent_width)
+        end
+      end
+
+      def explicit_require?(needed_registration)
+        Gem::Version.new(Tilt::VERSION) >= Gem::Version.new('2.0.0') &&
+          !Tilt.registered?(needed_registration)
+      end
+
+      private
+
+      # TODO: support interpolation
+      def precompiled_with_tilt(node, name)
+        src = ::Tilt["t.#{name}"].new { node.value[:text] }.send(:precompiled, {}).first
+        [:dynamic, src]
+      end
+
+      def compile_with_tilt(node, name, indent_width: 0)
+        if ::Haml::Util.contains_interpolation?(node.value[:text])
+          dynamic_compile(node, name, indent_width: indent_width)
+        else
+          static_compile(node, name, indent_width: indent_width)
+        end
+      end
+
+      def static_compile(node, name, indent_width: 0)
+        temple = [:multi, [:static, TiltBase.render(name, node.value[:text], indent_width: indent_width)]]
+        node.value[:text].split("\n").size.times do
+          temple << [:newline]
+        end
+        temple
+      end
+
+      def dynamic_compile(node, name, indent_width: 0)
+        # original: Haml::Filters#compile
+        text = ::Haml::Util.unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
+          escapes = $1.size
+          next s if escapes % 2 == 0
+          "#{'\\' * (escapes - 1)}\n"
+        end
+        text.prepend("\n").sub!(/\n"\z/, '"')
+
+        [:dynamic, "::Haml::Filters::TiltBase.render('#{name}', #{text}, indent_width: #{indent_width})"]
+      end
+    end
+  end
+end

data/lib/haml/filters.rb

@@ -1,399 +1,75 @@
 # frozen_string_literal: true
-
-require "tilt"
+require 'haml/filters/base'
+require 'haml/filters/text_base'
+require 'haml/filters/tilt_base'
+require 'haml/filters/coffee'
+require 'haml/filters/css'
+require 'haml/filters/erb'
+require 'haml/filters/escaped'
+require 'haml/filters/javascript'
+require 'haml/filters/less'
+require 'haml/filters/markdown'
+require 'haml/filters/plain'
+require 'haml/filters/preserve'
+require 'haml/filters/ruby'
+require 'haml/filters/sass'
+require 'haml/filters/scss'
+require 'haml/filters/cdata'
 
 module Haml
-  # The module containing the default Haml filters,
-  # as well as the base module, {Haml::Filters::Base}.
-  #
-  # @see Haml::Filters::Base
-  module Filters
-
-    extend self
-
-    # @return [{String => Haml::Filters::Base}] a hash mapping filter names to
-    #   classes.
-    attr_reader :defined
-    @defined = {}
-
-    # Loads an external template engine from
-    # [Tilt](https://github.com/rtomayko/tilt) as a filter. This method is used
-    # internally by Haml to set up filters for Sass, SCSS, Less, Coffeescript,
-    # and others. It's left public to make it easy for developers to add their
-    # own Tilt-based filters if they choose.
-    #
-    # @return [Module] The generated filter.
-    # @param [Hash] options Options for generating the filter module.
-    # @option options [Boolean] :precompiled Whether the filter should be
-    #   precompiled. Erb, Nokogiri and Builder use this, for example.
-    # @option options [Class] :template_class The Tilt template class to use,
-    #   in the event it can't be inferred from an extension.
-    # @option options [String] :extension The extension associated with the
-    #   content, for example "markdown". This lets Tilt choose the preferred
-    #   engine when there are more than one.
-    # @option options [String,Array<String>] :alias Any aliases for the filter.
-    #   For example, :coffee is also available as :coffeescript.
-    # @option options [String] :extend The name of a module to extend when
-    #   defining the filter. Defaults to "Plain". This allows filters such as
-    #   Coffee to "inherit" from Javascript, wrapping its output in script tags.
-    # @since 4.0
-    def register_tilt_filter(name, options = {})
-      if constants.map(&:to_s).include?(name.to_s)
-        raise "#{name} filter already defined"
-      end
-
-      filter = const_set(name, Module.new)
-      filter.extend const_get(options[:extend] || "Plain")
-      filter.extend TiltFilter
-      filter.extend PrecompiledTiltFilter if options.has_key? :precompiled
-
-      if options.has_key? :template_class
-        filter.template_class = options[:template_class]
-      else
-        filter.tilt_extension = options.fetch(:extension) { name.downcase }
-      end
-
-      # All ":coffeescript" as alias for ":coffee", etc.
-      if options.has_key?(:alias)
-        [options[:alias]].flatten.each {|x| Filters.defined[x.to_s] = filter}
-      end
-      filter
-    end
-
-    # Removes a filter from Haml. If the filter was removed, it returns
-    # 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
-    # @since 4.0
-    def remove_filter(name)
-      defined.delete name.to_s.downcase
-      if constants.map(&:to_s).include?(name.to_s)
-        remove_const name.to_sym
-      end
-    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)
-        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::Compiler} instance to compile
-      # the string to Ruby code that will be executed in the context of the
-      # active Haml template.
-      #
-      # Warning: the {Haml::Compiler} 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 compiler [Haml::Compiler] The compiler 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(compiler, text)
-        filter = self
-        compiler.instance_eval do
-          if contains_interpolation?(text)
-            return if options[:suppress_eval]
-
-            escape = options[:escape_filter_interpolations]
-            # `escape_filter_interpolations` defaults to `escape_html` if unset.
-            escape = options[:escape_html] if escape.nil?
-
-            text = unescape_interpolation(text, escape).gsub(/(\\+)n/) do |s|
-              escapes = $1.size
-              next s if escapes % 2 == 0
-              "#{'\\' * (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
-            # a line that doesn't show up in the source, namely the
-            # 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\"")}]
-            push_script <<RUBY.rstrip, :escape_html => false
-find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _hamlout.options))
-RUBY
-            return
-          end
-
-          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text.to_s, compiler.options), compiler.options[:preserve])
-          push_text("#{rendered.rstrip}\n")
-        end
-      end
-    end
-
-    # 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)
-        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
-        if options[:format] == :html5
-          type = ''
-        else
-          type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
-        end
-
-        text = text.rstrip
-        text.gsub!("\n", "\n#{indent}")
+  class Filters
+    @registered = {}
 
-        %!<script#{type}>\n#{"  //<![CDATA[\n" if options[:cdata]}#{indent}#{text}\n#{"  //]]>\n" if options[:cdata]}</script>!
-      end
-    end
-
-    # Surrounds the filtered text with `<style>` and CDATA tags. Useful for
-    # including inline CSS.
-    module Css
-      include Base
-
-      # @see Base#render_with_options
-      def render_with_options(text, options)
-        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
-        if options[:format] == :html5
-          type = ''
-        else
-          type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
-        end
-
-        text = text.rstrip
-        text.gsub!("\n", "\n#{indent}")
-
-        %(<style#{type}>\n#{"  /*<![CDATA[*/\n" if options[:cdata]}#{indent}#{text}\n#{"  /*]]>*/\n" if options[:cdata]}</style>)
-      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. Creates an IO
-    # object named `haml_io`, anything written to it is output into the Haml
-    # document. In previous version this filter redirected any output to `$stdout`
-    # to the Haml document, this was not threadsafe and has been removed, you
-    # should use `haml_io` instead.
-    #
-    # Not available if the {file: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
-      require 'stringio'
+    class << self
+      attr_reader :registered
 
-      # @see Base#compile
-      def compile(compiler, text)
-        return if compiler.options[:suppress_eval]
-        compiler.instance_eval do
-          push_silent "#{<<-FIRST.tr("\n", ';')}#{text}#{<<-LAST.tr("\n", ';')}"
-            begin
-              haml_io = StringIO.new(_hamlout.buffer, 'a')
-          FIRST
-            ensure
-              haml_io.close
-              haml_io = nil
-            end
-          LAST
+      def remove_filter(name)
+        registered.delete(name.to_s.downcase.to_sym)
+        if constants.map(&:to_s).include?(name.to_s)
+          remove_const name.to_sym
         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
+      private
 
-      # @see Base#render
-      def render(text)
-        Haml::Helpers.preserve text
+      def register(name, compiler)
+        registered[name] = compiler
       end
     end
 
-    # @private
-    module TiltFilter
-      extend self
-      attr_accessor :tilt_extension, :options
-      attr_writer :template_class
-
-      def template_class
-        (@template_class if defined? @template_class) or begin
-          @template_class = Tilt["t.#{tilt_extension}"] or
-            raise Error.new(Error.message(:cant_run_filter, tilt_extension))
-        rescue LoadError => e
-          dep = e.message.split('--').last.strip
-          raise Error.new(Error.message(:gem_install_filter_deps, tilt_extension, dep))
-        end
-      end
-
-      def self.extended(base)
-        base.options = {}
-        # There's a bug in 1.9.2 where the same parse tree cannot be shared
-        # across several singleton classes -- this bug is fixed in 1.9.3.
-        # We work around this by using a string eval instead of a block eval
-        # so that a new parse tree is created for each singleton class.
-        base.instance_eval %Q{
-          include Base
-
-          def render_with_options(text, compiler_options)
-            text = template_class.new(nil, 1, options) {text}.render
-            super(text, compiler_options)
-          end
-        }
-      end
+    register :coffee,       Coffee
+    register :coffeescript, CoffeeScript
+    register :css,          Css
+    register :erb,          Erb
+    register :escaped,      Escaped
+    register :javascript,   Javascript
+    register :less,         Less
+    register :markdown,     Markdown
+    register :plain,        Plain
+    register :preserve,     Preserve
+    register :ruby,         Ruby
+    register :sass,         Sass
+    register :scss,         Scss
+    register :cdata,        Cdata
+
+    def initialize(options = {})
+      @options = options
+      @compilers = {}
     end
 
-    # @private
-    module PrecompiledTiltFilter
-      def precompiled(text)
-        template_class.new(nil, 1, options) { text }.send(:precompiled, {}).first
-      end
-
-      def compile(compiler, text)
-        return if compiler.options[:suppress_eval]
-        compiler.send(:push_script, precompiled(text))
-      end
+    def compile(node)
+      node.value[:text] ||= ''
+      find_compiler(node).compile(node)
     end
 
-    # @!parse module Sass; end
-    register_tilt_filter "Sass", :extend => "Css"
-
-    # @!parse module Scss; end
-    register_tilt_filter "Scss", :extend => "Css"
-
-    # @!parse module Less; end
-    register_tilt_filter "Less", :extend => "Css"
-
-    # @!parse module Markdown; end
-    register_tilt_filter "Markdown"
-
-    # @!parse module Erb; end
-    register_tilt_filter "Erb", :precompiled => true
+    private
 
-    # @!parse module Coffee; end
-    register_tilt_filter "Coffee", :alias => "coffeescript", :extend => "Javascript"
+    def find_compiler(node)
+      name = node.value[:name].to_sym
+      compiler = Filters.registered[name]
+      raise FilterNotFound.new("FilterCompiler for '#{name}' was not found", node.line.to_i - 1) unless compiler
 
-    # Parses the filtered text with ERB.
-    # Not available if the {file: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
-      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
+      @compilers[name] ||= compiler.new(@options)
     end
   end
 end
-
-# These filters have been demoted to Haml Contrib but are still included by
-# default in Haml 4.0. Still, we rescue from load error if for some reason
-# haml-contrib is not installed.
-begin
-  require "haml/filters/maruku"
-  require "haml/filters/textile"
-rescue LoadError
-end

data/lib/haml/force_escape.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'haml/escape'
+
+module Haml
+  # This module allows Temple::Filter to dispatch :fescape on `#compile`.
+  module FescapeDispathcer
+    def on_fescape(flag, exp)
+      [:fescape, flag, compile(exp)]
+    end
+  end
+  ::Temple::Filter.include FescapeDispathcer
+
+  # Unlike Haml::Escape, this escapes value even if it's html_safe.
+  class ForceEscape < Escape
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] || "::Haml::Util.escape_html((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+
+    alias_method :on_fescape, :on_escape
+
+    # ForceEscape doesn't touch :escape expression.
+    # This method is not used if it's inserted after Haml::Escape.
+    def on_escape(flag, exp)
+      [:escape, flag, compile(exp)]
+    end
+  end
+end