liquid2 0.1.1 → 0.3.0

data/lib/liquid2/environment.rb

@@ -21,16 +21,19 @@ require_relative "nodes/tags/cycle"
 require_relative "nodes/tags/decrement"
 require_relative "nodes/tags/doc"
 require_relative "nodes/tags/echo"
+require_relative "nodes/tags/extends"
 require_relative "nodes/tags/for"
 require_relative "nodes/tags/if"
 require_relative "nodes/tags/include"
 require_relative "nodes/tags/increment"
 require_relative "nodes/tags/inline_comment"
 require_relative "nodes/tags/liquid"
+require_relative "nodes/tags/macro"
 require_relative "nodes/tags/raw"
 require_relative "nodes/tags/render"
 require_relative "nodes/tags/tablerow"
 require_relative "nodes/tags/unless"
+require_relative "nodes/tags/with"
 
 module Liquid2
   # Template parsing and rendering configuration.
@@ -42,9 +45,30 @@ 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
+                :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.
+    # @param globals [Hash[String, untyped]?] Variables that are available to all templates
+    #   rendered from this environment.
+    # @param loader [Liquid2::Loader] An instance of `Liquid2::Loader`. A template loader
+    #   is responsible for finding and reading templates for `{% include %}` and
+    #   `{% render %}` tags, or when calling `Liquid2::Environment.get_template(name)`.
+    # @param local_namespace_limit [Integer?] The maximum allowed "size" of the template
+    #   local namespace (variables from `assign` and `capture` tags) before a
+    #   `Liquid2::LiquidResourceLimitError`` is raised.
+    # @param loop_iteration_limit [Integer?] The maximum number of loop iterations allowed
+    #   before a `LiquidResourceLimitError` is raised.
+    # @param output_stream_limit [Integer?] The maximum number of bytes that can be written
+    #   to a template's output buffer before a `LiquidResourceLimitError` is raised.
+    # @param shorthand_indexes [bool] When `true`, allow shorthand dotted array indexes as
+    #   well as bracketed indexes in variable paths. Defaults to `false`.
+    # @param suppress_blank_control_flow_blocks [bool] When `true`, suppress blank control
+    #   flow block output, so as not to include unnecessary whitespace. Defaults to `true`.
+    # @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,
@@ -53,7 +77,8 @@ module Liquid2
       output_stream_limit: nil,
       shorthand_indexes: false,
       suppress_blank_control_flow_blocks: true,
-      undefined: Undefined
+      undefined: Undefined,
+      falsy_undefined: true
     )
       # A mapping of tag names to objects responding to `parse(token, parser)`.
       @tags = {}
@@ -63,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
@@ -99,10 +128,14 @@ module Liquid2
       # unnecessary whitespace. Defaults to `true`.
       @suppress_blank_control_flow_blocks = suppress_blank_control_flow_blocks
 
-      # An instance of `Liquid2::Undefined` used to represent template variables that
-      # don't exist.
+      # A singleton returning an instance of `Liquid2::Undefined`, which is used to
+      # represent template variables that don't exist.
       @undefined = undefined
 
+      # When `true` (the default), undefined variables are considered falsy and do not
+      # raise an error when tested for truthiness.
+      @falsy_undefined = falsy_undefined
+
       # Override `setup_tags_and_filters` in environment subclasses to configure custom
       # tags and/or filters.
       setup_tags_and_filters
@@ -118,8 +151,8 @@ module Liquid2
                    name: name, path: path, up_to_date: up_to_date,
                    globals: make_globals(globals), overlay: overlay)
     rescue LiquidError => e
-      e.source = source
-      e.template_name = name unless name.empty?
+      e.source = source unless e.source
+      e.template_name = name unless e.template_name || name.empty?
       raise
     end
 
@@ -155,6 +188,20 @@ module Liquid2
       @filters.delete(name)
     end
 
+    # Add or replace a tag.
+    # @param name [String] The tag's name, as used by template authors.
+    # @param tag [responds to parse: ([Symbol, String?, Integer], Parser) -> Tag]
+    def register_tag(name, tag)
+      @tags[name] = tag
+    end
+
+    # Remove a tag from the tag register.
+    # @param name [String] The name of the tag.
+    # @return [_Tag | nil]
+    def delete_tag(name)
+      @tags.delete(name)
+    end
+
     def setup_tags_and_filters
       @tags["#"] = InlineComment
       @tags["assign"] = AssignTag
@@ -167,15 +214,20 @@ module Liquid2
       @tags["decrement"] = DecrementTag
       @tags["doc"] = DocTag
       @tags["echo"] = EchoTag
+      @tags["extends"] = ExtendsTag
+      @tags["block"] = BlockTag
       @tags["for"] = ForTag
       @tags["if"] = IfTag
       @tags["include"] = IncludeTag
       @tags["increment"] = IncrementTag
       @tags["liquid"] = LiquidTag
+      @tags["macro"] = MacroTag
+      @tags["call"] = CallTag
       @tags["raw"] = RawTag
       @tags["render"] = RenderTag
       @tags["tablerow"] = TableRowTag
       @tags["unless"] = UnlessTag
+      @tags["with"] = WithTag
 
       register_filter("abs", Liquid2::Filters.method(:abs))
       register_filter("append", Liquid2::Filters.method(:append))

data/lib/liquid2/errors.rb

@@ -7,10 +7,10 @@ module Liquid2
 
     FULL_MESSAGE = ((RUBY_VERSION.split(".")&.map(&:to_i) <=> [3, 2, 0]) || -1) < 1
 
-    def initialize(message, token = nil)
+    def initialize(message, token = nil, template_name: nil)
       super(message)
       @token = token
-      @template_name = nil
+      @template_name = template_name
       @source = nil
     end
 
@@ -76,4 +76,6 @@ module Liquid2
   class LiquidResourceLimitError < LiquidError; end
   class UndefinedError < LiquidError; end
   class DisabledTagError < LiquidError; end
+  class TemplateInheritanceError < LiquidError; end
+  class RequiredBlockError < TemplateInheritanceError; end
 end

data/lib/liquid2/expressions/arguments.rb

@@ -22,4 +22,24 @@ module Liquid2
 
     def children = [@value]
   end
+
+  # A macro parameter with a name and optional default value.
+  class Parameter < 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/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/boolean.rb

@@ -12,7 +12,8 @@ module Liquid2
     end
 
     def evaluate(context)
-      Liquid2.truthy?(context, context.evaluate(@expr))
+      value = context.evaluate(@expr)
+      Liquid2.truthy?(context, value.respond_to?(:to_liquid) ? value.to_liquid(context) : value)
     end
 
     def children = [@expr]

data/lib/liquid2/expressions/filtered.rb

@@ -15,8 +15,10 @@ module Liquid2
 
     def evaluate(context)
       left = context.evaluate(@left)
+      return left if @filters.nil?
+
       index = 0
-      while (filter = @filters[index])
+      while (filter = (@filters || raise)[index])
         left = filter.evaluate(left, context)
         index += 1
       end
@@ -81,7 +83,7 @@ module Liquid2
     attr_reader :name, :args
 
     # @param name [String]
-    # @param args [Array[Expression]]
+    # @param args [Array[Expression]?]
     def initialize(token, name, args)
       super(token)
       @name = name
@@ -92,36 +94,18 @@ module Liquid2
       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
+      return filter.call(left) if @args.nil? && !with_context # steep:ignore
+      return filter.call(left, context: context) if @args.nil? && with_context # steep:ignore
 
-    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
+        break if index >= @args.length # steep:ignore
 
-        arg = @args[index]
+        arg = @args[index] # steep:ignore
         index += 1
         if arg.respond_to?(:sym)
           keyword_args[arg.sym] = context.evaluate(arg.value)
@@ -130,7 +114,17 @@ module Liquid2
         end
       end
 
