haml 7.2.1 → 7.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4665a2a3c561765d35c0eeec78fdc87d2574cd640249089ace5035cc672e46f
-  data.tar.gz: 02146e70c4ace1a58a1598ccfe25b08a22f06d0aa0554244806b1593cce85caa
+  metadata.gz: def36fc38e0b0116356b085a4120ea0564c5624c766e03f705ec91d3657e2e8c
+  data.tar.gz: 937230d9bbf1ad0cbad38457d985bd964a5edd49137f31398fafad0aa474a8bf
 SHA512:
-  metadata.gz: 3b24e11afe577f0b175fca4ae8fe5bdc45ae245e2f654a6d832ac2c619e25f2aeefb700e5ba51742f22ad5e849cc06d8831ef2a2c30083aab7a2bab727fcfe01
-  data.tar.gz: ad77cc1be2d2831de2cbac2568efbc368fb1627626c19138e7059b120fb2e85c88057b8f9fb705c22f82b7d910497018e156acbc61691ce52db4de5d39a0e764
+  metadata.gz: f57d6abe6fdac34effcac8e52c889142828bf405f915239526fe6540ccb2fe138e79f972536e79a1c5dc7ab4de1871030900d0b2a0118325049d316bd5e534f7
+  data.tar.gz: b9135ee6741e0105df6e5f4a92c5c3ea660e10be525aca983d2b0d7f509f80d61216fcc32d340f678c3e1ca7ab91da70d4a436a6c45ce6b956d48cf8105097c8

data/CHANGELOG.md

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

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/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/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.1'
+  VERSION = '7.2.2'
 end

metadata

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