let tag init

Author: karreiro

.rubocop_todo.yml

@@ -91,6 +91,7 @@ Naming/ConstantName:
     - 'lib/liquid/tags/cycle.rb'
     - 'lib/liquid/tags/for.rb'
     - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/tags/let.rb'
     - 'lib/liquid/tags/raw.rb'
     - 'lib/liquid/tags/table_row.rb'
     - 'lib/liquid/variable.rb'

.ruby-version

@@ -1 +1 @@
-3.4.1
+3.3

artifacts/stewardship/2026-02-25T2234-let-tag-re-review.md

@@ -0,0 +1,110 @@
+**Re-Review: Liquid `let` tag -- Commit 56c35dfb**
+
+## Precedent Gathered
+
+### Reference Files
+| File | Why Selected | Key Patterns |
+|------|--------------|--------------|
+| `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/assign.rb` | Closest sibling tag (variable assignment) | YARD `@liquid_public_docs` block, `Syntax` constant, `assign_score_of`, `ParseTreeVisitor` |
+| `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/capture.rb` | Block-scoped variable tag | YARD docs, `Block#render` indirection, `has_let?` gating |
+| `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/if.rb` | Block tag with `render_body` pattern | `render_body` helper, `has_let?` check, `context.stack` |
+| `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/case.rb` | Block tag with `render_body` pattern | Identical `render_body` to `if.rb` |
+| `/Users/karreiro/src/github.com/Shopify/liquid/.rubocop_todo.yml` | RuboCop exclusions registry | Alphabetical ordering within `Naming/ConstantName` |
+| `/Users/karreiro/src/github.com/Shopify/liquid/test/unit/parse_tree_visitor_test.rb` | Existing `Style/SymbolProc` disable pattern | Line 269: `# rubocop:disable Style/SymbolProc` |
+
+---
+
+## Verification of Claimed Fixes
+
+### Finding #1: YARD Documentation on `let.rb`
+
+**Precedent:** `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/assign.rb:4-19` uses the `@liquid_public_docs` block with `@liquid_type`, `@liquid_category`, `@liquid_name`, `@liquid_summary`, `@liquid_description`, `@liquid_syntax`, and `@liquid_syntax_keyword` annotations, placed immediately before the class declaration.
+
+**New code:** `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/let.rb:4-17` now has a `@liquid_public_docs` block with the same annotation structure: `@liquid_type tag`, `@liquid_category variable`, `@liquid_name let`, `@liquid_summary`, `@liquid_description`, `@liquid_syntax`, and `@liquid_syntax_keyword` entries.
+
+**Verdict:** Consistent. The annotation ordering matches `assign.rb` and `capture.rb`. Category is `variable`, matching the other variable-family tags (`assign`, `capture`).
+
+---
+
+### Finding #2: `.rubocop_todo.yml` Exclusion for `let.rb`
+
+**Precedent:** `/Users/karreiro/src/github.com/Shopify/liquid/.rubocop_todo.yml:84-100` lists `Naming/ConstantName` exclusions in alphabetical order: `assign.rb`, `capture.rb`, `case.rb`, `cycle.rb`, `for.rb`, `if.rb`, ... `raw.rb`, `table_row.rb`.
+
+**New code:** `/Users/karreiro/src/github.com/Shopify/liquid/.rubocop_todo.yml:94` inserts `lib/liquid/tags/let.rb` between `if.rb` (line 93) and `raw.rb` (line 95).
+
+**Verdict:** Consistent. Alphabetical ordering is preserved.
+
+---
+
+### Finding #6: `capture.rb` Else Branch -- `render(context)` Indirection
+
+**Precedent:** `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/block.rb:20-22` defines `Block#render(context)` as a backwards-compatibility wrapper that delegates to `@body.render(context)`. The original `capture.rb` used `render(context)` in its else branch prior to the `let` feature, preserving this indirection layer.
+
+**New code:** `/Users/karreiro/src/github.com/Shopify/liquid/lib/liquid/tags/capture.rb:39` uses `render(context)` in the else branch (when `has_let?` is false), while the `has_let?` branch on line 37 uses `context.stack { @body.render(context) }`.
+
+**Verdict:** Consistent. The else branch preserves the `Block#render` indirection for the non-`let` path, matching the original behavior. The `has_let?` branch correctly adds `context.stack` wrapping.
+
+**Note:** The `if.rb` and `case.rb` tags use a different pattern for their else branches -- they call `body.render_to_output_buffer(context, output)` directly. This difference is expected because `capture.rb` needs to capture output as a string (via `@body.render(context)` which returns a string), while `if.rb`/`case.rb` write directly to an output buffer. The patterns are structurally different for a valid reason.
+
+---
+
+### RuboCop Fix: `Style/RegexpLiteral` in `let_tag_test.rb`
+
+**New code:** `/Users/karreiro/src/github.com/Shopify/liquid/test/integration/tags/let_tag_test.rb:125` uses `%r{</tr>\d}` instead of `/<\/tr>\d/`.
+
+**Verdict:** Consistent with RuboCop's `Style/RegexpLiteral` rule. The `%r{}` form is the correct way to avoid escaping forward slashes.
+
+---
+
+### RuboCop Fix: `Style/SymbolProc` Disable in `let_tag_unit_test.rb`
+
+**Precedent:** `/Users/karreiro/src/github.com/Shopify/liquid/test/unit/parse_tree_visitor_test.rb:269` uses the identical pattern:
+```ruby
+.add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
+```
+
+**New code:** `/Users/karreiro/src/github.com/Shopify/liquid/test/unit/tags/let_tag_unit_test.rb:61` uses:
+```ruby
+.add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
+```
+
+**Verdict:** Identical to precedent. The disable comment is justified: `add_callback_for` invokes the block with `(node, context)`, so `&:name` would pass both arguments to `Symbol#to_proc`, which only expects `self`. The block form is necessary.
+
+---
+
+## Non-Blocking Items (Confirmed Acknowledged)
+
+| Finding | Reason Not Changed | Assessment |
+|---------|--------------------|------------|
+| #3: `assign_score_of` duplication | No extraction pattern exists in codebase | Correct -- duplication matches `assign.rb` exactly |
+| #4: `has_let?` naming | `Naming/PredicatePrefix` disabled in `.rubocop_todo.yml:183-184` | Correct -- not enforceable |
+| #5: `render_body` duplication in `if.rb`/`case.rb` | No extraction pattern exists | Correct -- both tags define identical private methods |
+| #7: Category separator comments in tests | Cosmetic; no enforced convention | Correct -- harmless |
+
+---
+
+## Findings
+
+| Deviation | Status |
+|-----------|--------|
+| Finding #1 (YARD docs) | **Resolved** -- matches `assign.rb`/`capture.rb` pattern |
+| Finding #2 (`.rubocop_todo.yml`) | **Resolved** -- alphabetically correct |
+| Finding #6 (`render(context)` indirection) | **Resolved** -- preserves `Block#render` wrapper |
+| RuboCop `Style/RegexpLiteral` | **Resolved** -- `%r{}` form correct |
+| RuboCop `Style/SymbolProc` | **Resolved** -- matches `parse_tree_visitor_test.rb:269` |
+
+**Total remaining deviations from established patterns:** 0
+
+---
+
+## Ambiguities
+
+None -- patterns are consistent.
+
+---
+
+## Verdict
+
+**APPROVED.**
+
+All blocking deviations from the original review have been addressed. Each fix is verified against existing codebase precedent. The non-blocking items were correctly identified as acceptable and left unchanged. Test suite passes with 0 failures and RuboCop reports 0 offenses.

bin/try

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'liquid'
+
+assigns = {}
+
+puts Liquid::Template.parse('{{ 1 | plus: 2 }}').render(assigns)

lib/liquid.rb

@@ -82,6 +82,8 @@ module Liquid
 require 'liquid/expression'
 require 'liquid/template'
 require 'liquid/condition'
+require 'liquid/object_literal'
+require 'liquid/array_literal'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'

lib/liquid/array_literal.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ArrayLiteral
+    attr_reader :entries
+
+    def initialize(entries)
+      @entries = entries
+    end
+
+    def evaluate(context)
+      result = []
+
+      @entries.each do |entry|
+        case entry[0]
+        when :element
+          value_expr = entry[1]
+          result << context.evaluate(value_expr)
+        when :spread
+          expr = entry[1]
+          value = context.evaluate(expr)
+
+          if value.is_a?(Array)
+            result.concat(value)
+          elsif value.respond_to?(:to_spread)
+            spread_result = value.to_spread
+            unless spread_result.is_a?(Array)
+              raise Liquid::ArgumentError, "to_spread must return an Array for array spread, got #{spread_result.class}"
+            end
+
+            result.concat(spread_result)
+          else
+            raise Liquid::ArgumentError, "Cannot spread a non-array value into an array literal (#{value.class})"
+          end
+        end
+      end
+
+      result
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.entries.map { |entry| entry[1] }
+      end
+    end
+  end
+end

lib/liquid/block_body.rb

@@ -17,6 +17,7 @@ class BlockBody
     def initialize
       @nodelist = []
       @blank    = true
