haml 6.4.0 → 7.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 313ffec5cc79d2b238173fde9769ac60d26b54bf15d3deda68adc84d0849620b
-  data.tar.gz: 143e9115612a2555a4ce34c817745e330548a7eaedf98bc819ead44b2156f8ad
+  metadata.gz: 8cf8d7cf95a5096090897276b03dd8073e73705fa1b880bba96af5dceb3b2c55
+  data.tar.gz: 4d1e1ff1bd53361d0a31c78533a838e60e52d10c5646ff0d8bbd87a552ccc658
 SHA512:
-  metadata.gz: 117f3811b514f8abd4142cdc8022e282e5a5434c5c0f6904e7eaff7655f58894e3486c999282f0140b6011016b52b139036071792c3ba33494de73342d512d77
-  data.tar.gz: 99e76cc2438c8ba70aaf39b3ccc0df9b610e3ac06de35b8865c2f2ce5aa692f9642791b863602eef5e382d60224fdb44a143074c11f072ccad7556ae1461b261
+  metadata.gz: 3bbfe67377d06702fa3240048fd25410f885f05a503d4e8e7793f0ccbba9ffb99e601d46068150d2170c11a3807660571fe26f337becfc155758f05cc470bc40
+  data.tar.gz: '01159a17fda467397309cfa38de5ad7b1e8820d506447b87221a8cdc087f02e8546cb1d2ad9a358d4ad0fa0c0b29c60b0a03bcf692e2fa551d748111701d8adc'

data/.github/workflows/test.yml

@@ -17,14 +17,10 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - '2.5'
-          - '2.6'
-          - '2.7'
-          - '3.0'
-          - '3.1'
           - '3.2'
           - '3.3'
           - '3.4'
+          - '4.0'
           - ruby-head
           - jruby
           - truffleruby

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Haml Changelog
 
+## 7.5.1
+
+* Improve frozen strings management https://github.com/haml/haml/pull/1205
+
+## 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
+* A guard on `respond_to?(:html_safe?)` is removed from `Haml::Util.escape_html_safe` https://github.com/haml/haml/pull/1217
+* Keep interpolated text in the source encoding, fixing the `Encoding::CompatibilityError` remaining on an ASCII-8BIT
+  template source that mixes plain text and interpolation with non-ASCII characters https://github.com/haml/haml/issues/1218
+
+## 7.3.1
+
+* Keep Prism-derived fragments in the source encoding, fixing `Encoding::CompatibilityError` on an ASCII-8BIT
+  template source with non-ASCII characters (regression in 7.3.0) https://github.com/haml/haml/issues/1218
+
+## 7.3.0
+
+* Replace Ripper with Prism https://github.com/haml/haml/pull/1214
+  * Interpolate `#@ivar`, `#$gvar` and `#@@cvar` in string literals instead of dropping them
+  * Keep an escaped delimiter of a percent literal, so `= %q{a\}b}` renders `a}b`
+  * Deprecate `Haml::AttributeParser.available?`, which is now always true and will be removed in the future
+
+## 7.2.2
+
+* Remove obsolete TruffleRuby compatibility skips https://github.com/haml/haml/pull/1210
+
+## 7.2.1
+
+* Do not rely on Ripper quirk in parsing old-style Haml attributes https://github.com/haml/haml/pull/1212
+
+## 7.2.0
+
+* Do not require rails when haml is required https://github.com/haml/haml/pull/1201
+* Point `changelog_uri` to GitHub Releases https://github.com/haml/haml/pull/1202
+
+## 7.1.0
+
+* Support xhtml format for boolean nested data attributes https://github.com/haml/haml/pull/1200
+
+## 7.0.2
+
+* Replace usages of `=~` with `.match?` where possible https://github.com/haml/haml/pull/1196
+* Add source code URI to gemspec metadata https://github.com/haml/haml/pull/1197
+
+## 7.0.1
+
+* Use `Regexp#match?` predicate where possible https://github.com/haml/haml/pull/1194
+* Fix the 'Changelog' link on rubygems.org/gems/haml https://github.com/haml/haml/pull/1192
+
+## 7.0.0
+
+* Change the default `attr_quote` from `'` to `"` https://github.com/haml/haml/issues/1188
+* Bump required Ruby version to 3.2 https://github.com/haml/haml/issues/1176
+
 ## 6.4.0
 
 * Authorize characters in attribute name for vuejs https://github.com/haml/haml/pull/1172

data/Gemfile

@@ -10,25 +10,17 @@ gemspec
 
 gem 'benchmark-ips', '2.3.0'
 gem 'maxitest'
-gem 'pry'
+gem 'base64'
+gem 'bigdecimal'
+gem 'mutex_m'
 
-if /java/ === RUBY_PLATFORM # JRuby
+if /java/.match?(RUBY_PLATFORM) # JRuby
   gem 'pandoc-ruby'
+  gem 'rdoc', '< 8' # rdoc 8 depends on rbs, whose native extension doesn't build on JRuby
 else
   gem 'redcarpet'
 
-  if RUBY_PLATFORM !~ /mswin|mingw/ && RUBY_ENGINE != 'truffleruby'
+  if RUBY_PLATFORM !~ /mswin|mingw/
     gem 'stackprof'
   end
 end
-
-if RUBY_VERSION < '2.6'
-  gem 'rake-compiler', '< 1.2.4'
-end
-
-# Temporary workaround to ensure Ruby 2.5 and 2.6 can pass tests with Rails 6.1
-# Reference: https://github.com/rails/rails/issues/54260
-# TODO: Remove this workaround when dropping support for Rails versions below 7.1
-if RUBY_VERSION < '2.7'
-  gem 'concurrent-ruby', '< 1.3.5'
-end

data/README.md

@@ -157,7 +157,7 @@ on a specific area:
 ruby -Itest test/helper_test.rb -n test_buffer_access
 ~~~
 
-Haml currently supports Ruby 2.0.0 and higher, so please make sure your changes run on 2.0+.
+Haml currently supports Ruby 3.2.0 and higher, so please make sure your changes run on 3.2+.
 
 ## Team
 

data/REFERENCE.md

@@ -320,7 +320,7 @@ or using `true` and `false`:
     %input(selected=true)
 
 This feature works only for attributes that are included in
