liquid2 0.1.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _liquid_ tag.
+  class LiquidTag < Tag
+    # @param parser [Parser]
+    # @return [LiquidTag]
+    def self.parse(token, parser)
+      block = parser.parse_line_statements
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, block)
+    end
+
+    def initialize(token, block)
+      super(token)
+      @block = block
+      @blank = block.blank
+    end
+
+    def render(context, buffer)
+      @block.render(context, buffer)
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _raw_ tag.
+  class RawTag < Tag
+    # @param parser [Parser]
+    # @return [RawTag]
+    def self.parse(token, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      # TODO: apply whitespace control to raw text
+      raw = parser.eat(:token_raw)
+      parser.eat_empty_tag("endraw")
+      new(token, raw[1] || raise)
+    end
+
+    # @param text [String]
+    def initialize(token, text)
+      super(token)
+      @text = text
+      @blank = false
+    end
+
+    def render(_context, buffer)
+      buffer << @text
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+require_relative "for"
+
+module Liquid2
+  DISABLED_TAGS = Set["include"]
+
+  # The standard _render_ tag.
+  class RenderTag < Tag
+    # @param parser [Parser]
+    # @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?
+
+      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 [String]
+    # @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&.name
+      @args = args
+      @blank = false
+    end
+
+    def render(context, buffer)
+      template = context.env.get_template(@name, context: context, tag: :render)
+      namespace = @args.to_h { |arg| [arg.name, context.evaluate(arg.value)] }
+
+      ctx = context.copy(namespace,
+                         template: template,
+                         disabled_tags: DISABLED_TAGS,
+                         carry_loop_iterations: true)
+
+      if @var
+        val = context.evaluate(@var || raise)
+        key = @as || template.name.split(".").first
+
+        if @repeat && val.respond_to?(:[]) && val.respond_to?(:size)
+          ctx.raise_for_loop_limit(length: val.size)
+
+          forloop = ForLoop.new(
+            key, val.size, context.env.undefined("parentloop")
+          )
+
+          namespace["forloop"] = forloop
+
+          index = 0
+          while index < val.length
+            namespace[key] = val[index]
+            index += 1
+            forloop.next
+            template.render_with_context(ctx, buffer, partial: true, block_scope: true)
+          end
+        else
+          namespace[key] = val
+          template.render_with_context(ctx, buffer, partial: true, block_scope: true)
+        end
+      else
+        template.render_with_context(ctx, buffer, partial: true, block_scope: true)
+      end
+    rescue LiquidTemplateNotFoundError => e
+      e.token = @name
+      e.template_name = context.template.full_name
+      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, :isolated, scope)
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _tablerow_ tag.
+  class TableRowTag < Tag
+    END_BLOCK = Set["endtablerow"]
+
+    def self.parse(token, parser)
+      expression = parser.parse_loop_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+      parser.eat_empty_tag("endtablerow")
+      new(token, expression, block)
+    end
+
+    def initialize(token, expression, block)
+      super(token)
+      @expression = expression
+      @block = block
+      @blank = false
+    end
+
+    def render(context, buffer)
+      array = @expression.evaluate(context)
+      name = @expression.identifier.name
+
+      context.raise_for_loop_limit(length: array.length)
+
+      cols = if @expression.cols
+               Liquid2.to_liquid_int(context.evaluate(@expression.cols))
+             else
+               array.length
+             end
+
+      drop = TableRow.new(@expression.name, array.length, cols)
+      namespace = { "tablerowloop" => drop }
+
+      buffer << "<tr class=\"row1\">\n"
+
+      context.extend(namespace) do
+        index = 0
+        while index < array.length
+          namespace[name] = array[index]
+          index += 1
+          drop.next
+
+          buffer << "<td class=\"col#{drop.col}\">"
+          @block.render(context, buffer)
+          buffer << "</td>"
+
+          buffer << "</tr>\n<tr class=\"row#{drop.row + 1}\">" if drop.col_last && !drop.last
+
+          case context.interrupts.pop
+          when :continue
+            next
+          when :break
+            break
+          end
+        end
+
+        buffer << "</tr>\n"
+      end
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def expressions = [@expression]
+
+    def block_scope
+      [@expression.identifier,
+       Identifier.new([:token_word, "tablerowloop", @expression.token.last])]
+    end
+  end
+
+  # `tablerow` loop helper variables.
+  class TableRow
+    attr_reader :name, :length, :col, :row
+
+    KEYS = Set[
+      "name",
+      "length",
+      "index",
+      "index0",
+      "rindex",
+      "rindex0",
+      "first",
+      "last",
+      "col",
+      "col0",
+      "col_first",
+      "col_last",
+      "row"
+    ]
+
+    def initialize(name, length, cols)
+      @name = name
+      @length = length
+      @cols = cols
+      @index = -1
+      @row = 1
+      @col = 0
+    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
+
+      if @col == @cols
+        @col = 1
+        @row += 1
+      else
+        @col += 1
+      end
+    end
+
+    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
+    def col0 = @col - 1
+    def col_first = @col == 1
+    def col_last = @col == @cols
+  end
+end

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

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

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "if"
+
+module Liquid2
+  # The standard _unless_ tag.
+  class UnlessTag < IfTag
+    END_TAG = "endunless"
+    END_BLOCK = Set["else", "elsif", "endunless"].freeze
+
+    def render(context, buffer)
+      return @block.render(context, buffer) unless @expression.evaluate(context)
+
+      @alternatives.each do |alt|
+        return alt.block.render(context, buffer) if alt.expression.evaluate(context)
+      end
+
+      return (@default || raise).render(context, buffer) if @default
+
+      0
+    end
+  end
+end

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

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