+      @has_let  = false
     end
 
     def parse(tokenizer, parse_context, &block)
@@ -36,6 +37,10 @@ def freeze
       super
     end
 
+    def has_let?
+      @has_let
+    end
+
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
         unless token.empty? || token.match?(WhitespaceOrNothing)
@@ -60,6 +65,7 @@ def freeze
           new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
           @blank &&= new_tag.blank?
           @nodelist << new_tag
+          @has_let = true if new_tag.is_a?(Let)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -155,6 +161,7 @@ def self.rescue_render_node(context, output, line_number, exc, blank_tag)
           new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
           @blank &&= new_tag.blank?
           @nodelist << new_tag
+          @has_let = true if new_tag.is_a?(Let)
         when token.start_with?(VARSTART)
           whitespace_handler(token, parse_context)
           @nodelist << create_variable(token, parse_context)

lib/liquid/lexer.rb

@@ -2,6 +2,7 @@
 
 module Liquid
   class Lexer
+    CLOSE_CURLY = [:close_curly, "}"].freeze
     CLOSE_ROUND = [:close_round, ")"].freeze
     CLOSE_SQUARE = [:close_square, "]"].freeze
     COLON = [:colon, ":"].freeze
@@ -22,12 +23,14 @@ class Lexer
     EOS = [:end_of_string].freeze
     IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
     NUMBER_LITERAL        = /-?\d+(\.\d+)?/
+    OPEN_CURLY = [:open_curly, "{"].freeze
     OPEN_ROUND = [:open_round, "("].freeze
     OPEN_SQUARE = [:open_square, "["].freeze
     PIPE = [:pipe, "|"].freeze
     QUESTION = [:question, "?"].freeze
     RUBY_WHITESPACE = [" ", "\t", "\r", "\n", "\f"].freeze
     SINGLE_STRING_LITERAL = /'[^\']*'/
+    SPREAD = [:spread, "..."].freeze
     WHITESPACE_OR_NOTHING = /\s*/
 
     SINGLE_COMPARISON_TOKENS = [].tap do |table|
@@ -89,6 +92,8 @@ class Lexer
       table[")".ord] = CLOSE_ROUND
       table["?".ord] = QUESTION
       table["-".ord] = DASH
+      table["{".ord] = OPEN_CURLY
+      table["}".ord] = CLOSE_CURLY
     end
 
     NUMBER_TABLE = [].tap do |table|
@@ -113,10 +118,15 @@ def tokenize(ss)
 
           if (special = SPECIAL_TABLE[peeked])
             ss.scan_byte
-            # Special case for ".."
+            # Special case for ".." and "..."
             if special == DOT && ss.peek_byte == DOT_ORD
               ss.scan_byte
-              output << DOTDOT
+              if ss.peek_byte == DOT_ORD
+                ss.scan_byte
+                output << SPREAD
+              else
+                output << DOTDOT
+              end
             elsif special == DASH
               # Special case for negative numbers
               if (peeked_byte = ss.peek_byte) && NUMBER_TABLE[peeked_byte]

lib/liquid/locales/en.yml

@@ -4,6 +4,9 @@
       tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
       block_tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: {% %{tag} %}{% end%{tag} %}"
       assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
+      let: "Syntax Error in 'let' - Valid syntax: let [var] = [expression]"
+      let_object: "Syntax Error in 'let' - Invalid object literal syntax"
+      let_array: "Syntax Error in 'let' - Invalid array literal syntax"
       capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
       case: "Syntax Error in 'case' - Valid syntax: case [condition]"
       case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"

lib/liquid/object_literal.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ObjectLiteral
+    attr_reader :entries
+
+    def initialize(entries)
+      @entries = entries
+    end
+
+    def evaluate(context)
+      result = {}
+
+      @entries.each do |entry|
+        case entry[0]
+        when :pair
+          key = entry[1]
+          value_expr = entry[2]
+          result[key] = context.evaluate(value_expr)
+        when :spread
+          expr = entry[1]
+          value = context.evaluate(expr)
+
+          if value.is_a?(Hash)
+            result.merge!(value)
+          elsif value.respond_to?(:to_spread)
+            spread_result = value.to_spread
+            unless spread_result.is_a?(Hash)
+              raise Liquid::ArgumentError, "to_spread must return a Hash for object spread, got #{spread_result.class}"
+            end
+            result.merge!(spread_result)
+          else
+            raise Liquid::ArgumentError, "Cannot spread a non-hash value into an object literal (#{value.class})"
+          end
+        end
+      end
+
+      result
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.entries.map { |entry| entry[0] == :pair ? entry[2] : entry[1] }
+      end
+    end
+  end
+end