-[`Haml::BOOLEAN_ATTRIBUTES`](https://github.com/haml/haml/blob/main/lib/haml/attribute_compiler.rb#L8),
+[`Haml::BOOLEAN_ATTRIBUTES`](https://github.com/haml/haml/blob/main/lib/haml/attribute_compiler.rb#L9),
 as well as `data-` and `aria-` attributes.
 
     %input{'data-hidden' => false}

data/bin/console

@@ -1,11 +1,10 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'hamlit'
+require 'haml'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-require 'pry'
-Pry.start
+require 'irb'
+IRB.start

data/bin/stackprof

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'hamlit'
+require 'haml'
 require 'stackprof'
 
 def open_flamegraph(report)
@@ -20,7 +20,7 @@ end
 
 haml = File.read(ARGV.first)
 StackProf.start(mode: :wall, interval: 1, raw: false)
-Hamlit::Engine.new.call(haml)
+Haml::Engine.new.call(haml)
 StackProf.stop
 
 report = StackProf::Report.new(StackProf.results)

data/haml.gemspec

@@ -21,10 +21,14 @@ Gem::Specification.new do |spec|
 
   spec.metadata      = { 'rubygems_mfa_required' => 'true' }
 
-  spec.metadata["changelog_uri"] = spec.homepage + "/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/haml/haml/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/haml/haml/blob/main/CHANGELOG.md"
+  spec.metadata["homepage_uri"] = "https://haml.info/"
+  spec.metadata["source_code_uri"] = "https://github.com/haml/haml"
 
-  spec.required_ruby_version = '>= 2.1.0'
+  spec.required_ruby_version = '>= 3.2.0'
 
+  spec.add_dependency 'prism', '>= 1.1.0'
   spec.add_dependency 'temple', '>= 0.8.2'
   spec.add_dependency 'thor'
   spec.add_dependency 'tilt'
@@ -33,7 +37,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'coffee-script'
   spec.add_development_dependency 'erubi'
-  spec.add_development_dependency 'haml', '>= 5'
   spec.add_development_dependency 'less'
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
   spec.add_development_dependency 'rails', '>= 4.0'

data/lib/haml/attribute_builder.rb

@@ -16,13 +16,15 @@ module Haml::AttributeBuilder
         when 'class'
           buf << " class=#{quote}#{build_class(escape_attrs, *hash[key])}#{quote}"
         when 'data'
-          buf << build_data(escape_attrs, quote, *hash[key])
+          buf << build_data(escape_attrs, quote, format, *hash[key])
         when 'aria'
-          buf << build_aria(escape_attrs, quote, *hash[key])
-        when *Haml::BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
-          build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+          buf << build_aria(escape_attrs, quote, format, *hash[key])
         else
-          buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+          if boolean_attribute?(key)
+            build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+          else
+            buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+          end
         end
       end
       buf.join
@@ -62,17 +64,21 @@ module Haml::AttributeBuilder
       escape_html(escape_attrs, classes.map(&:to_s).uniq.join(' '))
     end
 
-    def build_data(escape_attrs, quote, *hashes)
-      build_data_attribute(:data, escape_attrs, quote, *hashes)
+    def build_data(escape_attrs, quote, format, *hashes)
+      build_data_attribute(:data, escape_attrs, quote, format, *hashes)
     end
 
-    def build_aria(escape_attrs, quote, *hashes)
-      build_data_attribute(:aria, escape_attrs, quote, *hashes)
+    def build_aria(escape_attrs, quote, format, *hashes)
+      build_data_attribute(:aria, escape_attrs, quote, format, *hashes)
     end
 
     private
 
-    def build_data_attribute(key, escape_attrs, quote, *hashes)
+    def boolean_attribute?(key)
+      Haml::BOOLEAN_ATTRIBUTES.include?(key) || key.start_with?('data-', 'aria-')
+    end
+
+    def build_data_attribute(key, escape_attrs, quote, format, *hashes)
       attrs = []
       if hashes.size > 1 && hashes.all? { |h| h.is_a?(Hash) }
         data_value = merge_all_attrs(hashes)
@@ -84,7 +90,7 @@ module Haml::AttributeBuilder
       hash.sort_by(&:first).each do |key, value|
         case value
         when true
-          attrs << " #{key}"
+          build_boolean!(escape_attrs, quote, format, attrs, key, value)
         when nil, false
           # noop
         else
@@ -98,14 +104,18 @@ module Haml::AttributeBuilder
       flattened = {}
 
       attributes.each do |key, value|
+        # Recursing into a hash which contains itself would never end.
+        next if value.equal?(attributes)
+
         case value
-        when attributes
         when Hash
           flatten_attributes(value).each do |k, v|
             if k.nil?
               flattened[key] = v
             else
-              flattened["#{key}-#{k.to_s.tr('_', '-')}"] = v
+              k = k.is_a?(Symbol) ? k.name : k.to_s
+              k = k.tr('_', '-') if k.include?('_')
+              flattened["#{key}-#{k}"] = v
             end
           end
         else
@@ -122,7 +132,8 @@ module Haml::AttributeBuilder
           raise ArgumentError, "Non-hash object is given to attributes!"
         end
         hash.each do |key, value|
-          key = key.to_s
+          # Symbol#name hands back the interned String; to_s allocates one per render.
+          key = key.is_a?(Symbol) ? key.name : key.to_s
           case key
           when 'id', 'class', 'data', 'aria'
             merged[key] ||= []

data/lib/haml/attribute_compiler.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
+require 'set'
 require 'haml/attribute_builder'
 require 'haml/attribute_parser'
 require 'haml/ruby_expression'
+require 'haml/temple_line_counter'
 
 module Haml
-  # The list of boolean attributes. You may add custom attributes to this constant.
-  BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
+  # The set of boolean attributes. You may add custom attributes to this constant.
+  BOOLEAN_ATTRIBUTES = Set.new(%w[disabled readonly multiple checked autobuffer
                        autoplay controls loop selected hidden scoped async
                        defer reversed ismap seamless muted required
                        autofocus novalidate formnovalidate open pubdate
                        itemscope allowfullscreen default inert sortable
-                       truespeed typemustmatch download]
+                       truespeed typemustmatch download])
 
   class AttributeCompiler
     def initialize(identity, options)
@@ -22,15 +24,16 @@ module Haml
 
     def compile(node)
       hashes = []
-      if node.value[:object_ref] != :nil || !AttributeParser.available?
-        return runtime_compile(node)
-      end
-      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
+      return runtime_compile(node) if node.value[:object_ref] != :nil
+      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
@@ -57,15 +60,24 @@ module Haml
           compile_class!(temple, key, values)
         when 'data', 'aria'
           compile_data!(temple, key, values)
-        when *BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
-          compile_boolean!(temple, key, values)
         else
-          compile_common!(temple, key, values)
+          if BOOLEAN_ATTRIBUTES.include?(key) || key.start_with?('data-', 'aria-')
+            compile_boolean!(temple, key, values)
+          else
+            compile_common!(temple, key, values)
+          end
         end
       end
       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) }
