twig_ruby 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48285eaf20e2ccc979242da5a4441263cfc17cbf8acdec2e4f7e28ce22b21f5d
-  data.tar.gz: e2e60724e210affecd7bb85075e1f21190ad224e15c9f4bbc581a49f58c6fb76
+  metadata.gz: 0c74aeae1c40b1a21026a07bf01374c5065997a0005025d5bd208111736d455b
+  data.tar.gz: 9e50006a3dceda02a14e3c2f0c5098480eb7f527d55152671d1dc2c0a5d3d871
 SHA512:
-  metadata.gz: 9107303138c19f49920a2c969b1ce45623ce0e7ce2013ec98ebab9e1204bf66b97898bd3158ad289d441c555dfc7ecd26f40669ae2a77c85511d23204ef02eb5
-  data.tar.gz: a202be7e8ef2c866fbe1c669d206e2e5a1647aa58947f5fa62176b6aaf608431e061075c4568679c93b1555d9ea86d993231874f6cc59b3d768b703eb45f520f
+  metadata.gz: dd3aa6fe4c411313f4ebaad61001870ccbf0c6fd4c9029941233e6f562c1a6c2d20142394bd80ac46bd8fefb727cece46a73353b7c2a90750d5f31c8a3bde335
+  data.tar.gz: 2dbb3fd08c278d2413de33d8a2b995dab7b40fa0f0ab7c4cbb2df1491d8db36f7ef66352ab434f0aec32e40d95687f669074a22a14875f11c02720fab64ec300

data/lib/twig/extension/core.rb

@@ -5,6 +5,10 @@ module Twig
     class Core < Base
       DEFAULT_TRIM_CHARS = " \t\n\r\0\x0B"
 
+      # Returned by subscript_key when nothing matched. A sentinel rather than
+      # nil, because nil is a perfectly good hash key and a perfectly good value.
+      KEY_NOT_FOUND = Object.new.freeze
+
       class << self
         include ActiveSupport::NumberHelper
       end
@@ -860,25 +864,64 @@ module Twig
         raise Error::Runtime, "Invalid regular expression passed to matches: #{e.message}"
       end
 
+      # The key or index that +attribute+ matches on a subscriptable object, or
+      # KEY_NOT_FOUND when it matches none.
+      #
+      # Returning the key rather than the value is the point: it lets the caller
+      # subscript exactly once. Fetching first and testing the result instead —
+      # as `object[attribute] || object[attribute.to_s]` did — can't tell a key
+      # holding nil or false from a key that isn't there, so { 'billable' =>
+      # false } came back as nil.
+      #
+      # @return [Object] the matching key, or KEY_NOT_FOUND
+      def self.subscript_key(object, attribute)
+        if object.is_a?(Array)
+          return KEY_NOT_FOUND unless attribute.is_a?(Integer)
+
+          # Ruby indexes from the end with a negative, so -1 is the last element
+          # while anything below -length is as absent as anything above length.
+          in_bounds = attribute >= -object.length && attribute < object.length
+
+          return in_bounds ? attribute : KEY_NOT_FOUND
+        end
+
+        return KEY_NOT_FOUND unless object.respond_to?(:key?)
+        return attribute if object.key?(attribute)
+
+        # A template writes h.foo, h['foo'] and h[:foo] for the same Ruby hash,
+        # so both forms of the name count as a match.
+        symbol = attribute.to_sym if attribute.respond_to?(:to_sym)
+        return symbol if !symbol.nil? && object.key?(symbol)
+
+        string = attribute.to_s if attribute.respond_to?(:to_s)
+        return string if !string.nil? && object.key?(string)
+
+        KEY_NOT_FOUND
+      end
+
+      # Names the keys that do exist rather than dumping the object, which for
+      # anything the size of a request's parameters buries the one absent key
+      # under everything else.
+      #
+      # @return [String]
+      def self.key_not_found_message(object, attribute)
+        keys = object.respond_to?(:keys) ? " with keys \"#{object.keys.join(', ')}\"" : ''
+
+        "Key \"#{attribute}\" for sequence/mapping#{keys} does not exist."
+      end
+
       # @param [Environment] environment
       def self.get_attribute(
         environment, source, object, attribute, type, arguments: {}, defined_test: false,
         ignore_strict_check: false, lineno: -1, &
       )
         if type == Template::ARRAY_CALL || object.respond_to?(:[])
-          if object.respond_to?(:[]) && (
-            (object.is_a?(Array) && attribute.is_a?(Integer) && attribute < object.length) ||
-            (
-              object.respond_to?(:key?) && (
-                object.key?(attribute) ||
-                (attribute.respond_to?(:to_sym) && object.key?(attribute.to_sym)) ||
-                  (attribute.respond_to?(:to_s) && object.key?(attribute.to_s))
-              )
-            )
-          )
+          key = object.respond_to?(:[]) ? subscript_key(object, attribute) : KEY_NOT_FOUND
+
+          unless key.equal?(KEY_NOT_FOUND)
             return true if defined_test
 
-            return object[attribute] || (attribute.is_a?(String) ? object[attribute.to_sym] : object[attribute.to_s])
+            return object[key]
           end
 
           if type == Template::ARRAY_CALL
@@ -890,7 +933,11 @@ module Twig
               return
             end
 
-            raise Error::Runtime, "Can't find key #{attribute} in #{object.inspect}."
+            raise Error::Runtime.new(
+              key_not_found_message(object, attribute),
+              lineno,
+              source
+            )
           end
         end
 
@@ -925,19 +972,22 @@ module Twig
 
           kwargs = kwargs.transform_keys(&:to_sym)
 
+          # public_send, not send: respond_to? above already excludes private and
+          # protected methods, but an object with a loose respond_to_missing?
+          # can report true for one. Templates only reach the public interface.
           if positional.length.positive? && kwargs.empty?
-            object.send(attribute, *positional, &)
+            object.public_send(attribute, *positional, &)
           elsif positional.empty? && kwargs.length.positive?
-            object.send(attribute, **kwargs, &)
+            object.public_send(attribute, **kwargs, &)
           elsif positional.length.positive? && kwargs.length.positive?
-            object.send(attribute, *positional, **kwargs, &)
+            object.public_send(attribute, *positional, **kwargs, &)
           else
-            case object
-            when Hash, Array
-              object[attribute]
-            else
-              object.send(attribute, &)
-            end
+            # Reached only when the object responds to the attribute and the
+            # key/index lookup above did not match, so subscripting a Hash or
+            # Array here could only ever miss — it raised TypeError on arrays
+            # ({{ list.any? }}) and returned nil on hashes, silently rendering
+            # nothing. Collections dispatch methods like any other object.
+            object.public_send(attribute, &)
           end
         # Constant could be nil but we should return if we find it
         elsif (constant = get_constant(object, attribute.to_s)) && constant[0] == :found
@@ -952,8 +1002,7 @@ module Twig
           message = if object.nil?
                       "Impossible to access an attribute (\"#{attribute}\") on a null variable."
                     elsif object.respond_to?(:[]) && !object.is_a?(String)
-                      keys = object.respond_to?(:keys) ? "with keys \"#{object.keys.join(', ')}\"" : ''
-                      "Key \"#{attribute}\" for sequence/mapping #{keys} does not exist."
+                      key_not_found_message(object, attribute)
                     else
                       "Impossible to access an attribute (\"#{attribute}\") on a #{object.class} " \
                         "variable (\"#{object}\")."

data/lib/twig/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Twig
+  VERSION = '0.0.9'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twig_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Craig Blanchette
 - Fabian Potencier
 bindir: bin
 cert_chain: []
-date: 2025-12-17 00:00:00.000000000 Z
+date: 2026-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -217,6 +217,7 @@ files:
 - lib/twig/twig_function.rb
 - lib/twig/twig_test.rb
 - lib/twig/util/callable_arguments_extractor.rb
+- lib/twig/version.rb
 - lib/twig_ruby.rb
 homepage: https://rubygems.org/gems/twig-ruby
 licenses: