liquid2 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 396a11c43cb73cebe443927f69b83210d9c1651d9168ad7412726f54470492a7
-  data.tar.gz: ed127fb805a3862d3bde1db35dd88a713b714af3f65c51ba58d0f85fd09052c3
+  metadata.gz: 42973b8aae08cf4321586ac4cdaf39ecab29e0a2a4b7f26aed278291e41b7645
+  data.tar.gz: 9c2bca82b7f589cfdccd4a2a5c091ac3cd32613e0c40354b6313d23a6c35bbec
 SHA512:
-  metadata.gz: 5c72bdc10c87b94b3863826cd1e964be714de2277c1c4627480fe0a9f869de977ae9efeb55cbaec573a625e43a46a0758312c36e15697d97934b177c968c078f
-  data.tar.gz: f2c6ec9e5d3d6d0fb86ba2455c0ec8134c8896243c6d8fab859ee3fbbd2c1bb17f2aaf949d591edf96eaf998d5562f7290e1ab9893502764ac9498ddb33aba97
+  metadata.gz: fbb3917b6b68ba37aaffbf158aac61d85a577ddf244b12fdad9eaa99e5ea54a0f94b255b3d21381514bb42bbb7c3543c247b7bba38255e95dacc195aedf2f10a
+  data.tar.gz: a61fd0b11ff0d4ed92bdcd1b8eca60b5997f6881caad131132256f561a0c039cdc33e758601b7dd9da0e02534f53c21a38da6c09e38bc947a4a93834a0413210

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.3.0] - 25-05-29
+
+- Fixed static analysis of lambda expressions (arrow functions). Previously we were not including lambda parameters in the scope of the expression. See [#12](https://github.com/jg-rp/ruby-liquid2/issues/12).
+- Fixed parsing of variable paths that start with `true`, `false`, `nil` or `null`. For example, `{{ true.foo }}`. See [#13](https://github.com/jg-rp/ruby-liquid2/issues/13).
+- Added support for arithmetic infix operators `+`, `-`, `*`, `/`, `%` and `**`, and prefix operators `+` and `-`. These operators are disabled by default. Enable them by passing `arithmetic_operators: true` to a new `Liquid2::Environment`.
+
 ## [0.2.0] - 25-05-12
 
 - Fixed error context info when raising `UndefinedError` from `StrictUndefined`.

data/README.md

@@ -36,7 +36,7 @@ Liquid templates for Ruby, with some extra features.
 Add `'liquid2'` to your Gemfile:
 
 ```
-gem 'liquid2', '~> 0.2.0'
+gem 'liquid2', '~> 0.3.0'
 ```
 
 Or
@@ -219,6 +219,10 @@ Here we use `~` to remove the newline after the opening `for` tag, but preserve
 </ul>
 ```
 
+#### Arithmetic operators
+
+Arithmetic infix operators `+`, `-`, `*`, `/`, `%` and `**`, and prefix operators `+` and `-`, are an experimental feature and are disabled by default. Enable them by passing `arithmetic_operators: true` to a new [`Liquid2::Environment`](https://github.com/jg-rp/ruby-liquid2/blob/main/lib/liquid2/environment.rb).
+
 #### Scientific notation
 
 Integer and float literals can use scientific notation, like `1.2e3` or `1e-2`.

data/lib/liquid2/environment.rb

@@ -45,7 +45,7 @@ module Liquid2
   class Environment
     attr_reader :tags, :local_namespace_limit, :context_depth_limit, :loop_iteration_limit,
                 :output_stream_limit, :filters, :suppress_blank_control_flow_blocks,
-                :shorthand_indexes, :falsy_undefined
+                :shorthand_indexes, :falsy_undefined, :arithmetic_operators
 
     # @param context_depth_limit [Integer] The maximum number of times a render context can
     #   be extended or copied before a `Liquid2::LiquidResourceLimitError`` is raised.
@@ -68,6 +68,7 @@ module Liquid2
     # @param undefined [singleton(Liquid2::Undefined)] A singleton returning an instance of
     #   `Liquid2::Undefined`, which is used to represent template variables that don't exist.
     def initialize(
+      arithmetic_operators: false,
       context_depth_limit: 30,
       globals: nil,
       loader: nil,
@@ -87,6 +88,10 @@ module Liquid2
       # keyword argument.
       @filters = {}
 
+      # When `true`, arithmetic operators `+`, `-`, `*`, `/`, `%` and `**` are enabled.
+      # Defaults to `false`.
+      @arithmetic_operators = arithmetic_operators
+
       # The maximum number of times a render context can be extended or copied before
       # a Liquid2::LiquidResourceLimitError is raised.
       @context_depth_limit = context_depth_limit

data/lib/liquid2/expressions/arithmetic.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "blank"
+require_relative "../expression"
+
+module Liquid2 # :nodoc:
+  # Base class for all arithmetic expressions.
+  class ArithmeticExpression < Expression
+    # @param left [Expression]
+    # @param right [Expression]
+    def initialize(token, left, right)
+      super(token)
+      @left = left
+      @right = right
+    end
+
+    def children = [@left, @right]
+
+    protected
+
+    def inner_evaluate(context)
+      left = context.evaluate(@left)
+      right = context.evaluate(@right)
+      left = left.to_liquid(context) if left.respond_to?(:to_liquid)
+      right = right.to_liquid(context) if right.respond_to?(:to_liquid)
+      [Liquid2::Filters.to_decimal(left), Liquid2::Filters.to_decimal(right)]
+    end
+  end
+
+  # Infix addition
+  class Plus < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left + right
+    end
+  end
+
+  # Infix subtraction
+  class Minus < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left - right
+    end
+  end
+
+  # Infix multiplication
+  class Times < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left * right
+    end
+  end
+
+  # Infix division
+  class Divide < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left / right
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+  end
+
+  # Infix modulo
+  class Modulo < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left % right
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+  end
+
+  # Infix exponentiation
+  class Pow < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left**right
+    end
+  end
+
+  # Prefix negation
+  class Negative < Expression
+    # @param right [Expression]
+    def initialize(token, right)
+      super(token)
+      @right = right
+    end
+
+    def evaluate(context)
+      right = context.evaluate(@right)
+      value = Liquid2::Filters.to_decimal(right,
+                                          default: nil) || context.env.undefined(
+                                            "-(#{Liquid2.to_output_string(right)})",
+                                            node: self
+                                          )
+      value.send(:-@)
+    end
+
+    def children = [@right]
+  end
+
+  # Prefix positive
+  class Positive < Expression
+    # @param right [Expression]
+    def initialize(token, right)
+      super(token)
+      @right = right
+    end
+
+    def evaluate(context)
+      right = context.evaluate(@right)
+      value = Liquid2::Filters.to_decimal(right,
+                                          default: nil) || context.env.undefined(
+                                            "+(#{Liquid2.to_output_string(right)})",
+                                            node: self
+                                          )
+      value.send(:+@)
+    end
+
+    def children = [@right]
+  end
+end

data/lib/liquid2/expressions/lambda.rb

@@ -19,6 +19,8 @@ module Liquid2
 
     def children = [@expr]
 
+    def scope = @params
+
     # Apply this lambda function to elements from _enum_.
     # @param context [RenderContext]
     # @param enum [Enumerable<Object>]

data/lib/liquid2/expressions/relational.rb

@@ -4,7 +4,7 @@ require_relative "blank"
 require_relative "../expression"
 
 module Liquid2 # :nodoc:
-  # Base for comparison expressions.
+  # Base class for all comparison expressions.
   class ComparisonExpression < Expression
     # @param left [Expression]
     # @param right [Expression]

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

@@ -10,7 +10,8 @@ module Liquid2
     def self.parse(token, parser)
       parser.carry_whitespace_control
       parser.eat(:token_tag_end)
-      # TODO: apply whitespace control to raw text
+      # TODO: apply whitespace control to raw text?
+      # Shopify/liquid does not apply whitespace control to raw content.
       raw = parser.eat(:token_raw)
       parser.eat_empty_tag("endraw")
       new(token, raw[1] || raise)

data/lib/liquid2/parser.rb

@@ -7,6 +7,7 @@ require_relative "node"
 require_relative "nodes/comment"
 require_relative "nodes/output"
 require_relative "expressions/arguments"
+require_relative "expressions/arithmetic"
 require_relative "expressions/array"
 require_relative "expressions/blank"
 require_relative "expressions/boolean"
@@ -336,14 +337,26 @@ module Liquid2
 
       left = case kind
              when :token_true
-               self.next
-               looks_like_a_path ? parse_path : true
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 true
+               end
              when :token_false
-               self.next
-               looks_like_a_path ? parse_path : false
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 false
+               end
              when :token_nil
-               self.next
-               looks_like_a_path ? parse_path : nil
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 nil
+               end
              when :token_int
                Liquid2.to_liquid_int(self.next[1])
              when :token_float
@@ -358,7 +371,7 @@ module Liquid2
                parse_path
              when :token_lparen
                parse_range_lambda_or_grouped_expression
-             when :token_not
+             when :token_not, :token_plus, :token_minus
                parse_prefix_expression
              else
                unless looks_like_a_path && RESERVED_WORDS.include?(kind)
@@ -535,7 +548,10 @@ module Liquid2
       LOGICAL_AND = 4
       RELATIONAL = 5
       MEMBERSHIP = 6
-      PREFIX = 7
+      ADD_SUB = 8
+      MUL_DIV = 9
+      POW = 10
+      PREFIX = 11
     end
 
     PRECEDENCES = {
@@ -551,7 +567,14 @@ module Liquid2
       token_ne: Precedence::RELATIONAL,
       token_lg: Precedence::RELATIONAL,
       token_le: Precedence::RELATIONAL,
-      token_ge: Precedence::RELATIONAL
+      token_ge: Precedence::RELATIONAL,
+      token_plus: Precedence::ADD_SUB,
+      token_minus: Precedence::ADD_SUB,
+      token_times: Precedence::MUL_DIV,
+      token_divide: Precedence::MUL_DIV,
+      token_floor_div: Precedence::MUL_DIV,
+      token_mod: Precedence::MUL_DIV,
+      token_pow: Precedence::POW
     }.freeze
 
     BINARY_OPERATORS = Set[
@@ -565,7 +588,14 @@ module Liquid2
       :token_contains,
       :token_in,
       :token_and,
-      :token_or
+      :token_or,
+      :token_plus,
+      :token_minus,
+      :token_times,
+      :token_divide,
+      :token_floor_div,
+      :token_mod,
+      :token_pow
     ]
 
     TERMINATE_EXPRESSION = Set[
@@ -803,14 +833,35 @@ module Liquid2
       end
 
       eat(:token_rparen)
-      GroupedExpression.new(token, expr)
+      expr
     end
 
     # @return [Node]
     def parse_prefix_expression
-      token = eat(:token_not)
-      expr = parse_primary
-      LogicalNot.new(token, expr)
+      case current_kind
+      when :token_not
+        token = self.next
+        expr = parse_primary(precedence: Precedence::PREFIX)
+        LogicalNot.new(token, expr)
+      when :token_plus
+        token = self.next
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected prefix operator +",
+                                      token)
+        end
+
+        Positive.new(token, parse_primary(precedence: Precedence::PREFIX))
+      when :token_minus
+        token = self.next
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected prefix operator -",
+                                      token)
+        end
+
+        Negative.new(token, parse_primary(precedence: Precedence::PREFIX))
+      else
+        raise LiquidSyntaxError.new("unexpected prefix operator #{current[1]}", current)
+      end
     end
 
     # @param left [Expression]
@@ -842,7 +893,27 @@ module Liquid2
       when :token_or
         LogicalOr.new(op_token, left, right)
       else
-        raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}", op_token)
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}",
+                                      op_token)
+        end
+
+        case op_token.first
+        when :token_plus
+          Plus.new(op_token, left, right)
+        when :token_minus
+          Minus.new(op_token, left, right)
+        when :token_times
+          Times.new(op_token, left, right)
+        when :token_divide
+          Divide.new(op_token, left, right)
+        when :token_mod
+          Modulo.new(op_token, left, right)
+        when :token_pow
+          Pow.new(op_token, left, right)
+        else
+          raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}", op_token)
+        end
       end
     end
 