@@ -85,7 +97,7 @@ module Haml
     end
 
     def compile_data!(temple, key, values)
-      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", values.map { |v| literal_for(v) }]
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect, values.map { |v| literal_for(v) }]
       build_code = "::Haml::AttributeBuilder.build_#{key}(#{args.join(', ')})"
 
       if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }

data/lib/haml/attribute_parser.rb

@@ -1,34 +1,36 @@
 # frozen_string_literal: true
-require 'haml/ruby_expression'
+require 'prism'
 
 module Haml
   class AttributeParser
-    class ParseSkip < StandardError
-    end
-
-    # @return [TrueClass, FalseClass] - return true if AttributeParser.parse can be used.
+    # @deprecated Prism is a hard dependency, so this is always true. Haml itself no longer
+    #   asks, and this will be removed in the future.
+    # @return [TrueClass] - return true if AttributeParser.parse can be used.
     def self.available?
-      # TruffleRuby doesn't have Ripper.lex
-      defined?(Ripper) && Ripper.respond_to?(:lex) && Temple::StaticAnalyzer.available?
+      true
     end
 
     def self.parse(text)
       self.new.parse(text)
     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, or if it holds a heredoc.
     def parse(text)
       exp = wrap_bracket(text)
-      return if Temple::StaticAnalyzer.syntax_error?(exp)
+      node = hash_node(exp)
+      return if node.nil? || contains_heredoc?(exp, node)
 
       hash = {}
-      tokens = Ripper.lex(exp)[1..-2] || []
-      each_attr(tokens) do |attr_tokens|
-        key = parse_key!(attr_tokens)
-        hash[key] = attr_tokens.map { |t| t[2] }.join.strip
+      node.elements.each do |element|
+        return unless element.is_a?(Prism::AssocNode)
+
+        key = static_key(element.key)
+        return if key.nil?
+
+        hash[in_source_encoding(key, exp)] = in_source_encoding(value_source(element.value), exp)
       end
       hash
-    rescue ParseSkip
-      nil
     end
 
     private
@@ -39,78 +41,50 @@ module Haml
       "{#{text}}"
     end
 
-    def parse_key!(tokens)
-      _, type, str = tokens.shift
-      case type
-      when :on_sp
-        parse_key!(tokens)
-      when :on_label
-        str.tr(':', '')
-      when :on_symbeg
-        _, _, key = tokens.shift
-        assert_type!(tokens.shift, :on_tstring_end) if str != ':'
-        skip_until_hash_rocket!(tokens)
-        key
-      when :on_tstring_beg
-        _, _, key = tokens.shift
-        next_token = tokens.shift
-        unless next_token[1] == :on_label_end
-          assert_type!(next_token, :on_tstring_end)
-          skip_until_hash_rocket!(tokens)
-        end
-        key
-      else
-        raise ParseSkip
-      end
+    def hash_node(exp)
+      # partial_script, because an attribute may legitimately call `yield` and the like:
+      # a template is compiled into a method body.
+      result = Prism.parse(exp, partial_script: true)
+      return if result.failure?
+
+      statements = result.value.statements.body
+      return if statements.size != 1
+
+      node = statements.first
+      node if node.is_a?(Prism::HashNode)
     end
 
-    def assert_type!(token, type)
-      raise ParseSkip if token[1] != type
+    # 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
 
-    def skip_until_hash_rocket!(tokens)
-      until tokens.empty?
-        _, type, str = tokens.shift
-        break if type == :on_op && str == '=>'
+    # 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)
+      case key
+      when Prism::SymbolNode then key.value_loc&.slice
+      when Prism::StringNode then key.content_loc&.slice
       end
     end
 
