haml 7.4.0 → 7.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a5bc7150b467bde9b4effce4bdc2b568a0b6a5644d7254b69a9de6ea6c807af
-  data.tar.gz: 172ab49b7e798cb37dd97ebfa037d27bd53dd5f8924f7111d9ac23c1de13d1ba
+  metadata.gz: 6436b78efc92438b9bd1a948dd0672bc8d3798c654fa2846d310386ef0552084
+  data.tar.gz: b8c2657b36c209e49c0e58c95470c45cc8213e30b1eb17458e0550db37bd616e
 SHA512:
-  metadata.gz: 4950862786ea326cfe7df4276bd75c99ce9e00cea7f9446b568880bb7a2999ad0b3dec92b4e0b0bfbd6b9b725a847f00ae6ff9f29ce1f0573efdf9ee0a283b91
-  data.tar.gz: 5ec5253e40f7dfd02fb4e6b537fe2c929590356d1e5130abe211c522e2d0856b7ceaaa1c951d8e7fa672bb4289f7a8284f3e3d384e6eec31552525546e31432a
+  metadata.gz: 0530e52beb2fd093dfeb7d55c107b92a84f91e854bd38ed2e919349fcb820043cd3dd6e328ba4b2b24aa1b64ee8fcf2faf4a36dae1da60cb1b0a2b6abef7f531
+  data.tar.gz: b5a94fe5203318f1eaefa08b86e418090b8d0ef48cb94afa219512d87b116f568833cdf42e8f24a0a5e540d47b4b98dfb8a04f9e372bfe99d912d01dc41c2c24

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Haml Changelog
 
+## 7.5.0
+
+* Compile a multi-line attribute hash statically https://github.com/haml/haml/pull/1222
+  * Errors from multi-line attributes will be reported on the tag's line instead of the expression that raised the error.
+
+## 7.4.1
+
+* Build the preserve regex once per tag list instead of per call https://github.com/haml/haml/pull/1220
+
 ## 7.4.0
 
 * `Haml::BOOLEAN_ATTRIBUTES` is changed from Array to Set https://github.com/haml/haml/pull/1216

data/lib/haml/attribute_compiler.rb

@@ -3,6 +3,7 @@ require 'set'
 require 'haml/attribute_builder'
 require 'haml/attribute_parser'
 require 'haml/ruby_expression'
+require 'haml/temple_line_counter'
 
 module Haml
   # The set of boolean attributes. You may add custom attributes to this constant.
@@ -24,12 +25,15 @@ module Haml
     def compile(node)
       hashes = []
       return runtime_compile(node) if node.value[:object_ref] != :nil
-      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
+      dynamic_attributes = node.value[:dynamic_attributes]
+      [dynamic_attributes.new, dynamic_attributes.old].compact.each do |attribute_str|
         hash = AttributeParser.parse(attribute_str)
         return runtime_compile(node) if hash.nil? || hash.any? { |_key, value| value.empty? }
         hashes << hash
       end
-      static_compile(node.value[:attributes], hashes)
+      temple = static_compile(node.value[:attributes], hashes)
+      restore_newlines!(temple, dynamic_attributes)
+      temple
     end
 
     private
@@ -67,6 +71,13 @@ module Haml
       temple
     end
 
+    # ChildrenCompiler counts on the tag spanning as many lines as its attribute source does.
+    def restore_newlines!(temple, dynamic_attributes)
+      missing = dynamic_attributes.newline_count
+      missing -= TempleLineCounter.count_lines(temple) if missing > 0
+      missing.times { temple << [:newline] }
+    end
+
     def compile_id!(temple, key, values)
       build_code = attribute_builder(:id, values)
       if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }

data/lib/haml/attribute_parser.rb

@@ -15,15 +15,11 @@ module Haml
     end
 
     # @return [Hash,nil] - keys and values are the attribute source as written, or nil if
-    #   the text is not a Hash literal whose keys are all static.
+    #   the text is not a Hash literal whose keys are all static, or if it holds a heredoc.
     def parse(text)
       exp = wrap_bracket(text)
