temple 0.10.4 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eedd92f18dc086c241e1163c104e1929477068901992a5b56a36783ddbe2b71
-  data.tar.gz: 87ad60cdfa2a9fbca8c2e499e3dd0ca4b54143cc4e04bbfc07f810bc085a2fdb
+  metadata.gz: 36199c665624018e6c8bfec5ff6d1e19bcd8015ee4aeedd7800b264136227b7b
+  data.tar.gz: f70ee914c911f6f7ad17c84f81fd88dc5cc6d974c37b2d773995bbcc03b17c5b
 SHA512:
-  metadata.gz: 169be5abf462523cc50b21b8b1f5ad16e32dd24d8864a7a0d7c69599224d7f62f5ac939cb3da4db733b173653ac0ee227dfc2dbf8d5d236cc8b507af56dce8bd
-  data.tar.gz: d34651062a8d38fbfeaa22a6f92df88b9cddaf821b7fecb506a4e7f9cbee9ce5fa06c42e5f8d1dee56e5987a2d390583a1188c7577ad90354737f49d4e435404
+  metadata.gz: f3661349e66534eaed2be550577677c3a4457ed0fe4e2ec5c3b8a6dced46fa45d5aa6be774662cf84186ead6954ebcb51ff53357abf93c64093b559fb22f22ec
+  data.tar.gz: 4e81de0ec56c60964b9363bf87b270191a39d19a0fd0710dc9e07b0baaadf273a8a84d6c37a733edd55ab55f90bba7d4a1b676b50817f1ba1566efdb29e8a911

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

@@ -25,10 +25,11 @@ jobs:
           - '3.2'
           - '3.3'
           - '3.4'
+          - '4.0'
           - jruby
           - truffleruby-head
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/CHANGES

@@ -1,3 +1,11 @@
+0.10.6
+
+  * Make StaticAnalyzer recognize shorthand syntax as dynamic (#149)
+
+0.10.5
+
+  * Allow using prism as the parser engine (#156)
+
 0.10.4
 
   * Fix Ruby 3.4 compatibility (#152)

data/README.md

@@ -1,7 +1,7 @@
 Temple
 ======
 
-[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
+[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Maintainability](https://qlty.sh/gh/judofyr/projects/temple/maintainability.svg)](https://qlty.sh/gh/judofyr/projects/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
 
 Temple is an abstraction and a framework for compiling templates to pure Ruby.
 It's all about making it easier to experiment, implement and optimize template

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,146 @@
 # 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
-
-    DYNAMIC_TOKENS = [
-      :on_ident, :on_period,
-    ].freeze
-
-    STATIC_KEYWORDS = [
-      'true', 'false', 'nil',
-    ].freeze
-
-    STATIC_OPERATORS = [
-      '=>',
-    ].freeze
-
-    class << self
-      def available?
-        defined?(Ripper) && Ripper.respond_to?(:lex)
-      end
+    if PARSER_ENGINE == :prism
+      class << self
+        def available?
+          true
+        end
+
+        def static?(code)
+          return false if code.nil? || code.strip.empty?
+          (result = Prism.parse(code)).success? && static_node?(result.value)
+        end
+
+        def syntax_error?(code)
+          !Prism.parse_success?(code)
+        end
+
+        private
 
-      def static?(code)
-        return false if code.nil? || code.strip.empty?
-        return false if 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
+        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
-            return false
+            false
           end
         end
-        true
       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 syntax_error?(code)
-        SyntaxChecker.new(code).parse
-        false
-      rescue SyntaxChecker::ParseError
-        true
-      end
-    end
+      DYNAMIC_TOKENS = [
+        :on_ident, :on_period,
+      ].freeze
 
-    if defined?(Ripper)
-      class SyntaxChecker < Ripper
-        class ParseError < StandardError; end
+      STATIC_KEYWORDS = [
+        'true', 'false', 'nil',
+      ].freeze
 
-        private
+      STATIC_OPERATORS = [
+        '=>',
+      ].freeze
+
+      class << self
+        def available?
+          true
+        end
 
-        def on_parse_error(*)
-          raise ParseError
+        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
+
+          !ShorthandSyntaxChecker.shorthand?(code)
+        end
+
+        def syntax_error?(code)
+          SyntaxChecker.new(code).parse
+          false
+        rescue SyntaxChecker::ParseError
+          true
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+
+        class ShorthandSyntaxChecker < Ripper
+          class << self
+            def shorthand?(code)
+              instance = new(code)
+              instance.parse
+              instance.shorthand
+            end
+          end
+
+          attr_reader :shorthand
+
+          def initialize(*)
+            super
+            @shorthand = nil
+          end
+
+          private
+
+          def on_assoc_new(key, value)
+            @shorthand = true if value.nil?
+          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.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: temple
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.6
 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