haml 5.0.4 → 6.0.0

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

@@ -1,5 +1,9 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
+
+require 'ripper'
 require 'strscan'
+require 'haml/error'
+require 'haml/util'
 
 module Haml
   class Parser
@@ -60,7 +64,7 @@ module Haml
       SILENT_SCRIPT,
       ESCAPE,
       FILTER
-    ]
+    ].freeze
 
     # The value of the character that designates that a line is part
     # of a multiline string.
@@ -74,8 +78,8 @@ module Haml
     #
     BLOCK_WITH_SPACES = /do\s*\|\s*[^\|]*\s+\|\z/
 
-    MID_BLOCK_KEYWORDS = %w[else elsif rescue ensure end when]
-    START_BLOCK_KEYWORDS = %w[if begin case unless]
+    MID_BLOCK_KEYWORDS = %w[else elsif rescue ensure end when].freeze
+    START_BLOCK_KEYWORDS = %w[if begin case unless].freeze
     # Try to parse assignments to block starters as best as possible
     START_BLOCK_KEYWORD_REGEX = /(?:\w+(?:,\s*\w+)*\s*=\s*)?(#{START_BLOCK_KEYWORDS.join('|')})/
     BLOCK_KEYWORD_REGEX = /^-?\s*(?:(#{MID_BLOCK_KEYWORDS.join('|')})|#{START_BLOCK_KEYWORD_REGEX.source})\b/
@@ -89,16 +93,27 @@ module Haml
     ID_KEY    = 'id'.freeze
     CLASS_KEY = 'class'.freeze
 
+    # Used for scanning old attributes, substituting the first '{'
+    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 = []
       @template_index     = 0
       @template_tabs      = 0
+      # When used in Haml::Engine, which gives options[:generator] to every filter
+      # in the engine, including Haml::Parser, we don't want to throw exceptions.
+      # However, when Haml::Parser is used as a library, we want to throw exceptions.
+      @raise_error = !options.key?(:generator)
     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
@@ -147,7 +162,8 @@ module Haml
       @root
     rescue Haml::Error => e
       e.backtrace.unshift "#{@options.filename}:#{(e.line ? e.line + 1 : @line.index + 1) + @options.line - 1}"
-      raise
+      raise if @raise_error
+      error_with_lineno(e)
     end
 
     def compute_tabs(line)
@@ -177,8 +193,18 @@ module Haml
 
     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
+      SyntaxError.new(error.message, line)
+    end
+
     # @private
-    class Line < Struct.new(:whitespace, :text, :full, :index, :parser, :eod)
+    Line = Struct.new(:whitespace, :text, :full, :index, :parser, :eod) do
       alias_method :eod?, :eod
 
       # @private
@@ -194,28 +220,29 @@ module Haml
     end
 
     # @private
-    class ParseNode < Struct.new(:type, :line, :value, :parent, :children)
+    ParseNode = Struct.new(:type, :line, :value, :parent, :children) do
       def initialize(*args)
         super
         self.children ||= []
       end
 
       def inspect
-        %Q[(#{type} #{value.inspect}#{children.each_with_object('') {|c, s| s << "\n#{c.inspect.gsub!(/^/, '  ')}"}})]
+        %Q[(#{type} #{value.inspect}#{children.each_with_object(''.dup) {|c, s| s << "\n#{c.inspect.gsub!(/^/, '  ')}"}})].dup
       end
     end
 
     # @param [String] new - Hash literal including dynamic values.
     # @param [String] old - Hash literal including dynamic values or Ruby literal of multiple Hashes which MUST be interpreted as method's last arguments.
-    class DynamicAttributes < Struct.new(:new, :old)
+    DynamicAttributes = Struct.new(:new, :old) do
+      undef :old=
       def old=(value)
         unless value =~ /\A{.*}\z/m
           raise ArgumentError.new('Old attributes must start with "{" and end with "}"')
         end
-        super
+        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
@@ -287,7 +314,7 @@ module Haml
     end
 
     def block_keyword(text)
-      return unless keyword = text.scan(BLOCK_KEYWORD_REGEX)[0]
+      return unless (keyword = text.scan(BLOCK_KEYWORD_REGEX)[0])
       keyword[0] || keyword[1]
     end
 
@@ -301,13 +328,13 @@ module Haml
         raise SyntaxError.new(Error.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 if escape_html.nil?
-      line.text = unescape_interpolation(line.text, escape_html)
-      script(line, false)
+      escape_html = @options.escape_html && @options.mime_type != 'text/plain' if escape_html.nil?
+      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)
@@ -394,7 +421,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 '&', '!'
@@ -402,19 +430,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
@@ -425,13 +455,13 @@ 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
 
@@ -453,7 +483,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
@@ -475,9 +506,9 @@ 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
@@ -534,7 +565,7 @@ module Haml
 
       # Post-process case statements to normalize the nesting of "when" clauses
       return unless node.value[:keyword] == "case"
-      return unless first = node.children.first
+      return unless (first = node.children.first)
       return unless first.type == :silent_script && first.value[:keyword] == "when"
       return if first.children.empty?
       # If the case node has a "when" child with children, it's the
@@ -546,7 +577,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,
@@ -570,8 +601,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
@@ -583,9 +614,9 @@ module Haml
       scanner = StringScanner.new(text)
       scanner.scan(/\s+/)
       until scanner.eos?
-        return unless key = scanner.scan(LITERAL_VALUE_REGEX)
+        return unless (key = scanner.scan(LITERAL_VALUE_REGEX))
         return unless scanner.scan(/\s*=>\s*/)
-        return unless value = scanner.scan(LITERAL_VALUE_REGEX)
+        return unless (value = scanner.scan(LITERAL_VALUE_REGEX))
         return unless scanner.scan(/\s*(?:,|$)\s*/)
         attributes[eval(key).to_s] = eval(value).to_s
       end
@@ -649,13 +680,18 @@ module Haml
     # @return [String] rest
     # @return [Integer] last_line
     def parse_old_attributes(text)
-      text = text.dup
       last_line = @line.index + 1
 
       begin
-        attributes_hash, rest = balance(text, ?{, ?})
+        # Old attributes often look like a valid Hash literal, but it sometimes allow code like
+        # `{ hash, foo: bar }`, which is compiled to `_hamlout.attributes({}, nil, hash, foo: bar)`.
+        #
+        # To scan such code correctly, this scans `a( hash, foo: bar }` instead, stops when there is
+        # 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 text.strip[-1] == ?, && e.message == Error.message(:unbalanced_brackets)
+        if e.message == Error.message(:unbalanced_brackets) && !@template.empty?
           text << "\n#{@next_line.text}"
           last_line += 1
           next_line
@@ -698,12 +734,12 @@ module Haml
       end
 
       static_attributes = {}
-      dynamic_attributes = "{"
+      dynamic_attributes = "{".dup
       attributes.each do |name, (type, val)|
         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 << "}"
@@ -713,7 +749,7 @@ module Haml
     end
 
     def parse_new_attribute(scanner)
-      unless name = scanner.scan(/[-:\w]+/)
+      unless (name = scanner.scan(/[-:\w]+/))
         return if scanner.scan(/\)/)
         return false
       end
@@ -722,8 +758,8 @@ module Haml
       return name, [:static, true] unless scanner.scan(/=/) #/end
 
       scanner.scan(/\s*/)
-      unless quote = scanner.scan(/["']/)
-        return false unless var = scanner.scan(/(@@?|\$)?\w+/)
+      unless (quote = scanner.scan(/["']/))
+        return false unless (var = scanner.scan(/(@@?|\$)?\w+/))
         return name, [:dynamic, var]
       end
 
@@ -738,7 +774,7 @@ module Haml
 
       return name, [:static, content.first[1]] if content.size == 1
       return name, [:dynamic,
-        %!"#{content.each_with_object('') {|(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
@@ -809,6 +845,25 @@ module Haml
       Haml::Util.balance(*args) or raise(SyntaxError.new(Error.message(:unbalanced_brackets)))
     end
 
+    # Unlike #balance, this balances Ripper tokens to balance something like `{ a: "}" }` correctly.
+    def balance_tokens(buf, start, finish, count: 0)
+      text = ''.dup
+      Ripper.lex(buf).each do |_, token, str|
+        text << str
+        case token
+        when start
+          count += 1
+        when finish
+          count -= 1
+        end
+
+        if count == 0
+          return text, buf.sub(text, '')
+        end
+      end
+      raise SyntaxError.new(Error.message(:unbalanced_brackets))
+    end
+
     def block_opened?
       @next_line.tabs > @line.tabs
     end
@@ -822,5 +877,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