liquid2 0.1.1 → 0.2.0

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/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

data/lib/liquid2/parser.rb

@@ -233,7 +233,6 @@ module Liquid2
       left = parse_primary
       left = parse_array_literal(left) if current_kind == :token_comma
       filters = parse_filters if current_kind == :token_pipe
-      filters ||= [] # : Array[Filter]
       expr = FilteredExpression.new(token, left, filters)
 
       if current_kind == :token_if
@@ -396,7 +395,7 @@ module Liquid2
     # @raises [LiquidTypeError].
     def parse_string
       node = parse_primary
-      raise LiquidTypeError, "expected a string" unless node.is_a?(String)
+      raise LiquidTypeError, "expected a string literal" unless node.is_a?(String)
 
       node
     end
@@ -411,6 +410,23 @@ module Liquid2
       Identifier.new(token)
     end
 
+    # Parse a string literals or unquoted word.
+    def parse_name
+      case current_kind
+      when :token_word
+        parse_identifier.name
+      when :token_single_quote_string, :token_double_quote_string
+        node = parse_string_literal
+        unless node.is_a?(String)
+          raise LiquidSyntaxError.new("names can't be template strings", node.token)
+        end
+
+        node
+      else
+        raise LiquidSyntaxError.new("expected a string literal or unquoted word", current)
+      end
+    end
+
     # Parse comma separated expression.
     # Leading commas should be consumed by the caller.
     # @return [Array<Expression>]
@@ -427,7 +443,7 @@ module Liquid2
       args
     end
 
-    # Parse comma name/value pairs.
+    # Parse comma separated name/value pairs.
     # Leading commas should be consumed by the caller, if allowed.
     # @return [Array<KeywordArgument>]
     def parse_keyword_arguments
@@ -438,8 +454,7 @@ module Liquid2
 
         word = eat(:token_word)
         eat_one_of(:token_assign, :token_colon)
-        val = parse_primary
-        args << KeywordArgument.new(word, word[1] || raise, val)
+        args << KeywordArgument.new(word, word[1] || raise, parse_primary)
 
         break unless current_kind == :token_comma
 
@@ -449,6 +464,68 @@ module Liquid2
       args
     end
 
+    # Parse comma separated parameter names with optional default expressions.
+    # Leading commas should be consumed by the caller, if allowed.
+    # @return [Hash[String, Parameter]]
+    def parse_parameters
+      args = {} # : Hash[String, Parameter]
+
+      loop do
+        break if TERMINATE_EXPRESSION.member?(current_kind)
+
+        word = eat(:token_word)
+        name = word[1] || raise
+
+        case current_kind
+        when :token_assign, :token_colon
+          @pos += 1
+          args[name] = Parameter.new(word, name, parse_primary)
+          @pos += 1 if current_kind == :token_comma
+        when :comma
+          args[name] = Parameter.new(word, name, :undefined)
+          @pos += 1
+        else
+          args[name] = Parameter.new(word, name, :undefined)
+          break
+        end
+      end
+
+      args
+    end
+
+    # Parse mixed positional and keyword arguments.
+    # Leading commas should be consumed by the caller, if allowed.
+    # @return [[Array[untyped], Array[KeywordArgument]]]
+    def parse_arguments
+      args = [] # : Array[untyped]
+      kwargs = [] # : Array[KeywordArgument]
+
+      loop do
+        break if TERMINATE_EXPRESSION.member?(current_kind)
+
+        case current_kind
+        when :token_word
+          if KEYWORD_ARGUMENT_DELIMITERS.include?(peek_kind)
+            token = self.next
+            @pos += 1 # = or :
+            kwargs << KeywordArgument.new(token, token[1] || raise, parse_primary)
+          else
+            # A positional argument
+            args << parse_primary
+          end
+        else
+          # A positional argument
+          args << parse_primary
+        end
+
+        break unless current_kind == :token_comma
+
+        @pos += 1
+      end
+
+      [args, kwargs]
+    end
+
     protected
 
     class Precedence
@@ -783,7 +860,7 @@ module Liquid2
 
       unless current_kind == :token_colon || !TERMINATE_FILTER.member?(current_kind)
         # No arguments
