liquid2 0.1.1 → 0.3.0

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

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

@@ -47,7 +47,7 @@ module Liquid2
     # @param args [Array<KeywordArgument> | nil]
     def initialize(token, name, repeat, var, as, args)
       super(token)
-      @name = name
+      @template_name = name
       @repeat = repeat
       @var = var
       @as = as
@@ -56,7 +56,7 @@ module Liquid2
     end
 
     def render(context, buffer)
-      name = context.evaluate(@name)
+      name = context.evaluate(@template_name)
       template = context.env.get_template(name.to_s, context: context, tag: :include)
       namespace = @args.to_h { |arg| [arg.name, context.evaluate(arg.value)] }
 
@@ -90,7 +90,7 @@ module Liquid2
     def children(static_context, include_partials: true)
       return [] unless include_partials
 
-      name = static_context.evaluate(@name)
+      name = static_context.evaluate(@template_name)
       template = static_context.env.get_template(name.to_s, context: static_context, tag: :include)
       template.ast
     rescue LiquidTemplateNotFoundError => e
@@ -100,7 +100,7 @@ module Liquid2
     end
 
     def expressions
-      exprs = [@name]
+      exprs = [@template_name]
       exprs << @var if @var
       exprs.concat(@args.map(&:value))
       exprs
@@ -112,12 +112,12 @@ module Liquid2
       if @var
         if @as
           scope << @as # steep:ignore
-        elsif @name.is_a?(String)
-          scope << Identifier.new([:token_word, @name.split(".").first, @token.last])
+        elsif @template_name.is_a?(String)
+          scope << Identifier.new([:token_word, @template_name.split(".").first, @token.last])
         end
       end
 
-      Partial.new(@name, :shared, scope)
+      Partial.new(@template_name, :shared, scope)
     end
   end
 end

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

@@ -1,3 +1,147 @@
 # frozen_string_literal: true
 
-# TODO
+require_relative "../../tag"
+
+module Liquid2
+  # The _macro_ tag.
+  class MacroTag < Tag
+    attr_reader :macro_name, :params, :block
+
+    END_BLOCK = Set["endmacro"]
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param parser [Parser]
+    # @return [MacroTag]
+    def self.parse(token, parser)
+      name = parser.parse_name
+      parser.next if parser.current_kind == :token_comma
+      params = parser.parse_parameters
+      parser.next if parser.current_kind == :token_comma
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+      parser.eat_empty_tag("endmacro")
+      new(token, name, params, block)
+    end
+
+    def initialize(token, name, params, block)
+      super(token)
+      @macro_name = name
+      @params = params
+      @block = block
+      @blank = true
+    end
+
+    def render(context, _buffer)
+      # Macro tags don't render or evaluate anything, just store their parameter list
+      # and block on the render context so it can be called later by a `call` tag.
+      context.tag_namespace[:macros][@macro_name] = [@params, @block]
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def expressions = @params.values.filter_map(&:value)
+
+    def block_scope
+      [
+        Identifier.new([:token_word, "args", @token.last]),
+        Identifier.new([:token_word, "kwargs", @token.last]),
+        *@params.values.map { |param| Identifier.new([:token_word, param.name, param.token.last]) }
+      ]
+    end
+  end
+
+  # The _call_ tag.
+  class CallTag < Tag
+    attr_reader :macro_name, :args, :kwargs
+
+    DISABLED_TAGS = Set["include", "block"]
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param parser [Parser]
+    # @return [CallTag]
+    def self.parse(token, parser)
+      name = parser.parse_name
+      parser.next if parser.current_kind == :token_comma
+      args, kwargs = parser.parse_arguments
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name, args, kwargs)
+    end
+
+    def initialize(token, name, args, kwargs)
+      super(token)
+      @macro_name = name
+      @args = args
+      @kwargs = kwargs
+      @blank = false
+    end
+
+    def render(context, buffer)
+      # @type var params: Hash[String, Parameter]?
+      # @type var block: Block
+      params, block = context.tag_namespace[:macros][@macro_name]
+
+      unless params
+        buffer << Liquid2.to_output_string(context.env.undefined(@macro_name, node: self))
+        return
+      end
+
+      # Parameter names mapped to default values. :undefined is used if there is no default.
+      args = params.values.to_h { |p| [p.name, p.value] }
+      excess_args = [] # : Array[untyped]
+      excess_kwargs = {} # : Hash[String, untyped]
+
+      # Update args with positional arguments.
+      # Keyword arguments are pushed to the end if they appear before positional arguments.
+      names = args.keys
+      length = @args.length
+      index = 0
+      while index < length
+        name = names[index]
+        expr = @args[index]
+        if name.nil?
+          excess_args << expr
+        else
+          args[name] = expr
+        end
+        index += 1
+      end
+
+      # Update args with keyword arguments.
+      @kwargs.each do |arg|
+        if params.include?(arg.name)
+          # This has the potential to override a positional argument.
+          args[arg.name] = arg.value
+        else
+          excess_kwargs[arg.name] = arg.value
+        end
+      end
+
+      # @type var namespace: Hash[String, untyped]
+      namespace = {
+        "args" => excess_args.map { |arg| context.evaluate(arg) },
+        "kwargs" => excess_kwargs.transform_values! { |val| context.evaluate(val) }
+      }
+
+      args.each do |k, v|
+        namespace[k] = if v == :undefined
+                         context.env.undefined(k, node: params[k])
+                       else
+                         context.evaluate(v)
+                       end
+      end
+
+      macro_context = context.copy(
+        namespace,
+        disabled_tags: DISABLED_TAGS,
+        carry_loop_iterations: true
+      )
+
+      block.render(macro_context, buffer)
+    end
+
+    def expressions
+      [*@args, *@kwargs.map(&:value)]
+    end
+  end
+end

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/nodes/tags/render.rb