-      # A multi-line hash is left to the runtime, which keeps the [:newline] bookkeeping of
-      # the compiled code correct. Compiling it statically is a separate optimization.
-      return if exp.include?("\n")
-
       node = hash_node(exp)
-      return if node.nil?
+      return if node.nil? || contains_heredoc?(exp, node)
 
       hash = {}
       node.elements.each do |element|
@@ -58,6 +54,12 @@ module Haml
       node if node.is_a?(Prism::HashNode)
     end
 
+    # A heredoc's body lies outside its node, so the value's slice would not be the value.
+    # Its opener always spells `<<`, which spares the tree walk for nearly every hash.
+    def contains_heredoc?(exp, node)
+      exp.include?('<<') && !node.breadth_first_search { |n| n.respond_to?(:heredoc?) && n.heredoc? }.nil?
+    end
+
     # The key as written between its delimiters, not unescaped: an escape has to reach the
     # attribute name as the source spelled it, like the `\0` of `{ "a\0b" => 1 }`.
     def static_key(key)

data/lib/haml/compiler/children_compiler.rb

@@ -40,9 +40,7 @@ module Haml
         when :script, :silent_script
           @lineno += 1
         when :tag
-          [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_hash|
-            @lineno += attribute_hash.count("\n")
-          end
+          @lineno += node.value[:dynamic_attributes].newline_count
           @lineno += 1 if node.children.empty? && node.value[:parse]
         end
 

data/lib/haml/compiler/script_compiler.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 require 'temple/static_analyzer'
+require 'haml/helpers'
+require 'haml/preserver'
 require 'haml/ruby_expression'
 require 'haml/string_splitter'
 
 module Haml
   class Compiler
     class ScriptCompiler
-      def self.find_and_preserve(input, tags)
-        tags = tags.map { |tag| Regexp.escape(tag) }.join('|')
-        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}>#{Haml::Helpers.preserve($3)}</#{$1}>"
-        end
+      def self.find_and_preserve(input, tags = ::Haml::Preserver::DEFAULT_TAGS)
+        ::Haml::Preserver.find_and_preserve(input, tags) { |content| ::Haml::Helpers.preserve(content) }
       end
 
       def initialize(identity, options)
@@ -69,7 +66,7 @@ module Haml
         if node.value[:escape_html]
           str = Haml::Util.escape_html(str)
         elsif node.value[:preserve]
-          str = ScriptCompiler.find_and_preserve(str, %w(textarea pre code))
+          str = ScriptCompiler.find_and_preserve(str)
         end
         [:multi, [:static, str], [:newline]]
       end
@@ -104,7 +101,7 @@ module Haml
       end
 
       def find_and_preserve(code)