-      [positional_args, keyword_args]
+      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 || []
   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/loop.rb

@@ -33,11 +33,13 @@ module Liquid2
               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
+              elsif obj.respond_to?(:slice)
+                # Special lazy drop slicing
+                return obj.slice(context.evaluate(@offset),
+                                 context.evaluate(@limit),
+                                 @reversed) || EMPTY_ENUM
+              elsif obj.is_a?(Enumerable) # rubocop:disable Lint/DuplicateBranch
+                obj.to_a
               else
                 EMPTY_ENUM
               end

data/lib/liquid2/expressions/path.rb

@@ -8,6 +8,8 @@ module Liquid2
   class Path < Expression
     attr_reader :segments, :head
 
+    RE_PROPERTY = /\A[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*\Z/
+
     # @param segments [Array[String | Integer | Path]]
     def initialize(token, segments)
       super(token)
@@ -19,8 +21,9 @@ module Liquid2
       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 to_s
+      segment_to_s(@head, head: true) + @segments.map { |segment| segment_to_s(segment) }.join
+    end
 
     def children
       if @head.is_a?(Path)
@@ -29,5 +32,19 @@ module Liquid2
         @segments.filter { |segment| segment.is_a?(Path) }
       end
     end
+
+    private
+
+    def segment_to_s(segment, head: false)
+      if segment.is_a?(String)
+        if segment.match?(RE_PROPERTY)
+          "#{head ? "" : "."}#{segment}"
+        else
+          "[#{segment.inspect}]"
+        end
+      else
+        "[#{segment}]"
+      end
+    end
   end
 end

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/filter.rb

@@ -63,8 +63,7 @@ module Liquid2
     end
 
     # Cast _obj_ to a  date and time. Return `nil` if casting fails.
-    #
-    # TODO: This was copied from Shopify/liquid. Include their license and copyright.
+    # NOTE: This was copied from Shopify/liquid.
     def self.to_date(obj)
       return obj if obj.respond_to?(:strftime)
 

data/lib/liquid2/filters/array.rb

@@ -29,7 +29,6 @@ module Liquid2
       when :undefined
         left.compact
       else
-        # TODO: stringify key?
         left.reject do |item|
           item.respond_to?(:fetch) ? item.fetch(key, nil).nil? : true
         end

data/lib/liquid2/filters/sort.rb

@@ -3,6 +3,8 @@
 module Liquid2
   # Liquid filters and helper methods.
   module Filters
+    INFINITY_ARRAY = [Float::INFINITY].freeze # : [Float]
+
     def self.sort(left, key = nil, context:)
       left = Liquid2::Filters.to_enumerable(left)
 
@@ -82,12 +84,11 @@ module Liquid2
     end
 
     def self.ints(obj)
-      case obj
-      when Integer, Float, BigDecimal
+      if obj.is_a?(Integer) || obj.is_a?(Float) || obj.is_a?(BigDecimal)
         [obj]
       else
-        numeric = obj.to_s.scan(/-?\d+/)
-        return [Float::INFINITY] if numeric.empty?
+        numeric = obj.to_s.scan(/(?<=\.)0+|-?\d+/)
+        return INFINITY_ARRAY if numeric.empty?
 
         numeric.map(&:to_i)
       end

data/lib/liquid2/loader.rb

@@ -31,6 +31,7 @@ module Liquid2
     def load(env, name, globals: nil, context: nil, **kwargs)
       data = get_source(env, name, context: context, **kwargs)
       path = Pathname.new(data.name)
+      # FIXME: name and path
       env.parse(data.source,
                 name: path.basename.to_s,
                 path: data.name,

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

@@ -5,6 +5,8 @@ require_relative "../../tag"
 module Liquid2
   # The standard _doc_ tag.
   class DocTag < Tag
+    attr_reader :text
+
     def self.parse(token, parser)
       parser.carry_whitespace_control
       parser.eat(:token_tag_end)