haml 7.2.2 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: def36fc38e0b0116356b085a4120ea0564c5624c766e03f705ec91d3657e2e8c
-  data.tar.gz: 937230d9bbf1ad0cbad38457d985bd964a5edd49137f31398fafad0aa474a8bf
+  metadata.gz: 381430279e5ca21c3d03f899c686f972609e54633c8e530609511e852597b7ef
+  data.tar.gz: a108268dccda6dc0e3ca014e484a7bcc0f50c973771a0057a086d75de2847495
 SHA512:
-  metadata.gz: f57d6abe6fdac34effcac8e52c889142828bf405f915239526fe6540ccb2fe138e79f972536e79a1c5dc7ab4de1871030900d0b2a0118325049d316bd5e534f7
-  data.tar.gz: b9135ee6741e0105df6e5f4a92c5c3ea660e10be525aca983d2b0d7f509f80d61216fcc32d340f678c3e1ca7ab91da70d4a436a6c45ce6b956d48cf8105097c8
+  metadata.gz: b5f8d7bcc23e52be3fd4ed443ec3fdf171773f9c9aaacd1705d92ec09a3ef372adf13a8715ca4b4d039aa2a07fc2fdbb7e59eef30a22f55be2823bb0c7e23f0d
+  data.tar.gz: 954f3aa91fa3f49499d05dd1503056dd65a439519c5b2bcc300a6cf3dfbacf686717c8aa1e10ddb1ca7fa779504d92561a33e8a7d729b8013967cde102636fca

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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

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,33 +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?
-      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
@@ -38,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

@@ -39,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

@@ -53,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,92 +1,69 @@
 # frozen_string_literal: true
-require 'ripper'
+require 'prism'
+require 'haml/ruby_expression'
 
 module Haml
   # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
   class StringSplitter < Temple::Filter
     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)
+      # `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
 
-      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]
+      # 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
 
-      def compile_tokens!(exps, tokens)
-        beg_str, end_str = strip_quotes!(tokens)
-
-        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)
-            exps << [:dynamic, embedded] unless embedded.empty?
+      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
       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
+      # 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
 
     def on_dynamic(code)
-      return [:dynamic, code] unless string_literal?(code)
       return [:dynamic, code] if code.include?("\n")
 
+      node = RubyExpression.string_literal_node(code)
+      return [:dynamic, code] if node.nil?
+
       temple = [:multi]
-      StringSplitter.compile(code).each do |type, content|
+      StringSplitter.compile(code, node: node).each do |type, content|
         case type
         when :static
           temple << [:static, content]
@@ -96,35 +73,5 @@ module Haml
       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
-    end
-
-    class SyntaxChecker < Ripper
-      class ParseError < StandardError; end
-
-      def self.syntax_error?(code)
-        self.new(code).parse
-        false
-      rescue ParseError
-        true
-      end
-
-      private
-
-      def on_parse_error(*)
-        raise ParseError
-      end
-    end
   end
 end

data/lib/haml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 7.2.2
+  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: