hamlit 2.11.1 → 2.14.1

data/lib/hamlit/parser/haml_parser.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
+require 'ripper'
 require 'strscan'
-require 'hamlit/parser/haml_util'
-require 'hamlit/parser/haml_error'
 
 module Hamlit
   class HamlParser
-    include ::Hamlit::HamlUtil
+    include Hamlit::HamlUtil
 
     attr_reader :root
 
@@ -61,7 +62,7 @@ module Hamlit
       SILENT_SCRIPT,
       ESCAPE,
       FILTER
-    ]
+    ].freeze
 
     # The value of the character that designates that a line is part
     # of a multiline string.
@@ -75,8 +76,8 @@ module Hamlit
     #
     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/
@@ -90,14 +91,19 @@ module Hamlit
     ID_KEY    = 'id'.freeze
     CLASS_KEY = 'class'.freeze
 
-    def initialize(template, options)
-      @options            = options
+    # Used for scanning old attributes, substituting the first '{'
+    METHOD_CALL_PREFIX = 'a('
+
+    def initialize(options)
+      @options = HamlOptions.wrap(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
+    end
 
+    def call(template)
       match = template.rstrip.scan(/(([ \t]+)?(.*?))(?:\Z|\r\n|\r|\n)/m)
       # discard the last match which is always blank
       match.pop
@@ -106,16 +112,14 @@ module Hamlit
       end
       # Append special end-of-document marker
       @template << Line.new(nil, '-#', '-#', @template.size, self, true)
-    end
 
-    def parse
       @root = @parent = ParseNode.new(:root)
       @flat = false
       @filter_buffer = nil
       @indentation = nil
       @line = next_line
 
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:indenting_at_start), @line.index) if @line.tabs != 0
+      raise HamlSyntaxError.new(HamlError.message(:indenting_at_start), @line.index) if @line.tabs != 0
 
       loop do
         next_line
@@ -138,7 +142,7 @@ module Hamlit
         end
 
         if !flat? && @next_line.tabs - @line.tabs > 1
-          raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:deeper_indenting, @next_line.tabs - @line.tabs), @next_line.index)
+          raise HamlSyntaxError.new(HamlError.message(:deeper_indenting, @next_line.tabs - @line.tabs), @next_line.index)
         end
 
         @line = @next_line
@@ -146,7 +150,7 @@ module Hamlit
       # Close all the open tags
       close until @parent.type == :root
       @root
-    rescue ::Hamlit::HamlError => e
+    rescue Hamlit::HamlError => e
       e.backtrace.unshift "#{@options.filename}:#{(e.line ? e.line + 1 : @line.index + 1) + @options.line - 1}"
       raise
     end
@@ -158,7 +162,7 @@ module Hamlit
         @indentation = line.whitespace
 
         if @indentation.include?(?\s) && @indentation.include?(?\t)
-          raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:cant_use_tabs_and_spaces), line.index)
+          raise HamlSyntaxError.new(HamlError.message(:cant_use_tabs_and_spaces), line.index)
         end
 
         @flat_spaces = @indentation * (@template_tabs+1) if flat?
@@ -169,17 +173,17 @@ module Hamlit
       return tabs if line.whitespace == @indentation * tabs
       return @template_tabs + 1 if flat? && line.whitespace =~ /^#{@flat_spaces}/
 