-        %Q[::Haml::Compiler::ScriptCompiler.find_and_preserve(#{code}, %w(textarea pre code))]
+        %Q[::Haml::Compiler::ScriptCompiler.find_and_preserve(#{code})]
       end
 
       def escape_html(temple)

data/lib/haml/helpers.rb

@@ -3,7 +3,7 @@ module Haml
   module Helpers
     def self.preserve(input)
       s = input.to_s.chomp("\n")
-      s.gsub!(/\n/, '
')
+      s.gsub!("\n", '
')
       s.delete!("\r")
       s
     end

data/lib/haml/parser.rb

@@ -247,6 +247,12 @@ module Haml
         [new, stripped_old].compact.join(', ')
       end
 
+      # The lines a tag spans beyond its first because of these attributes, which is what
+      # the compiled tag has to span too for the line numbers after it to hold.
+      def newline_count
+        (new ? new.count("\n") : 0) + (old ? old.count("\n") : 0)
+      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.

data/lib/haml/preserver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Haml
+  # find_and_preserve, shared by compiled templates and RailsHelpers.
+  #
+  # @api private
+  module Preserver
+    DEFAULT_TAGS = %w[textarea pre code].freeze
+
+    def self.build_regex(tags)
+      # An empty entry would add an alternative matching `<>`.
+      pattern = tags.reject(&:empty?).map { |tag| Regexp.escape(tag) }.join('|')
+      /<(#{pattern})([^>]*)>(.*?)(<\/\1>)/im
+    end
+    private_class_method :build_regex
+
+    DEFAULT_REGEX = build_regex(DEFAULT_TAGS)
+    private_constant :DEFAULT_REGEX
+
+    # Past this many lists the merge below turns quadratic, so the cache starts over.
+    MAX_REGEXES = 64
+    private_constant :MAX_REGEXES
+
+    INITIAL_REGEXES = { DEFAULT_TAGS => DEFAULT_REGEX }.freeze
+    private_constant :INITIAL_REGEXES
+
+    @regexes = INITIAL_REGEXES
+
+    # The cache is replaced, never mutated, so a racing writer at worst rebuilds a regex.
+    def self.regex(tags)
+      return DEFAULT_REGEX if tags.equal?(DEFAULT_TAGS)
+
+      cache = @regexes
+      cache[tags] || begin
+        regex = build_regex(tags)
+        # Copied so a caller mutating its own list, or a String in it, cannot strand the entry.
+        key = tags.map { |tag| tag.dup.freeze }.freeze
+        cache = INITIAL_REGEXES if cache.size >= MAX_REGEXES
+        @regexes = cache.merge(key => regex).freeze
+        regex
+      end
+    end
+
+    def self.find_and_preserve(input, tags)
+      re = regex(tags)
+      input.to_s.gsub(re) do |s|
+        s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
+        name, attributes, content = $1, $2, $3
+        "<#{name}#{attributes}>#{yield(content)}</#{name}>"
+      end
+    end
+  end
+end

data/lib/haml/rails_helpers.rb

@@ -1,5 +1,6 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'haml/helpers'
+require 'haml/preserver'
 
 # There are only helpers that depend on ActionView internals.
 module Haml
@@ -7,21 +8,12 @@ module Haml
     include Helpers
     extend self
 
-    DEFAULT_PRESERVE_TAGS = %w[textarea pre code].freeze
+    DEFAULT_PRESERVE_TAGS = Preserver::DEFAULT_TAGS
 
     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
+      Preserver.find_and_preserve(input, tags) { |content| preserve(content) }
     end
 
     def preserve(input = nil, &block)

data/lib/haml/template.rb

@@ -16,5 +16,5 @@ module Haml
       "extend Haml::Helpers; #{super}"
     end
   end
-  Template.send(:extend, TemplateExtension)
+  Template.extend TemplateExtension
 end

data/lib/haml/temple_line_counter.rb

@@ -19,13 +19,27 @@ module Haml
         arg.count("\n") + cases.map do |cond, e|
           (cond == :else ? 0 : cond.count("\n")) + count_lines(e)
         end.reduce(:+)
-      when :escape
+      when :escape, :fescape
         count_lines(args[1])
+      when :html
+        count_html_lines(args)
       when :newline
         1
       else
         raise UnexpectedExpression.new("[HAML BUG] Unexpected Temple expression '#{type}' is given!")
       end
     end
+
+    def self.count_html_lines(args)
+      case args[0]
+      when :attrs
+        args.drop(1).sum { |a| count_lines(a) }
+      when :attr
+        count_lines(args[2])
+      else
+        raise UnexpectedExpression.new("[HAML BUG] Unexpected Temple expression 'html #{args[0]}' is given!")
+      end
+    end
+    private_class_method :count_html_lines
   end
 end

data/lib/haml/util.rb

@@ -5,7 +5,6 @@ begin
 rescue LoadError
   require 'erb'
 end
-require 'set'
 require 'stringio'
 require 'strscan'
 

data/lib/haml/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Haml
-  VERSION = '7.4.0'
+  VERSION = '7.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 7.4.0
+  version: 7.5.0
 platform: ruby
 authors:
 - Natalie Weizenbaum
@@ -307,6 +307,7 @@ files:
 - lib/haml/identity.rb
 - lib/haml/object_ref.rb
 - lib/haml/parser.rb
+- lib/haml/preserver.rb
 - lib/haml/rails_helpers.rb
 - lib/haml/rails_template.rb
 - lib/haml/railtie.rb