-    def each_attr(tokens)
-      attr_tokens = []
-      open_tokens = Hash.new { |h, k| h[k] = 0 }
-
-      tokens.each do |token|
-        _, type, _ = token
-        case type
-        when :on_comma
-          if open_tokens.values.all?(&:zero?)
-            yield(attr_tokens)
-            attr_tokens = []
-            next
-          end
-        when :on_lbracket
-          open_tokens[:array] += 1
-        when :on_rbracket
-          open_tokens[:array] -= 1
-        when :on_lbrace
-          open_tokens[:block] += 1
-        when :on_rbrace
-          open_tokens[:block] -= 1
-        when :on_lparen
-          open_tokens[:paren] += 1
-        when :on_rparen
-          open_tokens[:paren] -= 1
-        when :on_embexpr_beg
-          open_tokens[:embexpr] += 1
-        when :on_embexpr_end
-          open_tokens[:embexpr] -= 1
-        when :on_sp
-          next if attr_tokens.empty?
-        end
-
-        attr_tokens << token
-      end
-      yield(attr_tokens) unless attr_tokens.empty?
+    def value_source(value)
+      # Ruby 3.1 value omission (`{ foo: }`). An empty value tells AttributeCompiler to
+      # fall back to the runtime, which is what resolves it.
+      return '' if value.is_a?(Prism::ImplicitNode)
+
+      value.slice
+    end
+
+    # Prism tags its slices with the encoding it parsed the source under (UTF-8 for a
+    # BINARY source), while the rest of the compiled template stays in the source
+    # encoding. Mixing the two raises Encoding::CompatibilityError once both sides hold
+    # non-ASCII bytes, so bring everything back to the source encoding.
+    def in_source_encoding(string, source)
+      return string if string.encoding == source.encoding
+
+      string.dup.force_encoding(source.encoding)
     end
   end
 end

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)
@@ -21,10 +18,6 @@ module Haml
       end
 
       def compile(node, &block)
-        unless Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
-          return dynamic_compile(node, &block)
-        end
-
         no_children = node.children.empty?
         case
         when no_children && node.value[:escape_interpolation]
@@ -43,8 +36,13 @@ module Haml
       # String-interpolated plain text must be compiled with this method
       # because we have to escape only interpolated values.
       def compile_interpolated_plain(node)
+        compiled = StringSplitter.try_compile(node.value[:text])
+        # Ruby that does not parse: let the generated code report it, rather than failing
+        # the whole compilation with an error that points at Haml instead of the template.
+        return delegate_optimization(node) if compiled.nil?
+
         temple = [:multi]
-        StringSplitter.compile(node.value[:text]).each do |type, value|
+        compiled.each do |type, value|
           case type
           when :static
             temple << [:static, value]
@@ -68,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
@@ -103,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/compiler/tag_compiler.rb

@@ -28,10 +28,8 @@ module Haml
           nil
         when node.value[:parse]
           return compile_interpolated_plain(node) if node.value[:escape_interpolation]
-          if Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
-            return delegate_optimization(node) if RubyExpression.string_literal?(node.value[:value])
-            return delegate_optimization(node) if Temple::StaticAnalyzer.static?(node.value[:value])
-          end
+          return delegate_optimization(node) if RubyExpression.string_literal?(node.value[:value])
+          return delegate_optimization(node) if Temple::StaticAnalyzer.static?(node.value[:value])
 
           var = @identity.generate
           [:multi,
@@ -55,8 +53,13 @@ module Haml
 
       # We should handle interpolation here to escape only interpolated values.
       def compile_interpolated_plain(node)
+        compiled = StringSplitter.try_compile(node.value[:value])
+        # Ruby that does not parse: let the generated code report it, rather than failing
+        # the whole compilation with an error that points at Haml instead of the template.
+        return delegate_optimization(node) if compiled.nil?
+
         temple = [:multi]
-        StringSplitter.compile(node.value[:value]).each do |type, value|
+        compiled.each do |type, value|
           case type
           when :static
             temple << [:static, value]

data/lib/haml/dynamic_merger.rb

@@ -36,7 +36,7 @@ module Haml
         return exps
       end
 
-      strlit_body = String.new
+      strlit_body = +''
       exps.each do |type, arg|
         case type
         when :static