-      message = ::Hamlit::HamlError.message(:inconsistent_indentation,
+      message = HamlError.message(:inconsistent_indentation,
         human_indentation(line.whitespace),
         human_indentation(@indentation)
       )
-      raise ::Hamlit::HamlSyntaxError.new(message, line.index)
+      raise HamlSyntaxError.new(message, line.index)
     end
 
     private
 
     # @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
@@ -195,14 +199,39 @@ module Hamlit
     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.
+    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
+        self[:old] = value
+      end
+
+      # This will be a literal for Hamlit::HamlBuffer#attributes's last argument, `attributes_hashes`.
+      def to_literal
+        [new, stripped_old].compact.join(', ')
+      end
+
+      private
+
+      # For `%foo{ { foo: 1 }, bar: 2 }`, :old is "{ { foo: 1 }, bar: 2 }" and this method returns " { foo: 1 }, bar: 2 " for last argument.
+      def stripped_old
+        return nil if old.nil?
+        old.sub!(/\A{/, '').sub!(/}\z/m, '')
       end
     end
 
@@ -264,7 +293,7 @@ module Hamlit
     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
 
@@ -275,20 +304,20 @@ module Hamlit
 
     def plain(line, escape_html = nil)
       if block_opened?
-        raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_plain), @next_line.index)
+        raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_plain), @next_line.index)
       end
 
       unless 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 = ::Hamlit::HamlUtil.unescape_interpolation(line.text)
+      escape_html = @options.escape_html && @options.mime_type != 'text/plain' if escape_html.nil?
+      line.text = 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)
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:no_ruby_code, '=')) if line.text.empty?
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, '=')) if line.text.empty?
       line = handle_ruby_multiline(line)
       escape_html = @options.escape_html if escape_html.nil?
 
@@ -300,12 +329,12 @@ module Hamlit
     end
 
     def flat_script(line, escape_html = nil)
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:no_ruby_code, '~')) if line.text.empty?
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, '~')) if line.text.empty?
       script(line, escape_html, :preserve)
     end
 
     def silent_script(line)
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:no_end), line.index) if line.text[1..-1].strip == 'end'
+      raise HamlSyntaxError.new(HamlError.message(:no_end), line.index) if line.text[1..-1].strip == 'end'
 
       line = handle_ruby_multiline(line)
       keyword = block_keyword(line.text)
@@ -314,7 +343,7 @@ module Hamlit
 
       if ["else", "elsif", "when"].include?(keyword)
         if @script_level_stack.empty?
-          raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:missing_if, keyword), @line.index)
+          raise Hamlit::HamlSyntaxError.new(HamlError.message(:missing_if, keyword), @line.index)
         end
 
         if keyword == 'when' and !@script_level_stack.last[2]
@@ -325,8 +354,8 @@ module Hamlit
         end
 
         if @script_level_stack.last[1] != @line.tabs
-          message = ::Hamlit::HamlError.message(:bad_script_indent, keyword, @script_level_stack.last[1], @line.tabs)
-          raise ::Hamlit::HamlSyntaxError.new(message, @line.index)
+          message = HamlError.message(:bad_script_indent, keyword, @script_level_stack.last[1], @line.tabs)
+          raise Hamlit::HamlSyntaxError.new(message, @line.index)
         end
       end
 
@@ -363,7 +392,6 @@ module Hamlit
 
       preserve_tag = @options.preserve.include?(tag_name)
       nuke_inner_whitespace ||= preserve_tag
-      preserve_tag = false if @options.ugly
       escape_html = (action == '&' || (action != '!' && @options.escape_html))
 
       case action
@@ -372,7 +400,7 @@ module Hamlit
       when '='
         parse = true
         if value[0] == ?=
-          value = ::Hamlit::HamlUtil.unescape_interpolation(value[1..-1].strip)
+          value = unescape_interpolation(value[1..-1].strip)
           escape_interpolation = true if escape_html
           escape_html = false
         end
@@ -381,50 +409,47 @@ module Hamlit
           parse = true
           preserve_script = (value[0] == ?~)
           if value[1] == ?=
-            value = ::Hamlit::HamlUtil.unescape_interpolation(value[2..-1].strip)
+            value = 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 = ::Hamlit::HamlUtil.unescape_interpolation(value)
+          value = unescape_interpolation(value)
           escape_interpolation = true if escape_html
           parse = true
           escape_html = false
         end
       else
         if contains_interpolation?(value)
-          value = ::Hamlit::HamlUtil.unescape_interpolation(value)
-          escape_interpolation = true if escape_html
+          value = unescape_interpolation(value, escape_html)
           parse = true
           escape_html = false
         end
       end
 
