haml 7.2.1 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4665a2a3c561765d35c0eeec78fdc87d2574cd640249089ace5035cc672e46f
-  data.tar.gz: 02146e70c4ace1a58a1598ccfe25b08a22f06d0aa0554244806b1593cce85caa
+  metadata.gz: 381430279e5ca21c3d03f899c686f972609e54633c8e530609511e852597b7ef
+  data.tar.gz: a108268dccda6dc0e3ca014e484a7bcc0f50c973771a0057a086d75de2847495
 SHA512:
-  metadata.gz: 3b24e11afe577f0b175fca4ae8fe5bdc45ae245e2f654a6d832ac2c619e25f2aeefb700e5ba51742f22ad5e849cc06d8831ef2a2c30083aab7a2bab727fcfe01
-  data.tar.gz: ad77cc1be2d2831de2cbac2568efbc368fb1627626c19138e7059b120fb2e85c88057b8f9fb705c22f82b7d910497018e156acbc61691ce52db4de5d39a0e764
+  metadata.gz: b5f8d7bcc23e52be3fd4ed443ec3fdf171773f9c9aaacd1705d92ec09a3ef372adf13a8715ca4b4d039aa2a07fc2fdbb7e59eef30a22f55be2823bb0c7e23f0d
+  data.tar.gz: 954f3aa91fa3f49499d05dd1503056dd65a439519c5b2bcc300a6cf3dfbacf686717c8aa1e10ddb1ca7fa779504d92561a33e8a7d729b8013967cde102636fca

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Haml Changelog
 
+## 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

data/Gemfile

@@ -20,7 +20,7 @@ if /java/.match?(RUBY_PLATFORM) # JRuby
 else
   gem 'redcarpet'
 
-  if RUBY_PLATFORM !~ /mswin|mingw/ && RUBY_ENGINE != 'truffleruby'
+  if RUBY_PLATFORM !~ /mswin|mingw/
     gem 'stackprof'
   end
 end

data/haml.gemspec

@@ -21,11 +21,14 @@ Gem::Specification.new do |spec|
 
   spec.metadata      = { 'rubygems_mfa_required' => 'true' }
 
-  spec.metadata["changelog_uri"] = "https://github.com/haml/haml/releases"
+  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 = '>= 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'

data/lib/haml/attribute_compiler.rb

@@ -22,9 +22,7 @@ module Haml
 
     def compile(node)
       hashes = []
-      if node.value[:object_ref] != :nil || !AttributeParser.available?
-        return runtime_compile(node)
-      end
+      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|
         hash = AttributeParser.parse(attribute_str)
         return runtime_compile(node) if hash.nil? || hash.any? { |_key, value| value.empty? }

data/lib/haml/attribute_parser.rb

@@ -1,34 +1,40 @@
 # 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.
     def parse(text)
       exp = wrap_bracket(text)
-      return if Temple::StaticAnalyzer.syntax_error?(exp)
+      # 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?
 
       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[key] = value_source(element.value)
       end
       hash
-    rescue ParseSkip
-      nil
     end
 
     private
@@ -39,78 +45,34 @@ 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
-    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
 
-    def assert_type!(token, type)
-      raise ParseSkip if token[1] != type
+      node = statements.first
+      node if node.is_a?(Prism::HashNode)
     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 }
+    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)
 
-      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?
+      value.slice
     end
   end
 end

data/lib/haml/compiler/script_compiler.rb

@@ -21,10 +21,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 +39,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]

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/filters/plain.rb

@@ -14,7 +14,12 @@ module Haml
 
       def compile_plain(text)
         string_literal = ::Haml::Util.unescape_interpolation(text)
-        StringSplitter.compile(string_literal).map do |temple|
+        compiled = StringSplitter.try_compile(string_literal)
+        # Ruby that does not parse: let the generated code report it against the template,
+        # rather than failing the whole compilation.
+        return [[:escape, false, [:dynamic, string_literal]]] if compiled.nil?
+
+        compiled.map do |temple|
           type, str = temple
           case type
           when :dynamic

data/lib/haml/parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'ripper'
+require 'prism'
 require 'strscan'
 require 'haml/error'
 require 'haml/util'
@@ -601,8 +601,7 @@ module Haml
       attributes
     end
 
-    # 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.
+    # Ideally this logic should be placed in Haml::AttributeParser 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
@@ -686,17 +685,17 @@ module Haml
         # 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.
+        # To scan such code correctly, this scans `a( hash, foo: bar }` instead, stops on the '}'
+        # that closes one more brace than was opened, and resurrects '{' afterwards.
         #
         # Old attributes allow invalid Hash constructs (e.g., `{ hash, foo: bar }`).
         # Replacing the opening `{` with `a(` makes the syntax look like a method call so
