haml 7.2.0 → 7.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 666a9c4513f3c1450ac36b92fefcff06d9a69aae9cc60840eb0182dbe53e2995
-  data.tar.gz: 709a5f0d8ad693be7bb7b2750d84fb1025d77ada780f045071e69bf16abfa76a
+  metadata.gz: def36fc38e0b0116356b085a4120ea0564c5624c766e03f705ec91d3657e2e8c
+  data.tar.gz: 937230d9bbf1ad0cbad38457d985bd964a5edd49137f31398fafad0aa474a8bf
 SHA512:
-  metadata.gz: 5baeb23700d275b2a6c678b807756ff3536d638b782c4a26f44236fd3b9e9037d6b46c5c09b76b87e19f3cffaa668c5f221a395b8f2ba37a9a026c17ebc2fccc
-  data.tar.gz: cd428da5241f00f831080af924ef7fd2a066699c9805272727dbe32eb7672c90d6fbd1bbf6d3cae8dffc99f472d8dfb721b6558d78e64808b2a1319b7a78aa01
+  metadata.gz: f57d6abe6fdac34effcac8e52c889142828bf405f915239526fe6540ccb2fe138e79f972536e79a1c5dc7ab4de1871030900d0b2a0118325049d316bd5e534f7
+  data.tar.gz: b9135ee6741e0105df6e5f4a92c5c3ea660e10be525aca983d2b0d7f509f80d61216fcc32d340f678c3e1ca7ab91da70d4a436a6c45ce6b956d48cf8105097c8

data/.github/workflows/test.yml

@@ -20,6 +20,7 @@ jobs:
           - '3.2'
           - '3.3'
           - '3.4'
+          - '4.0'
           - ruby-head
           - jruby
           - truffleruby

data/CHANGELOG.md

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

data/Gemfile

@@ -16,10 +16,11 @@ gem 'mutex_m'
 
 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

data/lib/haml/attribute_parser.rb

@@ -8,8 +8,7 @@ module Haml
 
     # @return [TrueClass, FalseClass] - 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?
+      Temple::StaticAnalyzer.available?
     end
 
     def self.parse(text)

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]

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,

data/lib/haml/parser.rb

@@ -688,8 +688,17 @@ module Haml
         #
         # 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, ?{)
+        #
+        # 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.
+
+        attributes_hash, rest = balance_tokens(
+          text.sub(?{, METHOD_CALL_PREFIX),
+          [:on_lbrace, :on_tlambeg, :on_embexpr_beg],
+          [:on_rbrace, :on_embexpr_end],
+          count: 1)
+        attributes_hash = attributes_hash.sub(METHOD_CALL_PREFIX, ?{)
       rescue SyntaxError => e
         if e.message == Error.message(:unbalanced_brackets) && !@template.empty?
           text << "\n#{@next_line.text}"
@@ -850,10 +859,9 @@ module Haml
       text = ''.dup
       Ripper.lex(buf).each do |_, token, str|
         text << str
-        case token
-        when start
+        if start.include?(token)
           count += 1
-        when finish
+        elsif finish.include?(token)
           count -= 1
         end
 

data/lib/haml/string_splitter.rb

@@ -1,139 +1,129 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'ripper'
 
 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)
+    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
+      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
+      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]
+      end
+
+      def compile_tokens!(exps, tokens)
+        beg_str, end_str = strip_quotes!(tokens)
+
+        until tokens.empty?
+          _, type, str = tokens.shift
 
-          _, type, end_str = tokens.pop
-          if type != :on_tstring_end
-            raise(Haml::InternalError, "Expected :on_tstring_end but got: #{type}")
+          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?
           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 compile_tokens!(exps, tokens)
-          beg_str, end_str = strip_quotes!(tokens)
+      def shift_balanced_embexpr(tokens)
+        String.new.tap do |embedded|
+          embexpr_open = 1
 
           until tokens.empty?
             _, type, str = tokens.shift
-
             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?
+              embexpr_open += 1
+            when :on_embexpr_end
+              embexpr_open -= 1
+              break if embexpr_open == 0
             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
+            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
+    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
-        temple
       end
+      temple
+    end
 
-      private
+    private
 
-      def string_literal?(code)
-        return false if SyntaxChecker.syntax_error?(code)
+    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 = Ripper.sexp(code)
+      return false if type != :program
+      return false if instructions.size > 1
 
-        type, _ = instructions.first
-        type == :string_literal
-      end
+      type, _ = instructions.first
+      type == :string_literal
+    end
 
-      class SyntaxChecker < Ripper
-        class ParseError < StandardError; end
+    class SyntaxChecker < Ripper
+      class ParseError < StandardError; end
 
-        def self.syntax_error?(code)
-          self.new(code).parse
-          false
-        rescue ParseError
-          true
-        end
+      def self.syntax_error?(code)
+        self.new(code).parse
+        false
+      rescue ParseError
+        true
+      end
 
-        private
+      private
 
-        def on_parse_error(*)
-          raise ParseError
-        end
-      end
-    else
-      # Do nothing if ripper is unavailable
-      def call(ast)
-        ast
+      def on_parse_error(*)
+        raise ParseError
       end
     end
   end

data/lib/haml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 7.2.0
+  version: 7.2.2
 platform: ruby
 authors:
 - Natalie Weizenbaum