-      attributes = ::Hamlit::HamlParser.parse_class_and_id(attributes)
-      attributes_list = []
+      attributes = HamlParser.parse_class_and_id(attributes)
+      dynamic_attributes = DynamicAttributes.new
 
       if attributes_hashes[:new]
         static_attributes, attributes_hash = attributes_hashes[:new]
-        ::Hamlit::HamlBuffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hash
+        HamlAttributeBuilder.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])
-        ::Hamlit::HamlBuffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hashes[:old] unless static_attributes || @options.suppress_eval
+        HamlAttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
+        dynamic_attributes.old = attributes_hashes[:old] unless static_attributes || @options.suppress_eval
       end
 
-      attributes_list.compact!
-
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
+      raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
+      raise HamlSyntaxError.new(HamlError.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
+      raise HamlSyntaxError.new(HamlError.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
 
       if block_opened? && !value.empty? && !is_ruby_multiline?(value)
-        raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_line, tag_name), @next_line.index)
+        raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_line, tag_name), @next_line.index)
       end
 
       self_closing ||= !!(!block_opened? && value.empty? && @options.autoclose.any? {|t| t === tag_name})
@@ -433,7 +458,7 @@ module Hamlit
       line = handle_ruby_multiline(line) if parse
 
       ParseNode.new(:tag, line.index + 1, :name => tag_name, :attributes => attributes,
-        :attributes_hashes => attributes_list, :self_closing => self_closing,
+        :dynamic_attributes => dynamic_attributes, :self_closing => self_closing,
         :nuke_inner_whitespace => nuke_inner_whitespace,
         :nuke_outer_whitespace => nuke_outer_whitespace, :object_ref => object_ref,
         :escape_html => escape_html, :preserve_tag => preserve_tag,
@@ -462,13 +487,13 @@ module Hamlit
 
       if contains_interpolation?(text)
         parse = true
-        text = slow_unescape_interpolation(text)
+        text = unescape_interpolation(text)
       else
         parse = false
       end
 
       if block_opened? && !text.empty?
-        raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_content), @next_line.index)
+        raise HamlSyntaxError.new(Hamlit::HamlError.message(:illegal_nesting_content), @next_line.index)
       end
 
       ParseNode.new(:comment, @line.index + 1, :conditional => conditional, :text => text, :revealed => revealed, :parse => parse)
@@ -476,13 +501,13 @@ module Hamlit
 
     # Renders an XHTML doctype or XML shebang.
     def doctype(text)
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_header), @next_line.index) if block_opened?
+      raise HamlSyntaxError.new(HamlError.message(:illegal_nesting_header), @next_line.index) if block_opened?
       version, type, encoding = text[3..-1].strip.downcase.scan(DOCTYPE_REGEX)[0]
       ParseNode.new(:doctype, @line.index + 1, :version => version, :type => type, :encoding => encoding)
     end
 
     def filter(name)
-      raise ::Hamlit::HamlError.new(::Hamlit::HamlError.message(:invalid_filter_name, name)) unless name =~ /^\w+$/
+      raise HamlError.new(HamlError.message(:invalid_filter_name, name)) unless name =~ /^\w+$/
 
       if filter_opened?
         @flat = true
@@ -519,7 +544,7 @@ module Hamlit
 
       # 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
@@ -531,7 +556,7 @@ module Hamlit
 
     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 {Hamlit::HamlHelpers}.
     #
     # Iterates through the classes and ids supplied through `.`
     # and `#` syntax, and returns a hash with them as attributes,
@@ -540,7 +565,7 @@ module Hamlit
       attributes = {}
       return attributes if list.empty?
 
