liquid2 0.1.0

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _case_ tag.
+  class CaseTag < Tag
+    END_BLOCK = Set["endcase", "when", "else"]
+    WHEN_DELIM = Set[:token_comma, :token_or]
+
+    def self.parse(token, parser)
+      expression = parser.parse_primary
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      parser.eat(:token_other) if parser.current_kind == :token_other
+
+      whens = [] # : Array[MultiEqualBlock]
+      default = nil # : Block?
+
+      whens << parse_when(parser, expression) while parser.tag?("when")
+
+      if parser.tag?("else")
+        parser.eat_empty_tag("else")
+        default = parser.parse_block(END_BLOCK)
+      end
+
+      parser.eat_empty_tag("endcase")
+      new(token, expression, whens, default)
+    end
+
+    # @return [MultiEqualBlock]
+    def self.parse_when(parser, expr)
+      parser.eat(:token_tag_start)
+      parser.skip_whitespace_control
+      token = parser.eat(:token_tag_name)
+
+      parser.next if parser.current_kind == :token_comma
+
+      args = [] # : Array[Expression]
+
+      loop do
+        args << parser.parse_primary(infix: false)
+        break unless WHEN_DELIM.member?(parser.current_kind)
+
+        parser.next
+      end
+
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      block = parser.parse_block(END_BLOCK)
+      MultiEqualBlock.new(token, expr, args, block)
+    end
+
+    def initialize(token, expression, whens, default)
+      super(token)
+      @expression = expression
+      @whens = whens
+      @default = default
+      @blank = whens.map(&:blank).all? && (!default || default.blank)
+    end
+
+    def render(context, buffer)
+      rendered = false
+      index = 0
+      while (node = @whens[index])
+        rendered_ = node.render(context, buffer)
+        rendered ||= rendered_
+        index += 1
+      end
+
+      (@default || raise).render(context, buffer) if @default && !rendered
+    end
+
+    def children(_static_context, include_partials: true)
+      # @type var nodes: Array[Node]
+      nodes = @whens.clone
+      nodes << (@default || raise) if @default
+      nodes
+    end
+
+    def expressions = [@expression]
+  end
+
+  # A Liquid block guarded by any one of multiple expressions.
+  class MultiEqualBlock < Node
+    # @param left [Expression]
+    # @param conditions [Array<Expression>]
+    # @param block [Block]
+    def initialize(token, left, conditions, block)
+      super(token)
+      @left = left
+      @conditions = conditions
+      @block = block
+      @blank = block.blank
+    end
+
+    def render(context, buffer)
+      left = context.evaluate(@left)
+      if @conditions.map { |right| Liquid2.eq?(left, context.evaluate(right)) }.any?
+        @block.render(context, buffer)
+        true
+      else
+        false
+      end
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def expressions = @conditions
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _cycle_ tag.
+  class CycleTag < Tag
+    # @param parser [Parser]
+    # @return [CycleTag]
+    def self.parse(token, parser)
+      items = [] # : Array[untyped]
+      group_name = nil # : untyped?
+      named = false
+      first = parser.parse_primary
+
+      # Is the first expression followed by a colon? If so, it is a group name
+      # followed by items to cycle.
+      if parser.current_kind == :token_colon
+        group_name = first
+        named = true
+        parser.next
+      else
+        items << first
+      end
+
+      parser.next if parser.current_kind == :token_comma
+
+      items.push(*parser.parse_positional_arguments)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, group_name, items, named)
+    end
+
+    # @param name [Expression?]
+    # @param items [Array<Expression>]
+    def initialize(token, name, items, named)
+      super(token)
+      @name = name
+      @items = items
+      @named = named
+      @blank = false
+    end
+
+    def render(context, buffer)
+      args = @items.map { |expr| context.evaluate(expr) }
+
+      key = if @named
+              context.evaluate(@name).to_s
+            else
+              @items.to_s
+            end
+
+      index = context.tag_namespace[:cycles][key]
+      buffer << Liquid2.to_output_s(args[index])
+
+      index += 1
+      index = 0 if index >= @items.length
+      context.tag_namespace[:cycles][key] = index
+    end
+
+    def expressions = @items
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _decrement_ tag.
+  class DecrementTag < Tag
+    # @param parser [Parser]
+    # @return [DecrementTag]
+    def self.parse(token, parser)
+      name = parser.parse_identifier(trailing_question: false)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name)
+    end
+
+    # @param name [Identifier]
+    def initialize(token, name)
+      super(token)
+      @name = name
+    end
+
+    def render(context, buffer)
+      buffer << context.decrement(@name.name).to_s
+    end
+
+    def template_scope = [@name]
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _doc_ tag.
+  class DocTag < Tag
+    def self.parse(token, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      text_token = parser.eat(:token_doc)
+      parser.eat_empty_tag("enddoc")
+      new(token, text_token[1] || raise)
+    end
+
+    # @param text [String]
+    def initialize(token, text)
+      super(token)
+      @text = text
+    end
+
+    def render(_context, _buffer) = 0
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _echo_ tag.
+  class EchoTag < Tag
+    # @param parser [Parser]
+    # @return [EchoTag]
+    def self.parse(token, parser)
+      expression = unless %i[token_whitespace_control token_tag_end].include?(parser.current_kind)
+                     parser.parse_filtered_expression
+                   end
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, expression)
+    end
+
+    def initialize(token, expression)
+      super(token)
+      @expression = expression
+      @blank = false
+    end
+
+    def render(context, buffer)
+      buffer << Liquid2.to_output_s(context.evaluate(@expression))
+    end
+
+    def expressions = [@expression]
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# TODO

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _for_ tag.
+  class ForTag < Tag
+    END_BLOCK = Set["endfor", "else"]
+
+    def self.parse(token, parser)
+      parser.expect_expression
+      expression = parser.parse_loop_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+
+      if parser.tag?("else")
+        parser.eat_empty_tag("else")
+        default = parser.parse_block(END_BLOCK)
+      else
+        default = nil
+      end
+
+      parser.eat_empty_tag("endfor")
+      new(token, expression, block, default)
+    end
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param expression [LoopExpression]
+    # @param block [Block]
+    # @param default [Block?]
+    def initialize(token, expression, block, default)
+      super(token)
+      @expression = expression
+      @block = block
+      @default = default
+      @blank = block.blank && (!default || default.blank)
+    end
+
+    def render(context, buffer)
+      array = @expression.evaluate(context)
+
+      if array.empty?
+        return @default ? (@default || raise).render(context, buffer) : 0
+      end
+
+      name = @expression.identifier.name
+      forloop = ForLoop.new(@expression.name, array.length, context.parent_loop(self))
+      namespace = { "forloop" => forloop }
+
+      context.loop(namespace, forloop) do
+        index = 0
+        while index < array.length
+          namespace[name] = array[index]
+          index += 1
+          forloop.next
+          @block.render(context, buffer)
+          case context.interrupts.pop
+          when :continue
+            next
+          when :break
+            break
+          end
+        end
+      end
+    end
+
+    def children(_static_context, include_partials: true)
+      # @type var nodes: Array[Node]
+      nodes = [@block]
+      nodes << (@default || raise) if @default
+      nodes
+    end
+
+    def expressions = [@expression]
+
+    def block_scope
+      [@expression.identifier, Identifier.new([:token_word, "forloop", @expression.token.last])]
+    end
+  end
+
+  # The standard _break_ tag.
+  class BreakTag < Tag
+    def self.parse(token, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token)
+    end
+
+    def render(context, _buffer)
+      context.interrupts << :break
+    end
+  end
+
+  # The standard _continue_ tag.
+  class ContinueTag < Tag
+    def self.parse(token, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token)
+    end
+
+    def render(context, _buffer)
+      context.interrupts << :continue
+    end
+  end
+
+  # `for` loop helper variables.
+  class ForLoop
+    attr_reader :name, :length, :parentloop
+
+    KEYS = Set[
+      "name",
+      "length",
+      "index",
+      "index0",
+      "rindex",
+      "rindex0",
+      "first",
+      "last",
+      "parentloop"
+    ]
+
+    def initialize(name, length, parent_loop)
+      @name = name
+      @length = length
+      @parentloop = parent_loop
+      @index = -1
+    end
+
+    def key?(key)
+      KEYS.member?(key)
+    end
+
+    def [](key)
+      send(key) if KEYS.member?(key)
+    end
+
+    def fetch(key, default = :undefined)
+      if KEYS.member?(key)
+        send(key)
+      else
+        default
+      end
+    end
+
+    def next = @index += 1
+    def index = @index + 1
+    def index0 = @index
+    def rindex = @length - @index
+    def rindex0 = @length - @index - 1
+    def first = @index.zero?
+    def last = @index == @length - 1
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _if_ tag
+  class IfTag < Tag
+    END_TAG = "endif"
+    END_BLOCK = Set["else", "elsif", "endif"].freeze
+
+    # @param parser [Parser]
+    # @return [IfTag]
+    def self.parse(token, parser)
+      parser.expect_expression
+      expression = BooleanExpression.new(parser.current, parser.parse_primary)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      block = parser.parse_block(self::END_BLOCK)
+      alternatives = [] # : Array[ConditionalBlock]
+      alternatives << parse_elsif(parser) while parser.tag?("elsif")
+
+      if parser.tag?("else")
+        parser.eat_empty_tag("else")
+        default = parser.parse_block(self::END_BLOCK)
+      else
+        default = nil
+      end
+
+      parser.eat_empty_tag(self::END_TAG)
+      new(token, expression, block, alternatives, default)
+    end
+
+    # @return [ConditionalBlock]
+    def self.parse_elsif(parser)
+      parser.eat(:token_tag_start)
+      parser.skip_whitespace_control
+      token = parser.eat(:token_tag_name)
+      parser.expect_expression
+      expression = BooleanExpression.new(parser.current, parser.parse_primary)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      block = parser.parse_block(self::END_BLOCK)
+      ConditionalBlock.new(token, expression, block)
+    end
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param expression [Expression]
+    # @param block [Block]
+    # @param alternatives [Array<[ConditionalBlock]>]
+    # @param default [Block?]
+    def initialize(token, expression, block, alternatives, default)
+      super(token)
+      @expression = expression
+      @block = block
+      @alternatives = alternatives
+      @default = default
+      @blank = block.blank && alternatives.all?(&:blank) && (!default || default.blank)
+    end
+
+    def render(context, buffer)
+      return @block.render(context, buffer) if context.evaluate(@expression)
+
+      index = 0
+      while (alt = @alternatives[index])
+        index += 1
+        return alt.block.render(context, buffer) if context.evaluate(alt.expression)
+      end
+
+      (@default || raise).render(context, buffer) if @default
+    end
+
+    def children(_static_context, include_partials: true)
+      # @type var nodes: Array[Node]
+      nodes = [@block, *@alternatives]
+      nodes << (@default || raise) if @default
+      nodes
+    end
+
+    def expressions = [@expression]
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _include_ tag.
+  class IncludeTag < Tag
+    # @param parser [Parser]
+    # @return [IncludeTag]
+    def self.parse(token, parser)
+      name = parser.parse_primary
+
+      repeat = false
+      var = nil # : Expression?
+      as = nil # : Identifier?
+
+      if parser.current_kind == :token_for && !%i[token_comma
+                                                  token_colon].include?(parser.peek_kind)
+        parser.next
+        repeat = true
+        var = parser.parse_primary
+        if parser.current_kind == :token_as
+          parser.next
+          as = parser.parse_identifier
+        end
+      elsif parser.current_kind == :token_with && !%i[token_comma
+                                                      token_colon].include?(parser.peek_kind)
+        parser.next
+        var = parser.parse_primary
+        if parser.current_kind == :token_as
+          parser.next
+          as = parser.parse_identifier
+        end
+      end
+
+      parser.next if parser.current_kind == :token_comma
+      args = parser.parse_keyword_arguments
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name, repeat, var, as, args)
+    end
+
+    # @param name [Expression]
+    # @param repeat [bool]
+    # @param var [Expression?]
+    # @param as [Identifier?]
+    # @param args [Array<KeywordArgument> | nil]
+    def initialize(token, name, repeat, var, as, args)
+      super(token)
+      @name = name
+      @repeat = repeat
+      @var = var
+      @as = as
+      @args = args
+      @blank = false
+    end
+
+    def render(context, buffer)
+      name = context.evaluate(@name)
+      template = context.env.get_template(name.to_s, context: context, tag: :include)
+      namespace = @args.to_h { |arg| [arg.name, context.evaluate(arg.value)] }
+
+      context.extend(namespace, template: template) do
+        if @var
+          val = context.evaluate(@var || raise)
+          key = @as&.name || template.name.split(".").first
+
+          if val.is_a?(Array)
+            context.raise_for_loop_limit(length: val.size)
+            index = 0
+            while index < val.length
+              namespace[key] = val[index]
+              template.render_with_context(context, buffer, partial: true, block_scope: false)
+              index += 1
+            end
+          else
+            namespace[key] = val
+            template.render_with_context(context, buffer, partial: true, block_scope: false)
+          end
+        else
+          template.render_with_context(context, buffer, partial: true, block_scope: false)
+        end
+      end
+    rescue LiquidTemplateNotFoundError => e
+      e.token = @token
+      e.template_name = context.template.full_name unless context.template.full_name.empty?
+      raise e
+    end
+
+    def children(static_context, include_partials: true)
+      return [] unless include_partials
+
+      name = static_context.evaluate(@name)
+      template = static_context.env.get_template(name.to_s, context: static_context, tag: :include)
+      template.ast
+    rescue LiquidTemplateNotFoundError => e
+      e.token = @token
+      e.template_name = static_context.template.full_name
+      raise e
+    end
+
+    def expressions
+      exprs = [@name]
+      exprs << @var if @var
+      exprs.concat(@args.map(&:value))
+      exprs
+    end
+
+    def partial_scope
+      scope = @args.map { |arg| Identifier.new([:token_word, arg.name, arg.token.last]) }
+
+      if @var
+        if @as
+          scope << @as # steep:ignore
+        elsif @name.is_a?(String)
+          scope << Identifier.new([:token_word, @name.split(".").first, @token.last])
+        end
+      end
+
+      Partial.new(@name, :shared, scope)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _increment_ tag.
+  class IncrementTag < Tag
+    # @param parser [Parser]
+    # @return [DecrementTag]
+    def self.parse(token, parser)
+      name = parser.parse_identifier(trailing_question: false)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name)
+    end
+
+    # @param name [Identifier]
+    def initialize(token, name)
+      super(token)
+      @name = name
+    end
+
+    def render(context, buffer)
+      buffer << context.increment(@name.name).to_s
+    end
+
+    def template_scope = [@name]
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # `{% # comment %}` style comments.
+  class InlineComment < Tag
+    attr_reader :text
+
+    def self.parse(token, parser)
+      comment = parser.eat(:token_comment)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, comment[1] || "")
+    end
+
+    # @param text [String]
+    def initialize(token, text)
+      super(token)
+      @text = text
+      return unless /\n\s*[^#\s]/.match?(text)
+
+      raise LiquidSyntaxError.new("every line must start with a '#'", token)
+    end
+
+    def render(_context, _buffer) = 0
+  end
+end