-        return Filter.new(name, name[1] || raise, []) # TODO: optimize
+        return Filter.new(name, name[1] || raise, nil)
       end
 
       @pos += 1 # token_colon
@@ -804,7 +881,7 @@ module Liquid2
             args << parse_arrow_function
           else
             # A positional argument that is a path.
-            args << parse_path
+            args << parse_primary
           end
         when :token_lparen
           # A grouped expression or range or arrow function

data/lib/liquid2/scanner.rb

@@ -12,8 +12,6 @@ module Liquid2
   class Scanner
     attr_reader :tokens
 
-    RE_MARKUP_START = /\{[\{%#]/
-    RE_WHITESPACE = /[ \n\r\t]+/
     RE_LINE_SPACE = /[ \t]+/
     RE_WORD = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/
     RE_INT  = /-?\d+(?:[eE]\+?\d+)?/
@@ -94,31 +92,19 @@ module Liquid2
     # @param value [String?]
     # @return void
     def emit(kind, value)
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "empty span (#{kind}, #{value})" if @scanner.pos == @start
-
       @tokens << [kind, value, @start]
       @start = @scanner.pos
     end
 
     def skip_trivia
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "must emit before skipping trivia" if @scanner.pos != @start
-
-      @start = @scanner.pos if @scanner.skip(RE_WHITESPACE)
+      @start = @scanner.pos if @scanner.skip(/[ \n\r\t]+/)
     end
 
     def skip_line_trivia
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "must emit before skipping line trivia" if @scanner.pos != @start
-
       @start = @scanner.pos if @scanner.skip(RE_LINE_SPACE)
     end
 
     def accept_whitespace_control
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "must emit before accepting whitespace control" if @scanner.pos != @start
-
       ch = @scanner.peek(1)
 
       case ch
@@ -133,7 +119,7 @@ module Liquid2
     end
 
     def lex_markup
-      case @scanner.scan(RE_MARKUP_START)
+      case @scanner.scan(/\{[\{%#]/)
       when "{#"
         :lex_comment
       when "{{"
@@ -197,37 +183,30 @@ module Liquid2
     end
 
     def lex_expression
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "must emit before accepting an expression token" if @scanner.pos != @start
-
       loop do
         skip_trivia
-
-        case @scanner.get_byte
-        when "'"
+        if (value = @scanner.scan(RE_FLOAT))
+          @tokens << [:token_float, value, @start]
           @start = @scanner.pos
-          scan_string("'", :token_single_quote_string, RE_SINGLE_QUOTE_STRING_SPECIAL)
-        when "\""
+        elsif (value = @scanner.scan(RE_INT))
+          @tokens << [:token_int, value, @start]
+          @start = @scanner.pos
+        elsif (value = @scanner.scan(RE_PUNCTUATION))
+          @tokens << [TOKEN_MAP[value] || :token_unknown, value, @start]
+          @start = @scanner.pos
+        elsif (value = @scanner.scan(RE_WORD))
+          @tokens << [TOKEN_MAP[value] || :token_word, value, @start]
           @start = @scanner.pos
-          scan_string("\"", :token_double_quote_string, RE_DOUBLE_QUOTE_STRING_SPECIAL)
-        when nil
-          # End of scanner. Unclosed expression or string literal.
-          break
         else
-          @scanner.pos -= 1
-          if (value = @scanner.scan(RE_FLOAT))
-            @tokens << [:token_float, value, @start]
+          case @scanner.get_byte
+          when "'"
             @start = @scanner.pos
-          elsif (value = @scanner.scan(RE_INT))
-            @tokens << [:token_int, value, @start]
-            @start = @scanner.pos
-          elsif (value = @scanner.scan(RE_PUNCTUATION))
-            @tokens << [TOKEN_MAP[value] || :token_unknown, value, @start]
-            @start = @scanner.pos
-          elsif (value = @scanner.scan(RE_WORD))
-            @tokens << [TOKEN_MAP[value] || :token_word, value, @start]
+            scan_string("'", :token_single_quote_string, RE_SINGLE_QUOTE_STRING_SPECIAL)
+          when "\""
             @start = @scanner.pos
+            scan_string("\"", :token_double_quote_string, RE_DOUBLE_QUOTE_STRING_SPECIAL)
           else
+            @scanner.pos -= 1
             break
           end
         end
@@ -413,9 +392,6 @@ module Liquid2
     end
 
     def lex_line_statements
-      # TODO: For debugging. Comment this out when benchmarking.
-      raise "must emit before accepting an expression token" if @scanner.pos != @start
-
       skip_trivia # Leading newlines are OK
 
       if (tag_name = @scanner.scan(/(?:[a-z][a-z_0-9]*|#)/))

data/lib/liquid2/static_analysis.rb

@@ -231,7 +231,7 @@ module Liquid2
     def self.extract_filters(expression, template_name)
       filters = [] # : Array[[String, Span]]
 
-      if expression.is_a?(Liquid2::FilteredExpression)
+      if expression.is_a?(Liquid2::FilteredExpression) && !expression.filters.nil?
         expression.filters.each do |filter|
           filters << [filter.name, Span.new(template_name, filter.token.last)]
         end

data/lib/liquid2/template.rb

@@ -43,7 +43,6 @@ module Liquid2
     end
 
     def render_with_context(context, buffer, partial: false, block_scope: false, namespace: nil)
-      # TODO: don't extend if namespace is nil
       context.extend(namespace || {}) do
         index = 0
         while (node = @ast[index])
@@ -59,6 +58,8 @@ module Liquid2
 
           next unless (interrupt = context.interrupts.pop)
 
+          break if interrupt == :stop_render
+
           if !partial || block_scope
             raise LiquidSyntaxError.new("unexpected #{interrupt}",
                                         node.token) # steep:ignore
@@ -69,15 +70,14 @@ module Liquid2
         end
       end
     rescue LiquidError => e
-      e.source = @source
-      e.template_name = @name unless @name.empty?
+      e.source = context.template.source unless e.source
+      e.template_name = @name unless e.template_name || @name.empty?
       raise
     end
 
     # Merge template globals with another namespace.
     def make_globals(namespace)
-      # TODO: optimize
-      @globals.merge(@overlay || {}, namespace || {})
+      @globals.merge(@overlay, namespace || {})
     end
 
     # Return `false` if this template is stale and needs to be loaded again.
@@ -123,6 +123,53 @@ module Liquid2
       nodes
     end
 
+    # Return an array of `{% doc %}` nodes found in this template.
+    #
+    # Each instance of `Liquid2::DocTag` has a `token` and `text` attribute. Use
+    # `Template#docs.map(&:text)` to get an array of doc strings.
+    #
+    # @return [Array[DocTag]]
+    def docs
+      context = RenderContext.new(self)
+      nodes = [] # : Array[DocTag]
+
+      # @type var visit: ^(Node) -> void
+      visit = lambda do |node|
+        nodes << node if node.is_a?(DocTag)
+
+        node.children(context, include_partials: false).each do |child|
+          visit.call(child) if child.is_a?(Node)
+        end
+      end
+
+      @ast.each { |node| visit.call(node) if node.is_a?(Node) }
+
+      nodes
+    end
+
+    # Return arrays of `{% macro %}` and `{% call %}` tags found in this template.
+    # @param include_partials [bool]
+    # @return [Array[MacroTag], Array[CallTag]]
+    def macros(include_partials: false)
+      context = RenderContext.new(self)
+      macro_nodes = [] # : Array[MacroTag]
+      call_nodes = [] # : Array[CallTag]
+
+      # @type var visit: ^(Node) -> void
+      visit = lambda do |node|
+        macro_nodes << node if node.is_a?(MacroTag)
+        call_nodes << node if node.is_a?(CallTag)
+
+        node.children(context, include_partials: include_partials).each do |child|
+          visit.call(child) if child.is_a?(Node)
+        end
+      end
+
+      @ast.each { |node| visit.call(node) if node.is_a?(Node) }
+
+      [macro_nodes, call_nodes]
+    end
+
     # Return an array of variables used in this template, without path segments.
     # @param include_partials [bool]
     # @return [Array[String]]