-      list.scan(/([#.])([-:_a-zA-Z0-9]+)/) do |type, property|
+      list.scan(/([#.])([-:_a-zA-Z0-9\@]+)/) do |type, property|
         case type
         when '.'
           if attributes[CLASS_KEY]
@@ -555,16 +580,22 @@ module Hamlit
       attributes
     end
 
+    # This method doesn't use Hamlit::HamlAttributeParser because currently it depends on Ripper and Rubinius doesn't provide it.
+    # Ideally this logic should be placed in Hamlit::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
     def parse_static_hash(text)
       attributes = {}
       return attributes if text.empty?
 
+      text = text[1...-1] # strip brackets
       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
@@ -573,13 +604,13 @@ module Hamlit
 
     # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value
     def parse_tag(text)
-      match = text.scan(/%([-:\w]+)([-:\w.#]*)(.+)?/)[0]
-      raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:invalid_tag, text)) unless match
+      match = text.scan(/%([-:\w]+)([-:\w.#\@]*)(.+)?/)[0]
+      raise HamlSyntaxError.new(HamlError.message(:invalid_tag, text)) unless match
 
       tag_name, attributes, rest = match
 
       if !attributes.empty? && (attributes =~ /[.#](\.|#|\z)/)
-        raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_element))
+        raise HamlSyntaxError.new(HamlError.message(:illegal_element))
       end
 
       new_attributes_hash = old_attributes_hash = last_line = nil
@@ -624,14 +655,22 @@ module Hamlit
        nuke_inner_whitespace, action, value, last_line || @line.index + 1]
     end
 
+    # @return [String] attributes_hash - Hash literal starting with `{` and ending with `}`
+    # @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, ?{, ?})
-      rescue ::Hamlit::HamlSyntaxError => e
-        if text.strip[-1] == ?, && e.message == ::Hamlit::HamlError.message(:unbalanced_brackets)
+        # 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 HamlSyntaxError => e
+        if e.message == HamlError.message(:unbalanced_brackets) && !@template.empty?
           text << "\n#{@next_line.text}"
           last_line += 1
           next_line
@@ -641,10 +680,12 @@ module Hamlit
         raise e
       end
 
-      attributes_hash = attributes_hash[1...-1] if attributes_hash
       return attributes_hash, rest, last_line
     end
 
+    # @return [Array<Hash,String,nil>] - [static_attributes (Hash), dynamic_attributes (nil or String starting with `{` and ending with `}`)]
+    # @return [String] rest
+    # @return [Integer] last_line
     def parse_new_attributes(text)
       scanner = StringScanner.new(text)
       last_line = @line.index + 1
@@ -656,9 +697,9 @@ module Hamlit
         break if name.nil?
 
         if name == false
-          scanned = ::Hamlit::HamlUtil.balance(text, ?(, ?))
+          scanned = Hamlit::HamlUtil.balance(text, ?(, ?))
           text = scanned ? scanned.first : text
-          raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:invalid_attribute_list, text.inspect), last_line - 1)
+          raise Hamlit::HamlSyntaxError.new(HamlError.message(:invalid_attribute_list, text.inspect), last_line - 1)
         end
         attributes[name] = value
         scanner.scan(/\s*/)
@@ -672,7 +713,7 @@ module Hamlit
       end
 
       static_attributes = {}
-      dynamic_attributes = "{"
+      dynamic_attributes = "{".dup
       attributes.each do |name, (type, val)|
         if type == :static
           static_attributes[name] = val
@@ -687,7 +728,7 @@ module Hamlit
     end
 
     def parse_new_attribute(scanner)
-      unless name = scanner.scan(/[-:\w]+/)
+      unless (name = scanner.scan(/[-:\w]+/))
         return if scanner.scan(/\)/)
         return false
       end
@@ -696,8 +737,8 @@ module Hamlit
       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
 
@@ -712,7 +753,7 @@ module Hamlit
 
       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 ? inspect_obj(v)[1...-1] : "\#{#{v}}")}}"!]
     end
 
     def next_line
@@ -780,7 +821,26 @@ module Hamlit
     end
 
     def balance(*args)
-      ::Hamlit::HamlUtil.balance(*args) or raise(::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:unbalanced_brackets)))
+      Hamlit::HamlUtil.balance(*args) or raise(HamlSyntaxError.new(HamlError.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 HamlSyntaxError.new(HamlError.message(:unbalanced_brackets))
     end
 
     def block_opened?