liquid2 0.1.1 → 0.2.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,8 +45,28 @@ 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
 
+    # @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(
       context_depth_limit: 30,
       globals: nil,
@@ -53,7 +76,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 = {}
@@ -99,10 +123,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 +146,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 +183,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 +209,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/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/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/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)

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

@@ -1,3 +1,272 @@
 # frozen_string_literal: true
 
-# TODO
+require_relative "../../tag"
+
+module Liquid2
+  # The _extends_ tag.
+  class ExtendsTag < Tag
+    attr_reader :template_name
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param parser [Parser]
+    # @return [ExtendsTag]
+    def self.parse(token, parser)
+      name = parser.parse_name
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name)
+    end
+
+    def initialize(token, name)
+      super(token)
+      @template_name = name
+      @blank = false
+    end
+
+    def render(context, buffer)
+      base_template = stack_blocks(context, context.template)
+      context.extend({}, template: base_template) do
+        base_template&.render_with_context(context, buffer)
+      end
+      context.tag_namespace[:extends].clear
+      context.interrupts << :stop_render
+    end
+
+    def children(static_context, include_partials: true)
+      return [] unless include_partials
+
+      begin
+        parent = static_context.env.get_template(
+          @template_name,
+          context: static_context,
+          tag: "extends"
+        )
+        parent.ast
+      rescue LiquidTemplateNotFoundError => e
+        e.token = @token
+        e.template_name = static_context.template.full_name
+        raise e
+      end
+    end
+
+    def partial_scope
+      Partial.new(@template_name, :inherited, [])
+    end
+
+    protected
+
+    # Visit all templates in the inheritance chain and build a stack for each `block` tag.
+    def stack_blocks(context, template)
+      # @type var stacks: Hash[String, Array[untyped]]
+      stacks = context.tag_namespace[:extends]
+
+      # Guard against recursive `extends`.
+      seen_extends = Set[] # : Set[String]
+
+      # @type var stack_blocks_: ^(Template) -> Template?
+      stack_blocks_ = lambda do |template_|
+        extends_nodes, block_nodes = inheritance_nodes(context, template_)
+        template_name = template_.path || template_.name
+
+        if extends_nodes.length > 1
+          raise TemplateInheritanceError.new("too many 'extends' tags", extends_nodes[1].token,
+                                             template_name: template_name)
+        end
+
+        # Identify duplicate blocks.
+        seen_blocks = Set[] # : Set[String]
+
+        block_nodes.each do |block|
+          if seen_blocks.include?(block.block_name)
+            raise TemplateInheritanceError.new("duplicate block #{block.block_name.inspect}",
+                                               block.token, template_name: template_name)
+          end
+
+          seen_blocks.add(block.block_name)
+
+          stack = stacks[block.block_name]
+          required = !stack.empty? && !block.required ? false : block.required
+          # [block, required, template, parent]
+          # [BlockTag, bool, Template, untyped?]
+          stack << [block, required, template_, nil]
+          # Populate parent block.
+          stack[-2][-1] = stack.last if stack.length > 1
+        end
+
+        return nil if extends_nodes.empty? # steep:ignore
+
+        extends_node = extends_nodes.first
+
+        if seen_extends.include?(extends_node.template_name)
+          raise TemplateInheritanceError.new(
+            "circular extends #{extends_node.template_name.inspect}",
+            extends_node.token,
+            template_name: template_name
+          )
+        end
+
+        seen_extends.add(extends_node.template_name)
+
+        begin
+          context.env.get_template(extends_node.template_name, context: context, tag: "extends")
+        rescue LiquidTemplateNotFoundError => e
+          e.token = extends_node.token
+          e.template_name = template_.full_name
+          raise e
+        end
+      end
+
+      # @type var next_template: Template?
+      base = next_template = stack_blocks_.call(template)
+
+      while next_template
+        next_template = stack_blocks_.call(next_template)
+        base = next_template if next_template
+      end
+
+      base
+    end
+
+    # Traverse the template's syntax tree looking for `{% extends %}` and `{% block %}`.
+    # @return [[Array[ExtendsTag], Array[BlockTag]]]
+    def inheritance_nodes(context, template)
+      extends_nodes = [] # : Array[ExtendsTag]
+      block_nodes = [] # : Array[BlockTag]
+
+      # @type var visit: ^(Node) -> void
+      visit = lambda do |node|
+        extends_nodes << node if node.is_a?(ExtendsTag)
+        block_nodes << node if node.is_a?(BlockTag)
+
+        node.children(context, include_partials: false).each do |child|
+          visit.call(child) if child.is_a?(Node)
+        end
+      end
+
+      template.ast.each { |node| visit.call(node) if node.is_a?(Node) }
+
+      [extends_nodes, block_nodes]
+    end
+  end
+
+  # The _block_ tag.
+  class BlockTag < Tag
+    attr_reader :block_name, :required, :block
+
+    END_BLOCK = Set["endblock"]
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param parser [Parser]
+    # @return [BlockTag]
+    def self.parse(token, parser)
+      block_name = parser.parse_name
+      required = if parser.current_kind == :token_required
+                   parser.next
+                   true
+                 else
+                   false
+                 end
+
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+      parser.eat_empty_tag("endblock")
+      new(token, block_name, block, required: required)
+    end
+
+    def initialize(token, name, block, required:)
+      super(token)
+      @block_name = name
+      @block = block
+      @required = required
+      @blank = false
+    end
+
+    def render(context, buffer)
+      # @type var stack: Array[[BlockTag, bool, Template, untyped?]]
+      stack = context.tag_namespace[:extends][@block_name]
+
+      if stack.empty?
+        # This base block is being rendered directly.
+        if @required
+          raise RequiredBlockError.new("block #{@block_name.inspect} is required",
+                                       @token)
+        end
+
+        context.extend({ "block" => BlockDrop.new(token, context, @block_name, nil) }) do
+          @block.render(context, buffer)
+        end
+
+        return
+      end
+
+      block_tag, required, template, parent = stack.first
+
+      if required
+        raise RequiredBlockError.new("block #{@block_name.inspect} is required", @token,
+                                     template_name: template.path || template.name)
+      end
+
+      namespace = { "block" => BlockDrop.new(token, context, @block_name, parent) }
+
+      block_context = context.copy(namespace,
+                                   carry_loop_iterations: true,
+                                   block_scope: true,
+                                   template: template)
+
+      begin
+        block_tag.block.render(block_context, buffer)
+      rescue LiquidError => e
+        e.template_name = template.path || template.name
+        e.source = template.source
+        raise
+      end
+    end
+
+    def children(_static_context, include_partials: true)
+      [@block]
+    end
+
+    def block_scope
+      [Identifier.new([:token_word, "block", @token.last])]
+    end
+  end
+
+  # A `block` object available within `{% block %}` tags.
+  class BlockDrop
+    attr_reader :token
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param context [RenderContext]
+    # @param name [String]
+    # @param parent [[BlockTag, bool, Template, Block?]?]
+    def initialize(token, context, name, parent)
+      @token = token
+      @context = context
+      @name = name
+      @parent = parent
+    end
+
+    def to_s = "BlockDrop(#{@name})"
+
+    def key?(key)
+      key == "super" && @parent
+    end
+
+    def [](key)
+      return nil if key != "super" || @parent.nil?
+
+      parent = @parent || raise
+      buf = +""
+      namespace = { "block" => BlockDrop.new(parent.first.token,
+                                             @context,
+                                             parent[2].path || parent[2].name,
+                                             parent.last) }
+      @context.extend(namespace) do
+        parent.first.block.render(@context, buf)
+      end
+
+      buf.freeze
+    end
+  end
+end