liquid2 0.1.0

data/lib/liquid2/expressions/arguments.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A keyword argument with a name and a value.
+  class KeywordArgument < Expression
+    attr_reader :value, :name, :sym
+
+    # @param name [String]
+    # @param value [Expression]
+    def initialize(token, name, value)
+      super(token)
+      @name = name
+      @sym = name.to_sym
+      @value = value
+    end
+
+    def evaluate(context)
+      [@name, context.evaluate(@value)]
+    end
+
+    def children = [@value]
+  end
+end

data/lib/liquid2/expressions/array.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # An array literal.
+  class ArrayLiteral < Expression
+    # @param items [Array<Expression>]
+    def initialize(token, items)
+      super(token)
+      @items = items
+    end
+
+    def evaluate(context)
+      @items.map { |item| context.evaluate(item) }
+    end
+
+    def children = @items
+  end
+end

data/lib/liquid2/expressions/blank.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # The special value _blank_.
+  class Blank < Expression
+    def evaluate(_context)
+      self
+    end
+
+    def ==(other)
+      return true if other.is_a?(String) && (other.empty? || other.match?(/\A\s+\Z/))
+
+      return other.empty? if other.respond_to?(:empty?)
+
+      other.is_a?(Blank)
+    end
+
+    alias eql? ==
+
+    def to_s = ""
+  end
+
+  # The special value _empty_.
+  class Empty < Expression
+    def evaluate(_context)
+      self
+    end
+
+    def ==(other)
+      return other.empty? if other.respond_to?(:empty?)
+
+      other.is_a?(Empty)
+    end
+
+    alias eql? ==
+
+    def to_s = ""
+  end
+end

data/lib/liquid2/expressions/boolean.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # An expression that evaluates to true or false.
+  class BooleanExpression < Expression
+    # @param expr [Expression]
+    def initialize(token, expr)
+      super(token)
+      @expr = expr
+    end
+
+    def evaluate(context)
+      Liquid2.truthy?(context, context.evaluate(@expr))
+    end
+
+    def children = [@expr]
+  end
+end

data/lib/liquid2/expressions/filtered.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A primary expression with optional filters.
+  class FilteredExpression < Expression
+    attr_reader :filters
+
+    def initialize(token, left, filters)
+      super(token)
+      @left = left
+      @filters = filters
+    end
+
+    def evaluate(context)
+      left = context.evaluate(@left)
+      index = 0
+      while (filter = @filters[index])
+        left = filter.evaluate(left, context)
+        index += 1
+      end
+      left
+    end
+
+    def children =[@left, *@filters]
+  end
+
+  # An inline conditional expression.
+  class TernaryExpression < Expression
+    attr_reader :filters, :tail_filters
+
+    # @param left [FilteredExpression]
+    # @param condition [BooleanExpression]
+    # @param alternative [Expression | nil]
+    # @param filters [Array<Filter>]
+    # @param tail_filters [Array<Filter>]
+    def initialize(token, left, condition, alternative, filters, tail_filters)
+      super(token)
+      @left = left
+      @condition = condition
+      @alternative = alternative
+      @filters = filters
+      @tail_filters = tail_filters
+    end
+
+    def evaluate(context)
+      rv = nil
+
+      if @condition.evaluate(context)
+        rv = @left.evaluate(context)
+      elsif @alternative
+        rv = context.evaluate(@alternative)
+        index = 0
+        while (filter = @filters[index])
+          rv = filter.evaluate(rv, context)
+          index += 1
+        end
+      end
+
+      index = 0
+      while (filter = @tail_filters[index])
+        rv = filter.evaluate(rv, context)
+        index += 1
+      end
+      rv
+    end
+
+    def children
+      # @type var nodes: Array[untyped]
+      nodes = [@left, @condition]
+      nodes << @alternative if @alternative
+      nodes.concat(@filters) if @filters
+      nodes.concat(@tail_filters) if @tail_filters
+      nodes
+    end
+  end
+
+  # A Liquid filter with a name and array of arguments.
+  class Filter < Expression
+    attr_reader :name, :args
+
+    # @param name [String]
+    # @param args [Array[Expression]]
+    def initialize(token, name, args)
+      super(token)
+      @name = name
+      @args = args
+    end
+
+    def evaluate(left, context)
+      filter, with_context = context.env.filters[@name]
+      raise LiquidFilterNotFoundError.new("unknown filter #{@name.inspect}", @token) unless filter
+
+      positional_args, keyword_args = evaluate_args(context)
+      keyword_args[:context] = context if with_context
+
+      if keyword_args.empty?
+        filter.call(left, *positional_args) # steep:ignore
+      else
+        filter.call(left, *positional_args, **keyword_args) # steep:ignore
+      end
+    rescue ArgumentError, TypeError => e
+      raise LiquidArgumentError.new(e.message, @token)
+    end
+
+    def children = @args
+
+    private
+
+    # @param context [RenderContext]
+    # @return [positional arguments, keyword arguments] An array with two elements.
+    #   The first is an array of evaluates positional arguments. The second is a hash
+    #   of keyword names to evaluated keyword values.
+    def evaluate_args(context)
+      positional_args = [] # @type var positional_args: Array[untyped]
+      keyword_args = {} # @type var keyword_args: Hash[Symbol, untyped]
+
+      index = 0
+      loop do
+        # `@args[index]` could be `false` or `nil`
+        break if index >= @args.length
+
+        arg = @args[index]
+        index += 1
+        if arg.respond_to?(:sym)
+          keyword_args[arg.sym] = context.evaluate(arg.value)
+        else
+          positional_args << context.evaluate(arg)
+        end
+      end
+
+      [positional_args, keyword_args]
+    end
+  end
+end

data/lib/liquid2/expressions/identifier.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A single word identifier.
+  class Identifier < Expression
+    attr_reader :name
+
+    # Try to cast _expr_ to an Identifier.
+    # @param expr [Expression]
+    def self.from(expr, trailing_question: true)
+      # TODO: trailing question
+      # TODO: expr might not have a token if its not a path.
+      unless expr.is_a?(Path) && expr.segments.empty?
+        raise LiquidSyntaxError.new("expected an identifier, found #{expr}", expr.token)
+      end
+
+      val = expr.head
+
+      unless val.is_a?(String)
+        raise LiquidSyntaxError.new("expected an identifier, found #{val}", expr.token)
+      end
+
+      # TODO: optimize
+      unless val.to_s.match?(/[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/)
+        raise LiquidSyntaxError.new("invalid identifier", expr.token)
+      end
+
+      new(expr.token)
+    end
+
+    # @param token [[Symbol, String?, Integer]]
+    def initialize(token)
+      super
+      @name = token[1]
+    end
+
+    def evaluate(_context)
+      @name
+    end
+  end
+end

data/lib/liquid2/expressions/lambda.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A lambda expression aka arrow function
+  class Lambda < Expression
+    attr_reader :params, :expr
+
+    # @param params [Array<Identifier>]
+    # @param expr [Expression]
+    def initialize(token, params, expr)
+      super(token)
+      @params = params
+      @expr = expr
+    end
+
+    def evaluate(_context) = self
+
+    def children = [@expr]
+
+    # Apply this lambda function to elements from _enum_.
+    # @param context [RenderContext]
+    # @param enum [Enumerable<Object>]
+    # @return [Enumerable<Object>]
+    def map(context, enum)
+      scope = {} # : Hash[String, untyped]
+      rv = [] # : Array[untyped]
+
+      if @params.length == 1
+        param = @params.first.name
+        context.extend(scope) do
+          enum.each do |item|
+            scope[param] = item
+            rv << context.evaluate(@expr)
+          end
+        end
+      else
+        name_param = @params.first.name
+        index_param = @params[1].name
+        context.extend(scope) do
+          enum.each_with_index do |item, index|
+            scope[index_param] = index
+            scope[name_param] = item
+            rv << context.evaluate(@expr)
+          end
+        end
+      end
+
+      rv
+    end
+  end
+end

data/lib/liquid2/expressions/logical.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A negated expression.
+  class LogicalNot < Expression
+    # @param expr [Expression]
+    def initialize(token, expr)
+      super(token)
+      @expr = expr
+    end
+
+    def evaluate(context)
+      !Liquid2.truthy?(context, context.evaluate(@expr))
+    end
+
+    def children = [@expr]
+  end
+
+  # Logical conjunction.
+  class LogicalAnd < Expression
+    # @param left [Expression]
+    # @param right [Expression]
+    def initialize(token, left, right)
+      super(token)
+      @left = left
+      @right = right
+    end
+
+    def evaluate(context)
+      left = context.evaluate(@left)
+      Liquid2.truthy?(context, left) ? context.evaluate(@right) : left
+    end
+
+    def children = [@left, @right]
+  end
+
+  # Logical disjunction.
+  class LogicalOr < Expression
+    # @param left [Expression]
+    # @param right [Expression]
+    def initialize(token, left, right)
+      super(token)
+      @left = left
+      @right = right
+    end
+
+    def evaluate(context)
+      left = context.evaluate(@left)
+      Liquid2.truthy?(context, left) ? left : context.evaluate(@right)
+    end
+
+    def children = [@left, @right]
+  end
+
+  # A logical expression with explicit parentheses.
+  class GroupedExpression < Expression
+    # @param expr [Expression]
+    def initialize(token, expr)
+      super(token)
+      @expr = expr
+    end
+
+    def evaluate(context)
+      context.evaluate(@expr)
+    end
+
+    def children = [@expr]
+  end
+end

data/lib/liquid2/expressions/loop.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # An expression used by the standard `for` and `tablerow` tags.
+  class LoopExpression < Expression
+    attr_reader :identifier, :enum, :limit, :offset, :reversed, :cols, :name
+
+    EMPTY_ENUM = [].freeze # steep:ignore
+
+    def initialize(token, identifier, enum, limit: nil, offset: nil, reversed: false, cols: nil)
+      super(token)
+      @identifier = identifier
+      @enum = enum
+      @limit = limit
+      @offset = offset
+      @reversed = reversed
+      @cols = cols
+      @name = "#{@identifier.name}-#{@enum}"
+    end
+
+    # @return [Array[untyped]]
+    def evaluate(context)
+      obj = context.evaluate(@enum)
+
+      # @type var array: Array[untyped]
+      array = if obj.is_a?(Array)
+                obj
+              elsif obj.is_a?(Hash) || obj.is_a?(Range)
+                # TODO: special big range slicing
+                obj.to_a
+              elsif obj.is_a?(String)
+                # TODO: optionally enable/disable string iteration
+                obj.each_char.to_a
+              elsif obj.respond_to?(:each)
+                # TODO: special lazy drop slicing
+                # #each and #slice is our enumerable drop interface
+                # TODO: or just #to_a
+                obj.each.to_a
+              else
+                EMPTY_ENUM
+              end
+
+      length = array.length
+
+      # No slicing required
+      if @offset.nil? && @limit.nil?
+        context.stop_index(@name, index: length)
+        return @reversed ? array.reverse : array
+      end
+
+      start = if @offset
+                offset = context.evaluate(@offset)
+                if offset == "continue"
+                  context.stop_index(@name)
+                else
+                  Liquid2.to_i(offset)
+                end
+              else
+                0
+              end
+
+      stop = @limit ? Liquid2.to_i(context.evaluate(@limit)) + start : length
+      context.stop_index(@name, index: stop)
+
+      array = (stop ? array.slice(start...stop) : array.slice(start..)) || EMPTY_ENUM # steep:ignore
+      @reversed ? array.reverse! : array
+    end
+
+    def children
+      expressions = [@enum]
+      expressions << @limit if @limit
+      expressions << @offset if @offset
+      expressions << @cols if @cols
+      expressions
+    end
+  end
+end

data/lib/liquid2/expressions/path.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A path to some variable data.
+  # If the path has just one segment, it is often just called a "variable".
+  class Path < Expression
+    attr_reader :segments, :head
+
+    # @param segments [Array[String | Integer | Path]]
+    def initialize(token, segments)
+      super(token)
+      @segments = segments
+      @head = @segments.shift
+    end
+
+    def evaluate(context)
+      context.fetch(@head, @segments, node: self)
+    end
+
+    # TODO: fix and optimize (store it on the instance)
+    def to_s = "#{@head}.#{@segments.map(&:to_s).join(".")}"
+
+    def children
+      if @head.is_a?(Path)
+        [@head, *@segments.filter { |segment| segment.is_a?(Path) }]
+      else
+        @segments.filter { |segment| segment.is_a?(Path) }
+      end
+    end
+  end
+end

data/lib/liquid2/expressions/range.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # A range expression.
+  class RangeExpression < Expression
+    # @param start [Expression]
+    # @param stop [Expression]
+    def initialize(token, start, stop)
+      super(token)
+      @start = start
+      @stop = stop
+    end
+
+    def evaluate(context)
+      from = Liquid2.to_liquid_int(context.evaluate(@start))
+      to = Liquid2.to_liquid_int(context.evaluate(@stop))
+      (from..to)
+    end
+
+    def to_s
+      "(#{@start}..#{@stop})"
+    end
+
+    def children = [@start, @stop]
+  end
+end

data/lib/liquid2/expressions/relational.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "blank"
+require_relative "../expression"
+
+module Liquid2 # :nodoc:
+  # Base for comparison expressions.
+  class ComparisonExpression < 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)
+      [left, right]
+    end
+  end
+
+  # Infix ==
+  class Eq < ComparisonExpression
+    def evaluate(context)
+      Liquid2.eq?(*inner_evaluate(context))
+    end
+  end
+
+  # Infix != or <>
+  class Ne < ComparisonExpression
+    def evaluate(context)
+      !Liquid2.eq?(*inner_evaluate(context))
+    end
+  end
+
+  # Infix <=
+  class Le < ComparisonExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      Liquid2.eq?(left, right) || Liquid2.lt?(left, right)
+    end
+  end
+
+  # Infix >=
+  class Ge < ComparisonExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      Liquid2.eq?(left, right) || Liquid2.lt?(right, left)
+    end
+  end
+
+  # Infix <
+  class Lt < ComparisonExpression
+    def evaluate(context)
+      Liquid2.lt?(*inner_evaluate(context))
+    end
+  end
+
+  # Infix >
+  class Gt < ComparisonExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      Liquid2.lt?(right, left)
+    end
+  end
+
+  # Infix `contains`
+  class Contains < ComparisonExpression
+    def evaluate(context)
+      left = context.evaluate(@left)
+      right = context.evaluate(@right)
+      Liquid2.contains?(left, right)
+    end
+  end
+
+  # Infix `in`
+  class In < ComparisonExpression
+    def evaluate(context)
+      left = context.evaluate(@left)
+      right = context.evaluate(@right)
+      Liquid2.contains?(right, left)
+    end
+  end
+
+  # Test _left_ and _right_ for Liquid equality.
+  def self.eq?(left, right)
+    left, right = right, left if right.is_a?(Empty) || right.is_a?(Blank)
+    left == right
+  rescue ::ArgumentError => e
+    raise Liquid2::LiquidArgumentError, e.message
+  end
+
+  # Return `true` if _left_ is considered less than _right_.
+  def self.lt?(left, right)
+    left < right
+  rescue ::ArgumentError => e
+    raise Liquid2::LiquidArgumentError, e.message
+  end
+
+  def self.contains?(left, right)
+    return false unless left.respond_to?(:include?)
+
+    if left.is_a?(String)
+      right.nil? || Liquid2.undefined?(right) ? false : left.include?(Liquid2.to_s(right))
+    else
+      left.include?(right)
+    end
+  rescue ::ArgumentError => e
+    raise Liquid2::LiquidArgumentError, e.message
+  end
+end

data/lib/liquid2/expressions/template_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../expression"
+
+module Liquid2
+  # Quoted string with interpolated expressions.
+  class TemplateString < Expression
+    # @param segments [Array<Expression>]
+    def initialize(token, segments)
+      super(token)
+      @segments = segments
+    end
+
+    def evaluate(context)
+      @segments.map { |expr| Liquid2.to_s(context.evaluate(expr)) }.join
+    end
+
+    def children = @segments
+  end
+end