-        # Ripper can lex it reliably.
+        # it can be lexed reliably.
 
         attributes_hash, rest = balance_tokens(
           text.sub(?{, METHOD_CALL_PREFIX),
-          [:on_lbrace, :on_tlambeg, :on_embexpr_beg],
-          [:on_rbrace, :on_embexpr_end],
+          [:BRACE_LEFT, :LAMBDA_BEGIN, :EMBEXPR_BEGIN],
+          [:BRACE_RIGHT, :EMBEXPR_END],
           count: 1)
         attributes_hash = attributes_hash.sub(METHOD_CALL_PREFIX, ?{)
       rescue SyntaxError => e
@@ -854,19 +853,23 @@ 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.
+    # Unlike #balance, this balances lexed 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
-        if start.include?(token)
+      Prism.lex(buf).value.each do |token, _|
+        type = token.type
+        next if type == :EOF
+
+        if start.include?(type)
           count += 1
-        elsif finish.include?(token)
+        elsif finish.include?(type)
           count -= 1
         end
 
         if count == 0
-          return text, buf.sub(text, '')
+          # Splitting on the offset instead of the tokens seen so far: whitespace and comments
+          # are not tokens, so the text cannot be rebuilt by concatenating them.
+          offset = token.location.end_offset
+          return buf.byteslice(0, offset), buf.byteslice(offset..)
         end
       end
       raise SyntaxError.new(Error.message(:unbalanced_brackets))

data/lib/haml/ruby_expression.rb

@@ -1,32 +1,39 @@
 # frozen_string_literal: true
-require 'ripper'
+require 'prism'
 
 module Haml
-  class RubyExpression < Ripper
-    class ParseError < StandardError; end
+  class RubyExpression
+    # A character literal (`?a`) is a StringNode for Prism, but it has no quotes
+    # to split on, so it must not be reported as a string literal.
+    CHAR_LITERAL_OPENING = '?'
+
+    # A template is compiled into a method body, so a jump like `yield` is valid here even
+    # though it would not be at the top level of a script.
+    PARSE_OPTIONS = { partial_script: true }.freeze
 
     def self.syntax_error?(code)
-      self.new(code).parse
-      false
-    rescue ParseError
-      true
+      Prism.parse_failure?(code, **PARSE_OPTIONS)
     end
 
     def self.string_literal?(code)
-      return false if syntax_error?(code)
-
-      type, instructions = Ripper.sexp(code)
-      return false if type != :program
-      return false if instructions.size > 1
-
-      type, _ = instructions.first
-      type == :string_literal
+      !string_literal_node(code).nil?
     end
 
-    private
+    # @return [Prism::Node, nil] - the node of a string literal StringSplitter can split, if any.
+    #   Its locations are byte offsets into `code` as given, so `code` must not be stripped here.
+    def self.string_literal_node(code)
+      result = Prism.parse(code, **PARSE_OPTIONS)
+      return if result.failure?
+
+      statements = result.value.statements.body
+      return if statements.size > 1
 
-    def on_parse_error(*)
-      raise ParseError
+      case (node = statements.first)
+      when Prism::StringNode, Prism::InterpolatedStringNode
+        # Adjacent concatenation (`"a" "b"`) is one node without an opening
+        # delimiter of its own, and each of its parts keeps its own quotes.
+        node if !node.opening.nil? && node.opening != CHAR_LITERAL_OPENING
+      end
     end
   end
 end

data/lib/haml/string_splitter.rb

@@ -1,140 +1,77 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'prism'
+require 'haml/ruby_expression'
 
 module Haml
   # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
   class StringSplitter < Temple::Filter
-    if defined?(Ripper) && Ripper.respond_to?(:lex)
-      class << self
-        # `code` param must be valid string literal
-        def compile(code)
-          [].tap do |exps|
-            tokens = Ripper.lex(code.strip)
-            tokens.pop while tokens.last && [:on_comment, :on_sp].include?(tokens.last[1])
-
-            if tokens.size < 2
-              raise(Haml::InternalError, "Expected token size >= 2 but got: #{tokens.size}")
-            end
-            compile_tokens!(exps, tokens)
-          end
-        end
-
-        private
-
-        def strip_quotes!(tokens)
-          _, type, beg_str = tokens.shift
-          if type != :on_tstring_beg
-            raise(Haml::InternalError, "Expected :on_tstring_beg but got: #{type}")
-          end
-
-          _, type, end_str = tokens.pop
-          if type != :on_tstring_end
-            raise(Haml::InternalError, "Expected :on_tstring_end but got: #{type}")
-          end
-
-          [beg_str, end_str]
+    class << self
+      # `code` param must be a string literal, as RubyExpression.string_literal? defines it.
+      def compile(code, node: RubyExpression.string_literal_node(code))
+        case node
+        when Prism::StringNode
+          node.unescaped.empty? ? [] : [[:static, node.unescaped]]
+        when Prism::InterpolatedStringNode
+          compile_parts(node.parts, code)
+        else
+          raise(Haml::InternalError, "Expected a string literal but got: #{code}")
         end
+      end
 
-        def compile_tokens!(exps, tokens)
-          beg_str, end_str = strip_quotes!(tokens)
+      # Like compile, but nil instead of raising, for callers that built `code` themselves
+      # and would rather emit it untouched than fail the whole compilation.
+      def try_compile(code)
+        node = RubyExpression.string_literal_node(code)
+        compile(code, node: node) unless node.nil?
+      end
 
-          until tokens.empty?
-            _, type, str = tokens.shift
+      private
 
-            case type
-            when :on_tstring_content
-              beg_str, end_str = escape_quotes(beg_str, end_str)
-              exps << [:static, eval("#{beg_str}#{str}#{end_str}").to_s]
-            when :on_embexpr_beg
-              embedded = shift_balanced_embexpr(tokens)
+      def compile_parts(parts, code)
+        [].tap do |exps|
+          parts.each do |part|
+            case part
+            when Prism::StringNode
+              content = part.unescaped
+              exps << [:static, content] unless content.empty?
+            when Prism::EmbeddedStatementsNode
+              embedded = embedded_source(part, code)
               exps << [:dynamic, embedded] unless embedded.empty?
+            when Prism::EmbeddedVariableNode
+              exps << [:dynamic, part.variable.slice]
+            else
+              # Prism allows more part types than a string literal can currently hold. Dropping
+              # one would silently lose content, so fail instead of rendering something wrong.
+              raise(Haml::InternalError, "Unexpected #{part.class} in string literal: #{code}")
             end
           end
         end
-
-        # Some quotes are split-unsafe. Replace such quotes with null characters.
-        def escape_quotes(beg_str, end_str)
-          case [beg_str[-1], end_str]
-          when ['(', ')'], ['[', ']'], ['{', '}']
-            [beg_str.sub(/.\z/) { "\0" }, "\0"]
-          else
-            [beg_str, end_str]
-          end
-        end
-
-        def shift_balanced_embexpr(tokens)
-          String.new.tap do |embedded|
-            embexpr_open = 1
-
-            until tokens.empty?
-              _, type, str = tokens.shift
-              case type
-              when :on_embexpr_beg
-                embexpr_open += 1
-              when :on_embexpr_end
-                embexpr_open -= 1
-                break if embexpr_open == 0
-              end
-
-              embedded << str
-            end
-          end
-        end
-      end
-
-      def on_dynamic(code)
-        return [:dynamic, code] unless string_literal?(code)
-        return [:dynamic, code] if code.include?("\n")
-
-        temple = [:multi]
-        StringSplitter.compile(code).each do |type, content|
-          case type
-          when :static
-            temple << [:static, content]
-          when :dynamic
-            temple << on_dynamic(content)
-          end
-        end
-        temple
       end
 
-      private
-
-      def string_literal?(code)
-        return false if SyntaxChecker.syntax_error?(code)
-
-        type, instructions = Ripper.sexp(code)
-        return false if type != :program
-        return false if instructions.size > 1
-
-        type, _ = instructions.first
-        type == :string_literal
+      # The source between `#{` and `}`, kept verbatim. Slicing `code` rather than
+      # using the statements' own source preserves the whitespace around them.
+      def embedded_source(part, code)
+        from = part.opening_loc.end_offset
+        code.byteslice(from, part.closing_loc.start_offset - from)
       end
+    end
 
-      class SyntaxChecker < Ripper
-        class ParseError < StandardError; end
-
-        def self.syntax_error?(code)
-          self.new(code).parse
-          false
-        rescue ParseError
-          true
-        end
+    def on_dynamic(code)
+      return [:dynamic, code] if code.include?("\n")
 
-        private
+      node = RubyExpression.string_literal_node(code)
+      return [:dynamic, code] if node.nil?
 
-        def on_parse_error(*)
-          raise ParseError
+      temple = [:multi]
+      StringSplitter.compile(code, node: node).each do |type, content|
+        case type
+        when :static
+          temple << [:static, content]
+        when :dynamic
+          temple << on_dynamic(content)
         end
       end
-    else
-      # Do nothing if ripper is unavailable
-      def call(ast)
-        ast
-      end
+      temple
     end
   end
 end

data/lib/haml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 7.2.1
+  version: 7.3.0
 platform: ruby
 authors:
 - Natalie Weizenbaum
@@ -13,6 +13,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: temple
   requirement: !ruby/object:Gem::Requirement
@@ -308,7 +322,9 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  changelog_uri: https://github.com/haml/haml/releases
+  bug_tracker_uri: https://github.com/haml/haml/issues
+  changelog_uri: https://github.com/haml/haml/blob/main/CHANGELOG.md
+  homepage_uri: https://haml.info/
   source_code_uri: https://github.com/haml/haml
 rdoc_options: []
 require_paths: