temple 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eedd92f18dc086c241e1163c104e1929477068901992a5b56a36783ddbe2b71
-  data.tar.gz: 87ad60cdfa2a9fbca8c2e499e3dd0ca4b54143cc4e04bbfc07f810bc085a2fdb
+  metadata.gz: 991a0b24405b8214645f3587f421886aa2f70d5e1dcb7a60e63174e8314bf0cd
+  data.tar.gz: 04ab064c8aa17d4baf2457cc6f97ae4f71ee801eeaa50ad0e2a1b4537e953bbc
 SHA512:
-  metadata.gz: 169be5abf462523cc50b21b8b1f5ad16e32dd24d8864a7a0d7c69599224d7f62f5ac939cb3da4db733b173653ac0ee227dfc2dbf8d5d236cc8b507af56dce8bd
-  data.tar.gz: d34651062a8d38fbfeaa22a6f92df88b9cddaf821b7fecb506a4e7f9cbee9ce5fa06c42e5f8d1dee56e5987a2d390583a1188c7577ad90354737f49d4e435404
+  metadata.gz: ba9e9141c61962b62b87247a77e70415145681ed35b590ba649781750098813597c40a334d45cfe7e3ae24a15cfe1d09ee32f6788c1aa600851432a8b6fe2c60
+  data.tar.gz: 88b97523630a72fa8d61d46a8e857cb3aaa26db025f0f919a52afef3b89fb372f89f3dafdfa4f2ce18a3c823003fad985f1a5d6516bbf8c63223f26a0159e302

data/.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  push:
+    if: github.repository_owner == 'judofyr'
+    runs-on: ubuntu-latest
+
+    environment:
+      name: rubygems.org
+      url: https://rubygems.org/gems/temple
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@f4a75cfd619ee5ce8d5b864b0d183aff3c69b55a # v2.13.1
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@eaecf785f6a34567a6d97f686bbb7bccc1ac1e5c # v1.237.0
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      - name: Publish to RubyGems
+        uses: rubygems/release-gem@a25424ba2ba8b387abc8ef40807c2c85b96cbe32 # v1.1.1
+
+      - name: Create GitHub release
+        run: |
+          tag_name="$(git describe --tags --abbrev=0)"
+          gh release create "${tag_name}" --verify-tag --generate-notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.github/workflows/test.yml

@@ -28,7 +28,7 @@ jobs:
           - jruby
           - truffleruby-head
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/CHANGES