@@ -12,8 +12,6 @@ module Liquid2
     # @return [RenderTag]
     def self.parse(token, parser)
       name = parser.parse_string
-      raise LiquidTypeError, "expected a string literal" unless name.is_a?(String)
-
       repeat = false
       var = nil # : Expression?
       as = nil # : Identifier?
@@ -51,7 +49,7 @@ module Liquid2
     # @param args [Array<KeywordArgument> | nil]
     def initialize(token, name, repeat, var, as, args)
       super(token)
-      @name = name
+      @template_name = name
       @repeat = repeat
       @var = var
       @as = as&.name
@@ -60,7 +58,7 @@ module Liquid2
     end
 
     def render(context, buffer)
-      template = context.env.get_template(@name, context: context, tag: :render)
+      template = context.env.get_template(@template_name, context: context, tag: :render)
       namespace = @args.to_h { |arg| [arg.name, context.evaluate(arg.value)] }
 
       ctx = context.copy(namespace,
@@ -96,7 +94,7 @@ module Liquid2
         template.render_with_context(ctx, buffer, partial: true, block_scope: true)
       end
     rescue LiquidTemplateNotFoundError => e
-      e.token = @name
+      e.token = @template_name
       e.template_name = context.template.full_name
       raise e
     end
@@ -104,7 +102,7 @@ module Liquid2
     def children(static_context, include_partials: true)
       return [] unless include_partials
 
-      name = static_context.evaluate(@name)
+      name = static_context.evaluate(@template_name)
       template = static_context.env.get_template(name.to_s, context: static_context, tag: :include)
       template.ast
     rescue LiquidTemplateNotFoundError => e
@@ -114,7 +112,7 @@ module Liquid2
     end
 
     def expressions
-      exprs = [@name]
+      exprs = [@template_name]
       exprs << @var if @var
       exprs.concat(@args.map(&:value))
       exprs
@@ -126,12 +124,12 @@ module Liquid2
       if @var
         if @as
           scope << @as # steep:ignore
-        elsif @name.is_a?(String)
-          scope << Identifier.new([:token_word, @name.split(".").first, @token.last])
+        elsif @template_name.is_a?(String)
+          scope << Identifier.new([:token_word, @template_name.split(".").first, @token.last])
         end
       end
 
-      Partial.new(@name, :isolated, scope)
+      Partial.new(@template_name, :isolated, scope)
     end
   end
 end

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

@@ -1,3 +1,44 @@
 # frozen_string_literal: true
 
-# TODO
+require_relative "../../tag"
+
+module Liquid2
+  # The _with_ tag.
+  class WithTag < Tag
+    END_BLOCK = Set["endwith"]
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param parser [Parser]
+    # @return [WithTag]
+    def self.parse(token, parser)
+      parser.next if parser.current_kind == :token_comma
+      args = parser.parse_keyword_arguments
+      parser.next if parser.current_kind == :token_comma
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+      parser.eat_empty_tag("endwith")
+      new(token, args, block)
+    end
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param args [Array[KeywordArgument]]
+    # @param block [Block]
+    def initialize(token, args, block)
+      super(token)
+      @args = args
+      @block = block
+      @blank = block.blank
+    end
+
+    def render(context, buffer)
+      namespace = @args.to_h { |arg| [arg.name, context.evaluate(arg.value)] }
+      context.extend(namespace) do
+        @block.render(context, buffer)
+      end
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def block_scope = @args.map { |arg| Identifier.new(arg.token) }
+  end
+end