liquid2 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 474a8dc5c84a97344741bc74d459cc904f1da7025af450c834fb8d416eb98518
-  data.tar.gz: 2dda5436fd261f0208123baa7f7f917f2406531e0bf295db085528a8fa7a5baa
+  metadata.gz: 2e67530ac2094dea72ed04c893712aef94689789410799cc3c49145a71f07e0d
+  data.tar.gz: f979c17c7d0431c338935433080e2a63159c20b6feb109b36b43ccd06844b5e5
 SHA512:
-  metadata.gz: 489dd5089b45f07779de0ee25ee4a8fa5b028a8721bf1423a6ca6884ebde6647d36e9e9450e650c2816c1a63a5b6f1554d8e2d8fa7712c106792a3dbeefe0205
-  data.tar.gz: 7b5e904527625b34d0e177168abbd00198f393b303b9504ee68a37cda3a2f1ef7a407333b15dec96907271610ca715f0e08f49c695466f8f7ddff22a1056b6d4
+  metadata.gz: 0ca528ffffe3a9c272d5e60c2895793fdd9cc0b789633b3b4e06a57e0c8613630cb64882f0d7e9e6a1dfa3a87d26d702635ab52ea988b4afa9bbd085a05ee55f
+  data.tar.gz: 36c6a606564ce5da8ddf448948878804e1df279b9e569535c99f72db48ab6024b24be4a006894df5e5163a8f1a403b1785bcc2506629183dce2d452424349779

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.5.0] - 25-22-10
+
+- Improved array literal syntax. Arrays with square brackets are now allowed anywhere a value (literal or variable) is expected. See [#21](https://github.com/jg-rp/ruby-liquid2/issues/21) and `docs/composite_literals.md`.
+- Added object (aka hash) literal syntax. Like arrays, object literals are allowed anywhere a value (literal or variable) is expected. See `docs/composite_literals.md`.
+- Added the spread operator `...`. Like spread syntax in JavaScript, the spread operator is used to expand array elements inside array literals and merge objects (aka hashes) in object literals. See `docs/composite_literals.md`.
+- Improved `{% cycle %}` tag implementation. We no longer evaluate all items for every call to `CycleTag#render`, just the next item in the cycle. We also cache cycle context keys if the key is known at parse time.
+
 ## [0.4.0] - 25-08-11
 
 - Fixed a bug where the parser would raise a `Liquid2::LiquidSyntaxError` if environment arguments `markup_out_end` and `markup_tag_end` where identical. See [#23](https://github.com/jg-rp/ruby-liquid2/issues/23).

data/README.md

@@ -36,7 +36,7 @@ Liquid templates for Ruby, with some extra features.
 Add `'liquid2'` to your Gemfile:
 
 ```
-gem 'liquid2', '~> 0.4.0'
+gem 'liquid2', '~> 0.5.0'
 ```
 
 Or
@@ -107,31 +107,77 @@ Hello, {{ you | capitalize }}!
 
 #### Array literals
 
-Filtered expressions (those found in output statements, the `assign` tag and the `echo` tag) and `for` tag expressions support array literal syntax. We don't use the traditional `[item1, item2, ...]` syntax with square brackets because square brackets are already used for variables (`["some variable with spaces"]` is a valid variable).
+_CHANGED IN VERSION 0.5.0_
 
-```liquid2
-{% assign my_array = a, b, '42', false -%}
-{% for item in my_array -%}
-    - {{ item }}
+Array literals are allowed anywhere a value (literal or variable) is expected.
+
+```liquid
+{{ [1, 2, 3] }}
+{{ ['a', 'b', 'c'] }}
+
+{% assign some_array = [x, y, z] %}
+
+{% for x in [1, 2, 3] %}
+  - {{ x }}
 {% endfor %}
 ```
 
-or, using a `{% liquid %}` tag:
+Square brackets are optional on the left-hand side of a filtered expression or a for loop target, as long as there's at least two items.
 
-```liquid2
-{% liquid
-    for item in a, b, '42', false
-        echo "- ${item}\n"
-    endfor %}
+```liquid
+{{ 1, 2, 3 | join: '-' }}
+
+{% for x in 1, 2, 3 %}
+  - {{ x }}
+{% endfor %}
 ```
 
-With `a` set to `"Hello"` and `b` set to `"World"`, both of the examples above produce the following output.
+The spread operator `...` allows template authors to compose arrays immutably from existing arrays and enumerables.
 
-```plain title="output"
-- Hello
-- World
-- 42
-- false
+```liquid
+{% assign x = [1, 2, 3] %}
+{% assign y = [...x, "a"] %}
+{{ y | json }}
+```
+
+**Output**
+
+```json
+[1, 2, 3, "a"]
+```
+
+#### Object literals
+
+_NEW IN VERSION 0.5.0_
+
+Object (aka hash) literals are allowed anywhere a value (literal or variable) is expected. Keys must be strings or static identifiers. We do not support dynamic keys.
+
+```liquid
+{% assign point = {x: 10, y: 20} %}
+{{ point.x }}
+
+{{ {"foo": "bar", "baz": 42} | json }}
+```
+
+Object and array literals can be nested arbitrarily.
+
+```liquid
+{% assign profile = {
+    name: "Ada",
+    age: 42,
+    tags: ["engineer", "mathematician"]
+  } %}
+
+{{ profile.tags[0] }}
+```
+
+The spread operator `...` can also be used within object literals to merge key–value pairs from other objects or expressions.
+
+```liquid
+{% assign defaults = {a: 1, b: 2} %}
+{% assign overrides = {b: 9, c: 3} %}
+{% assign merged = {...defaults, ...overrides, d: 4} %}
+{{ merged | json }}
 ```
 
 #### Logical `not`
@@ -271,7 +317,7 @@ puts template.render("you" => "Liquid") # Hello, Liquid!
 
 If the _globals_ keyword argument is given, that data will be _pinned_ to the template and will be available as template variables every time you call `Template#render`. Pinned data will be merged with data passed to `Template#render`, with `render` arguments taking priority over pinned data if there's a name conflict.
 
-`Liquid2.render(source)` is a convenience method equivalent to `Liquid2::DEFAULT_ENVIRONMENT.parse(source)` or `Liquid2::Environment.new.parse(source)`.
+`Liquid2.parse(source)` is a convenience method equivalent to `Liquid2::DEFAULT_ENVIRONMENT.parse(source)` or `Liquid2::Environment.new.parse(source)`.
 
 ### Configure
 

data/docs/composite_literals.md

@@ -0,0 +1,139 @@
+# Composite literals in Liquid2
+
+Liquid2, in its default configuration, will never mutate render context data. This behavior ensures that rendering the same template with the same inputs always yields identical results, and that data passed into the template cannot be changed accidentally or maliciously.
+
+Some Liquid2 deployments may choose to support controlled data mutation for performance or integration reasons. In those configurations, custom filters and tags may mutate existing data structures. However, the default runtime always treats data as immutable, providing deterministic and side-effect-free rendering suitable for static publishing, caching, and sandboxed execution.
+
+As such, there are no built-in `append`, `add`, `prepend` or `removed` filters for mutating arrays, nor filters for adding, removing or setting keys in objects (aka hashes or mappings). Instead, we introduce **array and object literals**, and the spread operator `...`.
+
+## Array literals
+
+```liquid
+{{ [1, 2, 3] }}
+{{ ['a', 'b', 'c'] }}
+
+{% assign some_array = [x, y, z] %}
+
+{% for x in [1, 2, 3] %}
+  - {{ x }}
+{% endfor %}
+```
+
+Square brackets are optional on the left-hand side of a filtered expression or a for loop target, as long as there's at least two items.
+
+```liquid
+{{ 1, 2, 3 | join: '-' }}
+
+{% for x in 1, 2, 3 %}
+  - {{ x }}
+{% endfor %}
+```
+
+Empty arrays are OK. Single element arrays must include a trailing comma to differentiate them from bracketed variable/path notation.
+
+```liquid
+{% assign empty_array = [] %}
+{% assign some_array = [x,] %}
+```
+
+Array literals can be arbitrarily nested.
+
+```liquid
+{% liquid
+  assign things = [["foo", 1], ["bar", 2]]
+  for item in things
+      echo "${item[0]}: ${item[1]}\\n"
+  endfor
+%}
+```
+
+The standard `concat` filter can accept an array literal as its argument. It always returns a new array.
+
+```liquid
+{% assign default_colors = "red", "blue" %}
+{% assign all_colors = default_colors | concat: ["green",] %}
+```
+
+You can also map to arrays using the `map` filter and an arrow function argument.
+
+**Data**
+
+```json
+{
+  "pages": [
+    { "dir": "foo", "url": "example.com", "filename": "file1" },
+    { "dir": "bar", "url": "thing.com", "filename": "file2" }
+  ]
+}
+```
+
+```liquid
+{% assign downloads = pages | map: p => [p.filename, "${p.url}/${p.dir}"] %}
+{% for item in downloads %}
+  {{ item | join: ": " }}
+{% endfor %}
+```
+
+The spread operator `...` allows template authors to compose arrays immutably from existing arrays and enumerables.
+
+```liquid
+{% assign x = [1, 2, 3] %}
+{% assign y = [...x, "a"] %}
+{{ y | json }}
+```
+
+**Output**
+
+```json
+[1, 2, 3, "a"]
+```
+
+## Object literals
+
+Object literals (also known as hashes or mappings) define key–value pairs enclosed in curly braces `{}`. Keys must be static identifiers or string literals, and braces are always required.
+
+```liquid
+{% assign point = {x: 10, y: 20} %}
+{{ point.x }}
+
+{{ {"foo": "bar", "baz": 42} | json }}
+```
+
+Object literals can contain values of any type, including arrays, objects, and interpolated strings.
+
+```liquid
+{% assign profile = {
+    name: "Ada",
+    age: 42,
+    tags: ["engineer", "mathematician"]
+  } %}
+
+{{ profile.name }}
+```
+
+Keys may be written as unquoted identifiers or quoted strings. Both forms are equivalent:
+
+```liquid
+{% assign a = {foo: 1, "bar": 2} %}
+```
+
+The spread operator `...` can also be used within object literals to merge key–value pairs from other objects or expressions. Each spread is evaluated in order, and later keys override earlier ones. The source objects themselves are never mutated.
+
+```liquid
+{% assign defaults = {a: 1, b: 2} %}
+{% assign overrides = {b: 9, c: 3} %}
+{% assign merged = {...defaults, ...overrides, d: 4} %}
+{{ merged | json }}
+```
+
+**Output**
+
+```json
+{ "a": 1, "b": 9, "c": 3, "d": 4 }
+```
+
+Spread values are evaluated as follows:
+
+- **Hashes (objects)** are merged directly.
+- **Objects responding to `to_h`** are converted and merged.
+- **Other values** are ignored (treated as empty objects).

data/lib/liquid2/environment.rb

@@ -412,7 +412,15 @@ module Liquid2
       @re_markup_end_chars = /[#{Regexp.escape((@markup_out_end + @markup_tag_end).each_char.uniq.join)}]/
 
       @re_up_to_markup_start = /(?=#{Regexp.escape(@markup_out_start)}|#{Regexp.escape(@markup_tag_start)}|#{Regexp.escape(@markup_comment_prefix)})/
-      @re_punctuation = %r{(?!#{@re_markup_end})(\?|\[|\]|\|{1,2}|\.{1,2}|,|:|\(|\)|[<>=!]+|[+\-%*/]+(?!#{@re_markup_end_chars}))}
+
+      # Braces `{` and `}` are handled separately by the scanner, similar to how we handle
+      # `"` and `'`, so we don't confuse ending a nested object/hash literal with ending an
+      # output statement.
+      #
+      # In this example we need two `:token_rbrace` before `:token_output_end`.
+      #  `{{ {"thing": {"foo": 1, "bar": 2}} }}`
+      @re_punctuation = %r{(?!#{@re_markup_end})(\?|\[|\]|\|{1,2}|\.{1,3}|,|:|\(|\)|[<>=!]+|[+\-%*/]+(?!#{@re_markup_end_chars}))}
+
       @re_up_to_inline_comment_end = /(?=([+\-~])?#{Regexp.escape(@markup_tag_end)})/
       @re_up_to_raw_end = /(?=(#{Regexp.escape(@markup_tag_start)}[+\-~]?\s*endraw\s*[+\-~]?#{Regexp.escape(@markup_tag_end)}))/
       @re_block_comment_chunk = /(#{Regexp.escape(@markup_tag_start)}[+\-~]?\s*(comment|raw|endcomment|endraw)\s*[+\-~]?#{Regexp.escape(@markup_tag_end)})/

data/lib/liquid2/expression.rb

@@ -10,6 +10,11 @@ module Liquid2
       @token = token
     end
 
+    # @param context RenderContext
+    def evaluate(_context)
+      raise "all expressions must implement `evaluate: (RenderContext context) -> untyped`"
+    end
+
     # Return children of this expression.
     def children = []
 

data/lib/liquid2/expressions/array.rb

@@ -5,16 +5,55 @@ require_relative "../expression"
 module Liquid2
   # An array literal.
   class ArrayLiteral < Expression
+    # @param token [[Symbol, String?, Integer]]
     # @param items [Array<Expression>]
     def initialize(token, items)
       super(token)
       @items = items
     end
 
+    # @param context [RenderContext]
+    # @return [untyped]
     def evaluate(context)
-      @items.map { |item| context.evaluate(item) }
+      result = [] # : Array[untyped]
+      @items.each do |item|
+        value = context.evaluate(item)
+        if item.is_a?(ArraySpread)
+          case value
+          when Array
+            result.concat(value)
+          when Hash, String
+            result << value
+          when Enumerable
+            result.concat(value.to_a)
+          else
+            if value.respond_to?(:each)
+              result.concat(value.each)
+            else
+              result << value
+            end
+          end
+        else
+          result << value
+        end
+      end
+      result
     end
 
     def children = @items
   end
+
+  # Represents a spread element inside an array literal, e.g. ...expr
+  class ArraySpread < Expression
+    # @param token [[Symbol, String?, Integer]]
+    # @param expr [Expression]
+    def initialize(token, expr)
+      super(token)
+      @expr = expr
+    end
+
+    def evaluate(context) = context.evaluate(@expr)
+
+    def children = [@expr]
+  end
 end

data/lib/liquid2/expressions/object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # JavaScript-style object/hash literal
+  class ObjectLiteral < Expression
+    # @param items [Array<ObjectLiteralItem>]
+    def initialize(token, items)
+      super(token)
+      @items = items
+    end
+
+    def evaluate(context)
+      result = {} # : Hash[String,untyped]
+      @items.each do |item|
+        key, value = context.evaluate(item)
+        if item.spread
+          if value.is_a?(Hash)
+            result.merge!(value)
+          elsif value.respond_to?(:to_h)
+            result.merge!(value.to_h)
+          end
+        else
+          result[key] = value
+        end
+      end
+      result
+    end
+
+    def children = @items
+  end
+
+  # A key/value pair belonging to an object literal.
+  class ObjectLiteralItem < Expression
+    attr_reader :value, :name, :sym, :spread
+
+    # @param name [String]
+    # @param value [Expression]
+    def initialize(token, name, value, spread: false)
+      super(token)
+      @name = name
+      @sym = name.to_sym
+      @value = value
+      @spread = spread
+    end
+
+    def evaluate(context)
+      [@name, context.evaluate(@value)]
+    end
+
+    def children = [@value]
+  end
+end

data/lib/liquid2/filter.rb

@@ -15,8 +15,6 @@ module Liquid2
         obj.flatten
       when Hash, String
         [obj]
-      # when String
-      #   obj.each_char
       when Enumerable
         obj
       else
@@ -86,6 +84,8 @@ module Liquid2
     end
 
     def self.fetch(obj, key, default = nil)
+      # TODO: benchmark without rescue
+      # TODO: try defensive respond_to?
       obj[key]
     rescue ArgumentError, TypeError, NoMethodError
       default

data/lib/liquid2/nodes/tags/cycle.rb

@@ -39,19 +39,14 @@ module Liquid2
       @items = items
       @named = named
       @blank = false
+      # Generate the cycle key here once if we don't have a potentially dynamic name.
+      @key = @items.to_s unless @named
     end
 
     def render(context, buffer)
-      args = @items.map { |expr| context.evaluate(expr) }
-
-      key = if @named
-              context.evaluate(@name).to_s
-            else
-              @items.to_s
-            end
-
+      key = @key || context.evaluate(@name).to_s
       index = context.tag_namespace[:cycles][key]
-      buffer << Liquid2.to_output_s(args[index])
+      buffer << Liquid2.to_output_s(context.evaluate(@items[index]))
 
       index += 1
       index = 0 if index >= @items.length

data/lib/liquid2/parser.rb

@@ -16,6 +16,7 @@ require_relative "expressions/identifier"
 require_relative "expressions/lambda"
 require_relative "expressions/logical"
 require_relative "expressions/loop"
+require_relative "expressions/object"
 require_relative "expressions/path"
 require_relative "expressions/range"
 require_relative "expressions/relational"
@@ -237,7 +238,7 @@ module Liquid2
     def parse_filtered_expression
       token = current
       left = parse_primary
-      left = parse_array_literal(left) if current_kind == :token_comma
+      left = parse_implicit_array(left) if current_kind == :token_comma
       filters = parse_filters if current_kind == :token_pipe
       expr = FilteredExpression.new(token, left, filters)
 
@@ -262,7 +263,7 @@ module Liquid2
 
       if current_kind == :token_comma
         unless LOOP_KEYWORDS.member?(peek[1] || raise)
-          enum = parse_array_literal(enum)
+          enum = parse_implicit_array(enum)
           return LoopExpression.new(identifier.token, identifier, enum,
                                     limit: limit, offset: offset, reversed: reversed, cols: cols)
         end
@@ -372,8 +373,12 @@ module Liquid2
                looks_like_a_path ? parse_path : Empty.new(self.next)
              when :token_single_quote_string, :token_double_quote_string
                parse_string_literal
-             when :token_word, :token_lbracket
+             when :token_word
                parse_path
+             when :token_lbracket
+               parse_array_or_path
+             when :token_lbrace
+               parse_object_literal
              when :token_lparen
                parse_range_lambda_or_grouped_expression
              when :token_not, :token_plus, :token_minus
@@ -429,6 +434,7 @@ module Liquid2
     end
 
     # Parse a string literals or unquoted word.
+    # @return [String]
     def parse_name
       case current_kind
       when :token_word
@@ -787,10 +793,69 @@ module Liquid2
       end
     end
 
+    # Parse an array literal delimited with `[` and `]` or a bracketed variable/path.
+    # @return [Node]
+    def parse_array_or_path
+      start_pos = @pos
+      token = eat(:token_lbracket)
+
+      if current_kind == :token_rbracket
+        # Empty array
+        @pos += 1
+        return ArrayLiteral.new(token, [])
+      end
+
+      if current_kind == :token_spread
+        # An array with a spread operator before the first item.
+        spread_token = self.next
+        return parse_partial_array(token, ArraySpread.new(spread_token, parse_primary))
+      end
+
+      first = parse_primary
+
+      if current_kind == :token_comma
+        # An array
+        parse_partial_array(token, first)
+      else
+        # backtrack
+        @pos = start_pos
+        parse_path
+      end
+    end
+
+    # Parse an array where we've already consumed the opening bracket and first item.
+    def parse_partial_array(token, first)
+      items = [first] # : Array[untyped]
+
+      loop do
+        if current_kind == :token_rbracket
+          @pos += 1
+          break
+        end
+
+        eat(:token_comma)
+
+        # Trailing commas are OK.
+        if current_kind == :token_rbracket
+          @pos += 1
+          break
+        end
+
+        if current_kind == :token_spread
+          spread_token = self.next
+          items << ArraySpread.new(spread_token, parse_primary)
+        else
+          items << parse_primary
+        end
+      end
+
+      ArrayLiteral.new(token, items)
+    end
+
     # Parse a comma separated list of expressions. Assumes the next token is a comma.
     # @param left [Expression] The first item in the array.
     # @return [ArrayLiteral]
-    def parse_array_literal(left)
+    def parse_implicit_array(left)
       token = current
       items = [left] # : Array[untyped]
 
@@ -807,19 +872,62 @@ module Liquid2
       ArrayLiteral.new(left.respond_to?(:token) ? left.token : token, items)
     end
 
+    def parse_object_literal
+      token = eat(:token_lbrace)
+
+      if current_kind == :token_rbrace
+        # Empty object/hash
+        @pos += 1
+        return ObjectLiteral.new(token, [])
+      end
+
+      items = [parse_object_literal_item] # : Array[ObjectLiteralItem]
+
+      # Subsequent items must be preceded by a comma.
+      loop do
+        break if current_kind == :token_rbrace
+
+        eat(:token_comma, "expected a comma")
+
+        # Trailing commas are OK.
+        break if current_kind == :token_rbrace
+
+        items << parse_object_literal_item
+      end
+
+      eat(:token_rbrace, "expected a closing brace")
+      ObjectLiteral.new(token, items)
+    end
+
+    def parse_object_literal_item
+      token = current
+      if token[0] == :token_spread
+        @pos += 1
+        return ObjectLiteralItem.new(token, "", parse_primary, spread: true)
+      end
+
+      key = parse_name # We don't support dynamic keys
+      eat(:token_colon)
+      value = parse_primary
+      ObjectLiteralItem.new(token, key, value)
+    end
+
     # @return [Node]
     def parse_range_lambda_or_grouped_expression
       token = eat(:token_lparen)
       expr = parse_primary
 
-      if current_kind == :token_double_dot
+      kind = current_kind
+
+      if kind == :token_double_dot
         @pos += 1
         stop = parse_primary
-        eat(:token_rparen)
+        eat(:token_rparen, "expected a closing parenthesis")
         return RangeExpression.new(token, expr, stop)
       end
 
-      kind = current_kind
+      # Probably a range expression with too many dots.
+      raise LiquidSyntaxError.new("too many dots", current) if kind == :token_spread
 
       # An arrow function, but we've already consumed lparen and the first parameter.
       return parse_partial_arrow_function(expr) if kind == :token_comma
@@ -978,7 +1086,7 @@ module Liquid2
         # A single parameter without parens
         params << parse_identifier
       when :token_lparen
-        # One or move parameters separated by commas and surrounded by parentheses.
+        # One or more parameters separated by commas and surrounded by parentheses.
         self.next
         while current_kind != :token_rparen
           params << parse_identifier

data/lib/liquid2/scanner.rb

@@ -38,6 +38,7 @@ module Liquid2
       "||" => :token_double_pipe,
       "." => :token_dot,
       ".." => :token_double_dot,
+      "..." => :token_spread,
       "," => :token_comma,
       ":" => :token_colon,
       "(" => :token_lparen,
@@ -222,6 +223,10 @@ module Liquid2
           @start = @scanner.pos
         else
           case @scanner.get_byte
+          when "{"
+            @tokens << [:token_lbrace, nil, @start]
+            @start = @scanner.pos
+            scan_object_literal
           when "'"
             @start = @scanner.pos
             scan_string("'", :token_single_quote_string, @re_single_quote_string_special)
@@ -249,8 +254,10 @@ module Liquid2
         return nil if @scanner.eos?
 
         if (ch = @scanner.scan(@re_markup_end_chars))
-          raise LiquidSyntaxError.new("missing markup delimiter detected",
-                                      [:token_unknown, ch, @start])
+          raise LiquidSyntaxError.new(
+            "missing markup delimiter or unbalanced object literal detected",
+            [:token_unknown, ch, @start]
+          )
         end
 
         @tokens << [:token_unknown, @scanner.getch, @start]
@@ -450,6 +457,9 @@ module Liquid2
       loop do
         skip_line_trivia
 
+        # XXX: strings can contain line breaks
+        # XXX: object literals can contain line breaks
+
         case @scanner.get_byte
         when "'"
           @start = @scanner.pos
@@ -457,6 +467,10 @@ module Liquid2
         when "\""
           @start = @scanner.pos
           scan_string("\"", :token_double_quote_string, @re_double_quote_string_special)
+        when "{"
+          @tokens << [:token_lbrace, nil, @start]
+          @start = @scanner.pos
+          scan_object_literal
         when nil
           # End of scanner. Unclosed expression or string literal.
           break
@@ -499,7 +513,7 @@ module Liquid2
       end
     end
 
-    # Scan a string literal surrounded by single quotes.
+    # Scan a string literal surrounded by `quote`.
     # Assumes the opening quote has already been consumed and emitted.
     def scan_string(quote, symbol, pattern)
       start_of_string = @start - 1
@@ -551,6 +565,10 @@ module Liquid2
               @start = @scanner.pos
               scan_string("\"", :token_double_quote_string,
                           @re_double_quote_string_special)
+            when "{"
+              @tokens << [:token_lbrace, nil, @start]
+              @start = @scanner.pos
+              scan_object_literal
             when "}"
               @tokens << [:token_string_interpol_end, nil, @start]
               @start = @scanner.pos
@@ -585,5 +603,52 @@ module Liquid2
         end
       end
     end
+
+    # Scan an object/hash literal delimited by `{` and `}`.
+    # Assumes the opening `{` has been consumed and emitted.
+    def scan_object_literal
+      start_of_object = @start - 1
+      loop do
+        skip_trivia
+        if (value = @scanner.scan(@re_float))
+          @tokens << [:token_float, value, @start]
+          @start = @scanner.pos
+        elsif (value = @scanner.scan(@re_int))
+          @tokens << [:token_int, value, @start]
+          @start = @scanner.pos
+        elsif (value = @scanner.scan(@re_punctuation))
+          @tokens << [TOKEN_MAP[value] || :token_unknown, value, @start]
+          @start = @scanner.pos
+        elsif (value = @scanner.scan(@re_word))
+          @tokens << [TOKEN_MAP[value] || :token_word, value, @start]
+          @start = @scanner.pos
+        else
+          case @scanner.get_byte
+          when "{"
+            @tokens << [:token_lbrace, nil, @start]
+            @start = @scanner.pos
+            scan_object_literal
+          when "'"
+            @start = @scanner.pos
+            scan_string("'", :token_single_quote_string, @re_single_quote_string_special)
+          when "\""
+            @start = @scanner.pos
+            scan_string("\"", :token_double_quote_string,
+                        @re_double_quote_string_special)
+          else
+            @scanner.pos -= 1
+            break
+          end
+        end
+      end
+
+      if @scanner.get_byte == "}"
+        @tokens << [:token_rbrace, nil, @start]
+        @start = @scanner.pos
+      else
+        raise LiquidSyntaxError.new("unclosed object literal",
+                                    [:token_lbrace, nil, start_of_object])
+      end
+    end
   end
 end

data/lib/liquid2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Liquid2
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/sig/liquid2.rbs

@@ -381,6 +381,8 @@ module Liquid2
     # Scan a string literal surrounded by _quote_.
     # Assumes the opening quote has already been consumed and emitted.
     def scan_string: (("\"" | "'"), Symbol, Regexp) -> void
+                   
+    def scan_object_literal: () -> void
   end
 end
 
@@ -583,7 +585,15 @@ module Liquid2
     # @return [Filter]
     def parse_filter: () -> Filter
                     
-    def parse_array_literal: (untyped left) -> ArrayLiteral
+    def parse_array_or_path: () -> (ArrayLiteral | Path)
+                    
+    def parse_partial_array: ([Symbol, String?, Integer] token, Expression first) -> ArrayLiteral
+
+    def parse_implicit_array: (untyped left) -> ArrayLiteral
+
+    def parse_object_literal: () -> ObjectLiteral
+                            
+    def parse_object_literal_item: () -> ObjectLiteralItem
 
     def parse_arrow_function: () -> untyped
 
@@ -1276,6 +1286,8 @@ module Liquid2
 
     # @param token [[Symbol, String?, Integer]]
     def initialize: ([Symbol, String?, Integer] token) -> void
+                  
+    def evaluate: (RenderContext context) -> untyped
 
     def children: () -> Array[untyped]
     
@@ -1335,6 +1347,49 @@ module Liquid2
 
     def evaluate: (RenderContext context) -> untyped
   end
+
+  class ArraySpread < Expression
+    @expr: Expression
+
+    def initialize: ([Symbol, String?, Integer] token, Expression expr) -> void
+
+    def evaluate: (RenderContext context) -> untyped
+  end
+end
+
+module Liquid2
+  class ObjectLiteral < Expression
+    @items: Array[ObjectLiteralItem]
+
+    # @param items [Array<Expression>]
+    def initialize: ([Symbol, String?, Integer] token, Array[ObjectLiteralItem] items) -> void
+
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  class ObjectLiteralItem < Expression
+    @name: String
+
+    @sym: Symbol
+
+    @value: untyped
+
+    @spread: bool
+
+    attr_reader name: String
+
+    attr_reader sym: Symbol
+
+    attr_reader value: untyped
+
+    attr_reader spread: bool
+
+    # @param name [Token]
+    # @param value [Expression]
+    def initialize: ([Symbol, String?, Integer] token, String name, untyped value, ?spread: bool) -> void
+
+    def evaluate: (RenderContext context) -> [String, untyped]
+  end
 end
 
 module Liquid2
@@ -1762,7 +1817,7 @@ module Liquid2
     # Cast _obj_ to a  date and time. Return `nil` if casting fails.
     def self.to_date: (untyped obj) -> untyped
                     
-    def self.fetch: (untyped obj, untyped key) -> untyped
+    def self.fetch: (untyped obj, untyped key, ?untyped default) -> untyped
 
     # Return the concatenation of items in _left_ separated by _sep_.
     def self.join: (untyped left, ?::String sep) -> untyped
@@ -2130,6 +2185,8 @@ module Liquid2
 
     @blank: bool
 
+    @key: String | nil
+
     # @param parser [Parser]
     # @return [CycleTag]
     def self.parse: ([Symbol, String?, Integer] token, Parser parser) -> CycleTag

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liquid2
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - James Prior
@@ -79,6 +79,7 @@ files:
 - README.md
 - Rakefile
 - Steepfile
+- docs/composite_literals.md
 - lib/liquid2.rb
 - lib/liquid2/context.rb
 - lib/liquid2/environment.rb
@@ -94,6 +95,7 @@ files:
 - lib/liquid2/expressions/lambda.rb
 - lib/liquid2/expressions/logical.rb
 - lib/liquid2/expressions/loop.rb
+- lib/liquid2/expressions/object.rb
 - lib/liquid2/expressions/path.rb
 - lib/liquid2/expressions/range.rb
 - lib/liquid2/expressions/relational.rb