data/lib/liquid2/scanner.rb

@@ -16,7 +16,7 @@ module Liquid2
     RE_WORD = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/
     RE_INT  = /-?\d+(?:[eE]\+?\d+)?/
     RE_FLOAT = /((?:-?\d+\.\d+(?:[eE][+-]?\d+)?)|(-?\d+[eE]-\d+))/
-    RE_PUNCTUATION = /\?|\[|\]|\|{1,2}|\.{1,2}|,|:|\(|\)|[<>=!]+/
+    RE_PUNCTUATION = %r{\?|\[|\]|\|{1,2}|\.{1,2}|,|:|\(|\)|[<>=!]+|[+\-%*/]+(?![\}%])}
     RE_SINGLE_QUOTE_STRING_SPECIAL = /[\\'\$]/
     RE_DOUBLE_QUOTE_STRING_SPECIAL = /[\\"\$]/
 
@@ -58,7 +58,14 @@ module Liquid2
       ">=" => :token_ge,
       "==" => :token_eq,
       "!=" => :token_ne,
-      "=>" => :token_arrow
+      "=>" => :token_arrow,
+      "+" => :token_plus,
+      "-" => :token_minus,
+      "%" => :token_mod,
+      "*" => :token_times,
+      "/" => :token_divide,
+      "//" => :token_floor_div,
+      "**" => :token_pow
     }.freeze
 
     def self.tokenize(source, scanner)

data/lib/liquid2/undefined.rb

@@ -28,6 +28,8 @@ module Liquid2
     def to_s = ""
     def to_i = 0
     def to_f = 0.0
+    def -@ = self
+    def +@ = self
     def each(...) = Enumerator.new {} # rubocop:disable Lint/EmptyBlock
     def each_with_index(...) = Enumerator.new {} # rubocop:disable Lint/EmptyBlock
     def join(...) = ""
@@ -102,6 +104,14 @@ module Liquid2
       raise UndefinedError.new(@message, @node.token)
     end
 
+    def +@
+      self
+    end
+
+    def -@
+      self
+    end
+
     def each(...)
       raise UndefinedError.new(@message, @node.token)
     end
@@ -115,7 +125,7 @@ module Liquid2
     end
 
     def to_liquid(_context)
-      raise UndefinedError.new(@message, @node.token)
+      self
     end
 
     def poke

data/lib/liquid2/version.rb

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

data/sig/liquid2.rbs

@@ -84,6 +84,8 @@ module Liquid2
 
     @scanner: StringScanner
 
+    @arithmetic_operators: bool
+
     attr_reader tags: Hash[String, _Tag]
 
     attr_reader local_namespace_limit: Integer?
@@ -102,6 +104,8 @@ module Liquid2
 
     attr_reader falsy_undefined: bool
 
+    attr_reader arithmetic_operators: bool
+
     def initialize: (?context_depth_limit: ::Integer, ?globals: Hash[String, untyped]?, ?loader: TemplateLoader?, ?local_namespace_limit: Integer?, ?loop_iteration_limit: Integer?, ?output_stream_limit: Integer?, ?shorthand_indexes: bool, ?suppress_blank_control_flow_blocks: bool, ?undefined: singleton(Undefined), ?falsy_undefined: bool) -> void
 
     # @param source [String] template source text.
@@ -375,6 +379,12 @@ module Liquid2
       MEMBERSHIP: 6
 
       PREFIX: 7
+
+      ADD_SUB: 8
+
+      MUL_DIV: 9
+      
+      POW: 10
     end
 
     PRECEDENCES: Hash[Symbol, Integer]
@@ -609,29 +619,33 @@ module Liquid2
 
     def []: (*untyped) ?{ (?) -> untyped } -> self
 
-    def key?: (*untyped) ?{ (?) -> untyped } -> false
+    def key?: (*untyped) ?{ (?) -> untyped } -> untyped
 
-    def include?: (*untyped) ?{ (?) -> untyped } -> false
+    def include?: (*untyped) ?{ (?) -> untyped } -> untyped
 
-    def member?: (*untyped) ?{ (?) -> untyped } -> false
+    def member?: (*untyped) ?{ (?) -> untyped } -> untyped
 
     def fetch: (*untyped) ?{ (?) -> untyped } -> self
 
-    def !: () -> true
+    def !: () -> untyped
 
     def ==: (untyped other) -> untyped
 
     alias eql? ==
 
-    def size: () -> 0
+    def size: () -> untyped
 
-    def length: () -> 0
+    def length: () -> untyped
 
     def to_s: () -> ""
 
-    def to_i: () -> 0
+    def to_i: () -> untyped
+            
+    def +@: () -> untyped
+          
+    def -@: () -> untyped
 
-    def to_f: () -> ::Float
+    def to_f: () -> untyped
 
     def each: (*untyped) ?{ (?) -> untyped } -> untyped
 
@@ -639,9 +653,9 @@ module Liquid2
                        
     def join: (*untyped) -> ""
 
-    def to_liquid: (RenderContext _context) -> nil
+    def to_liquid: (RenderContext _context) -> untyped
 
-    def poke: () -> true
+    def poke: () -> bool
   end
 
   # An undefined type that always raises an exception.
@@ -679,6 +693,10 @@ module Liquid2
     def to_s: () -> untyped
 
     def to_i: () -> untyped
+            
+    def +@: () -> untyped
+          
+    def -@: () -> untyped
 
     def to_f: () -> untyped
 
@@ -1593,7 +1611,7 @@ module Liquid2
     def self.to_integer: (untyped obj) -> Integer
 
     # Cast _obj_ to a number, favouring BigDecimal over Float.
-    def self.to_decimal: (untyped obj, ?default: ::Integer) -> (Integer | BigDecimal | Numeric)
+    def self.to_decimal: (untyped obj, ?default: untyped) -> (Integer | BigDecimal | Numeric)
 
     # Cast _obj_ to a  date and time. Return `nil` if casting fails.
     def self.to_date: (untyped obj) -> untyped
@@ -2551,4 +2569,71 @@ module Liquid2
 
     def block_scope: () -> Array[Identifier]
   end
-end
+end
+
+module Liquid2
+  # Base class for all arithmetic expressions.
+  class ArithmeticExpression < Expression
+    @left: untyped
+
+    @right: untyped
+
+    # @param left [Expression]
+    # @param right [Expression]
+    def initialize: ([Symbol, String?, Integer] token, untyped left, untyped right) -> void
+
+    def children: () -> ::Array[untyped]
+
+    def inner_evaluate: (untyped context) -> ::Array[untyped]
+  end
+
+  # Infix addition
+  class Plus < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Infix subtraction
+  class Minus < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Infix multiplication
+  class Times < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Infix division
+  class Divide < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Infix modulo
+  class Modulo < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Infix exponentiation
+  class Pow < ArithmeticExpression
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Prefix negation
+  class Negative < Expression
+    @right: untyped
+
+    # @param right [Expression]
+    def initialize: ([Symbol, String?, Integer] token, untyped right) -> void
+
+    def evaluate: (RenderContext context) -> untyped
+  end
+
+  # Prefix positive
+  class Positive < Expression
+    @right: untyped
+
+    # @param right [Expression]
+    def initialize: ([Symbol, String?, Integer] token, untyped right) -> void
+
+    def evaluate: (RenderContext context) -> untyped
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liquid2
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - James Prior
@@ -85,6 +85,7 @@ files:
 - lib/liquid2/errors.rb
 - lib/liquid2/expression.rb
 - lib/liquid2/expressions/arguments.rb
+- lib/liquid2/expressions/arithmetic.rb
 - lib/liquid2/expressions/array.rb
 - lib/liquid2/expressions/blank.rb
 - lib/liquid2/expressions/boolean.rb