@@ -1,3 +1,7 @@
+0.10.5
+
+  * Allow using prism as the parser engine (#156)
+
 0.10.4
 
   * Fix Ruby 3.4 compatibility (#152)

data/lib/temple/filters/static_analyzer.rb

@@ -4,7 +4,7 @@ module Temple
     # Convert [:dynamic, code] to [:static, text] if code is static Ruby expression.
     class StaticAnalyzer < Filter
       def call(exp)
-        # Optimize only when Ripper is available.
+        # Optimize only when a parser engine is available.
         if ::Temple::StaticAnalyzer.available?
           super
         else

data/lib/temple/filters/string_splitter.rb

@@ -1,14 +1,70 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'temple/parser_engine'
 
 module Temple
   module Filters
     # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
     class StringSplitter < Filter
-      if defined?(Ripper) && Ripper.respond_to?(:lex)
+      if PARSER_ENGINE == :prism
+        class << self
+          # `code` param must be valid string literal
+          def compile(code)
+            compiled = try_compile(code)
+            raise(FilterError, "Expected string literal") unless compiled
+            compiled
+          end
+
+          def try_compile(code)
+            result = Prism.parse(code)
+            return unless result.success?
+
+            stmts = result.value.statements.body
+            return if stmts.size != 1
+
+            stack = [stmts.first]
+            compiled = []
+
+            until stack.empty?
+              case (node = stack.pop).type
+              when :interpolated_string_node
+                stack.concat(node.parts.reverse)
+              when :string_node
+                if !(unescaped = node.unescaped).empty?
+                  compiled << [:static, unescaped]
+                end
+              when :embedded_statements_node
+                if (stmts = node.statements) && !(slice = stmts.slice).empty?
+                  compiled << [:dynamic, slice]
+                end
+              when :embedded_variable_node
+                compiled << [:dynamic, node.variable.slice]
+              else
+                return
+              end
+            end
+
+            compiled
+          end
+        end
+
+        def on_dynamic(code)
+          return [:dynamic, code] if code.include?("\n")
+
+          compiled = StringSplitter.try_compile(code)
+          return [:dynamic, code] unless compiled
+
+          temple = [:multi]
+          compiled.each do |type, content|
+            case type
+            when :static
+              temple << [:static, content]
+            when :dynamic
+              temple << on_dynamic(content)
+            end
+          end
+          temple
+        end
+      elsif PARSER_ENGINE == :ripper
         class << self
           # `code` param must be valid string literal
           def compile(code)

data/lib/temple/parser_engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Temple
+  temple_parser_engine = ENV['TEMPLE_PARSER_ENGINE']
+
+  prism_available =
+    if !temple_parser_engine || temple_parser_engine == 'prism'
+      begin
+        require 'prism'
+        true
+      rescue LoadError
+      end
+    end
+
+  ripper_available =
+    if !temple_parser_engine || temple_parser_engine == 'ripper'
+      begin
+        require 'ripper'
+        Ripper.respond_to?(:lex)
+      rescue LoadError
+      end
+    end
+
+  PARSER_ENGINE =
+    if prism_available
+      :prism
+    elsif ripper_available
+      :ripper
+    else
+      :none
+    end
+
+  private_constant :PARSER_ENGINE
+end

data/lib/temple/static_analyzer.rb

@@ -1,76 +1,122 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'temple/parser_engine'
 
 module Temple
   module StaticAnalyzer
-    STATIC_TOKENS = [
-      :on_tstring_beg, :on_tstring_end, :on_tstring_content,
-      :on_embexpr_beg, :on_embexpr_end,
-      :on_lbracket, :on_rbracket,
-      :on_qwords_beg, :on_words_sep, :on_qwords_sep,
-      :on_lparen, :on_rparen,
-      :on_lbrace, :on_rbrace, :on_label,
-      :on_int, :on_float, :on_imaginary,
-      :on_comma, :on_sp, :on_ignored_nl,
-    ].freeze
+    if PARSER_ENGINE == :prism
+      class << self
+        def available?
+          true
+        end
 
-    DYNAMIC_TOKENS = [
-      :on_ident, :on_period,
-    ].freeze
+        def static?(code)
+          return false if code.nil? || code.strip.empty?
+          (result = Prism.parse(code)).success? && static_node?(result.value)
+        end
 
-    STATIC_KEYWORDS = [
-      'true', 'false', 'nil',
-    ].freeze
+        def syntax_error?(code)
+          !Prism.parse_success?(code)
+        end
 
-    STATIC_OPERATORS = [
-      '=>',
-    ].freeze
+        private
 
-    class << self
-      def available?
-        defined?(Ripper) && Ripper.respond_to?(:lex)
+        def static_node?(node)
+          case node.type
+          when :program_node
+            static_node?(node.statements)
+          when :parentheses_node
+            (stmts = node.body).is_a?(Prism::StatementsNode) &&
+              static_node?(stmts)
+          when :statements_node
+            node.body.size == 1 && static_node?(node.body.first)
+          when :interpolated_string_node
+            node.parts.all? { |part| static_node?(part) }
+          when :embedded_statements_node
+            (stmts = node.statements) && static_node?(stmts)
+          when :array_node
+            node.elements.all? { |elem| static_node?(elem) }
+          when :hash_node, :keyword_hash_node
+            node.elements.all? { |elem| static_node?(elem) }
+          when :assoc_node
+            static_node?(node.key) && static_node?(node.value)
+          when :string_node, :integer_node, :float_node, :imaginary_node,
+               :rational_node, :symbol_node, :true_node, :false_node, :nil_node
+            true
+          else
+            false
+          end
+        end
       end
+    elsif PARSER_ENGINE == :ripper
+      STATIC_TOKENS = [
+        :on_tstring_beg, :on_tstring_end, :on_tstring_content,
+        :on_embexpr_beg, :on_embexpr_end,
+        :on_lbracket, :on_rbracket,
+        :on_qwords_beg, :on_words_sep, :on_qwords_sep,
+        :on_lparen, :on_rparen,
+        :on_lbrace, :on_rbrace, :on_label,
+        :on_int, :on_float, :on_imaginary,
+        :on_comma, :on_sp, :on_ignored_nl,
+      ].freeze
 
-      def static?(code)
-        return false if code.nil? || code.strip.empty?
-        return false if syntax_error?(code)
+      DYNAMIC_TOKENS = [
+        :on_ident, :on_period,
+      ].freeze
 
-        Ripper.lex(code).each do |_, token, str|
-          case token
-          when *STATIC_TOKENS
-            # noop
-          when :on_kw
-            return false unless STATIC_KEYWORDS.include?(str)
-          when :on_op
-            return false unless STATIC_OPERATORS.include?(str)
-          when *DYNAMIC_TOKENS
-            return false
-          else
-            return false
+      STATIC_KEYWORDS = [
+        'true', 'false', 'nil',
+      ].freeze
+
+      STATIC_OPERATORS = [
+        '=>',
+      ].freeze
+
+      class << self
+        def available?
+          true
+        end
+
+        def static?(code)
+          return false if code.nil? || code.strip.empty? || syntax_error?(code)
+
+          Ripper.lex(code).each do |_, token, str|
+            case token
+            when *STATIC_TOKENS
+              # noop
+            when :on_kw
+              return false unless STATIC_KEYWORDS.include?(str)
+            when :on_op
+              return false unless STATIC_OPERATORS.include?(str)
+            when *DYNAMIC_TOKENS
+              return false
+            else
+              return false
+            end
           end
+          true
         end
-        true
-      end
 
-      def syntax_error?(code)
-        SyntaxChecker.new(code).parse
-        false
-      rescue SyntaxChecker::ParseError
-        true
-      end
-    end
+        def syntax_error?(code)
+          SyntaxChecker.new(code).parse
+          false
+        rescue SyntaxChecker::ParseError
+          true
+        end
 
-    if defined?(Ripper)
-      class SyntaxChecker < Ripper
-        class ParseError < StandardError; end
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
 
-        private
+          private
 
-        def on_parse_error(*)
-          raise ParseError
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+      end
+    else
+      class << self
+        def available?
+          false
         end
       end
     end

data/lib/temple/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Temple
-  VERSION = '0.10.4'
+  VERSION = '0.10.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: temple
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - Magnus Holm
 - Daniel Mendler
 bindir: bin
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 2026-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
@@ -73,6 +73,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".yardopts"
@@ -126,6 +127,7 @@ files:
 - lib/temple/mixins/options.rb
 - lib/temple/mixins/template.rb
 - lib/temple/parser.rb
+- lib/temple/parser_engine.rb
 - lib/temple/static_analyzer.rb
 - lib/temple/templates.rb
 - lib/temple/templates/rails.rb