luoma 0.1.0

data/lib/luoma/tags/case.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Luoma
+  class CaseTag < Markup
+    END_CASE_BLOCK = Set["endcase", "when", "else"]
+
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      parser.expect_expression
+      expression = parser.parse_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      # Junk between `{% case %}` and first `{% when %}`.
+      parser.eat(:token_text) if parser.kind == :token_text
+
+      blocks = [] #: Array[WhenBlock|ElseBlock]
+      blocks << WhenBlock.parse("when", parser) while parser.tag?("when")
+
+      if parser.tag?("else")
+        else_token = parser.eat_empty_tag("else")
+        blocks << ElseBlock.new(
+          else_token,
+          "else",
+          parser.parse_block(stop: END_CASE_BLOCK)
+        )
+      end
+
+      parser.eat_empty_tag("endcase")
+      new(token, tag_name, expression, blocks)
+    end
+
+    #: (t_token, String, Expression, Array[WhenBlock|ElseBlock]) -> void
+    def initialize(token, tag_name, expression, blocks)
+      super(token)
+      @tag_name = tag_name
+      @expression = expression
+      @blocks = blocks
+      @blank = blocks.all?(&:blank)
+      @blocks.each(&:filter_strings) if @blank
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      left = @expression.evaluate(context)
+
+      @blocks.each do |block|
+        if block.is_a?(ElseBlock)
+          return Luoma.render_block(block.block, context, buffer)
+        else
+          block.right.each do |expr|
+            right = expr.evaluate(context)
+            if (right.is_a?(PredicateFunction) && context.env.truthy?(right.call(context, left), context)) ||
+               context.env.eq?(left, right, context, expr.span)
+              return Luoma.render_block(block.block, context, buffer)
+            end
+          end
+        end
+      end
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @blocks
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      [@expression]
+    end
+  end
+
+  class WhenBlock < Markup
+    attr_reader :block, :right
+
+    END_CASE_BLOCK = Set["endcase", "when", "else"]
+
+    #: (String, Parser) -> WhenBlock
+    def self.parse(tag_name, parser)
+      parser.eat(:token_tag_start)
+      parser.skip_whitespace_control
+      token = parser.eat(:token_tag_name)
+
+      right = [] #: Array[Expression]
+
+      loop do
+        expr = parser.parse_expression
+        right << if parser.kind == :token_question &&
+                    expr.is_a?(Variable) &&
+                    expr.segments.empty? &&
+                    expr.root.is_a?(Name)
+                   parser.next
+                   Predicate.new(expr.token, expr.root.value)
+                 else
+                   expr
+                 end
+
+        break unless parser.kind == :token_comma
+
+        parser.next
+      end
+
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(stop: END_CASE_BLOCK)
+      new(token, tag_name, right, block)
+    end
+
+    #: (t_token, String, Array[Expression], t_block) -> void
+    def initialize(token, tag_name, right, block)
+      super(token)
+      @tag_name = tag_name
+      @right = right
+      @block = block
+      @blank = Luoma.blank_block?(block)
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      Luoma.render_block(@block, context, buffer)
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @block.grep_v(String) #: Array[Markup]
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      @right
+    end
+
+    def filter_strings
+      @block.filter! { |node| !node.is_a?(String) }
+    end
+  end
+end

data/lib/luoma/tags/comment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Luoma
+  class Comment < Markup
+    attr_reader :text
+
+    #: (t_token, String) -> void
+    def initialize(token, text)
+      super(token)
+      @text = text
+      @blank = true
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer) end
+  end
+end

data/lib/luoma/tags/continue.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ContinueTag < Markup
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, tag_name)
+    end
+
+    def initialize(token, tag_name)
+      super(token)
+      @tag_name = tag_name
+      @blank = true
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      context.interrupts.push(:continue)
+    end
+  end
+end

data/lib/luoma/tags/define.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Luoma
+  class DefineTag < Markup
+    END_DEFINE_BLOCK = Set["enddefine"]
+
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      identifier = parser.parse_ident
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(stop: END_DEFINE_BLOCK)
+      parser.eat_empty_tag("enddefine")
+      new(token, tag_name, identifier, block)
+    end
+
+    #: (t_token, String, Name, t_block) -> void
+    def initialize(token, tag_name, identifier, block)
+      super(token)
+      @tag_name = tag_name
+      @identifier = identifier
+      @block = block
+      @blank = true
+      @drop = BlockDrop.new(block)
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      context.assign(@identifier.value, @drop)
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @block.grep_v(String) #: Array[Markup]
+    end
+
+    #: () -> Array[Name]
+    def template_scope
+      [@identifier]
+    end
+  end
+end

data/lib/luoma/tags/else.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ElseBlock < Markup
+    attr_reader :expression, :block
+
+    #: (t_token, String, t_block) -> void
+    def initialize(token, tag_name, block)
+      super(token)
+      @tag_name = tag_name
+      @expression = BooleanLiteral.new(token, true)
+      @block = block
+      @blank = Luoma.blank_block?(block)
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      Luoma.render_block(@block, context, buffer)
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @block.grep_v(String) #: Array[Markup]
+    end
+
+    def filter_strings
+      @block.filter! { |node| !node.is_a?(String) }
+    end
+  end
+end

data/lib/luoma/tags/for.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ForTag < Markup
+    END_FOR_BLOCK = Set["else", "endfor"]
+
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      params = [parser.parse_ident] #: Array[Name]
+
+      while parser.kind == :token_comma
+        parser.next
+        params << parser.parse_ident
+      end
+
+      parser.eat(:token_in, message: "missing 'in'")
+      parser.expect_expression
+      expr = parser.parse_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      block = parser.parse_block(stop: END_FOR_BLOCK)
+
+      default = if parser.tag?("else")
+                  parser.eat_empty_tag("else")
+                  parser.parse_block(stop: END_FOR_BLOCK)
+                end
+
+      parser.eat_empty_tag("endfor")
+
+      new(token, tag_name, params, expr, block, default)
+    end
+
+    #: (t_token, String, Array[Name], Expression, t_block, t_block?) -> void
+    def initialize(token, tag_name, params, expression, block, default)
+      super(token)
+      @tag_name = tag_name
+      @params = params
+      @expression = expression
+
+      @blank = Luoma.blank_block?(block) && (!default || Luoma.blank_block?(default))
+
+      @block = if @blank
+                 block.grep_v(String)
+               else
+                 block
+               end
+
+      @default = if blank && default
+                   default.grep_v(String)
+                 else
+                   default
+                 end
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      array = context.env.to_a(@expression.evaluate(context), context)
+
+      if array.empty? && @default
+        Luoma.render_block(@default || raise, context, buffer)
+        return
+      end
+
+      namespace = {} #: Hash[String, untyped]
+      namespace[@params[2].value] = array if @params.length > 2
+
+      name_param = @params.first.value
+      index_param = @params[1].value if @params.length > 1
+      length = array.length
+
+      context.extends(namespace) do
+        index = 0
+        while index < length
+          namespace[name_param] = array[index]
+          namespace[index_param] = index if index_param
+          index += 1
+
+          Luoma.render_block(@block, context, buffer)
+
+          case context.interrupts.pop
+          when :continue
+            next
+          when :break
+            break
+          end
+        end
+      end
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      result = @block.grep_v(String) #: Array[Markup]
+      result.concat(@default.grep_v(String)) if @default # steep:ignore
+      result
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      [@expression, @offset, @limit].compact
+    end
+
+    #: () -> Array[Name]
+    def block_scope
+      @params
+    end
+  end
+end

data/lib/luoma/tags/if.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Luoma
+  class IfTag < Markup
+    END_IF_BLOCK = Set["else", "elif", "elsif", "endif"]
+    ELSE_IF_TAGS = Set["elif", "elsif"]
+
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      blocks = [] #: Array[IfBlock | ElseBlock]
+      parser.expect_expression
+      expression = parser.parse_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+
+      block = parser.parse_block(stop: END_IF_BLOCK)
+      blocks << IfBlock.new(token, "if", expression, block)
+
+      loop do
+        inner_tag_name = parser.tags(ELSE_IF_TAGS)
+        break unless inner_tag_name
+
+        blocks << IfBlock.parse(inner_tag_name, parser)
+      end
+
+      if parser.tag?("else")
+        name_token = parser.eat_empty_tag("else")
+        blocks << ElseBlock.new(
+          name_token,
+          "else",
+          parser.parse_block(stop: END_IF_BLOCK)
+        )
+      end
+
+      parser.eat_empty_tag("endif")
+      IfTag.new(token, tag_name, blocks)
+    end
+
+    def initialize(token, tag_name, alts)
+      super(token)
+      @tag_name = tag_name
+      @alts = alts
+      @blank = alts.all?(&:blank)
+      @alts.each(&:filter_strings) if @blank
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      index = 0
+      while (alt = @alts[index])
+        if context.env.truthy?(alt.expression.evaluate(context), context)
+          Luoma.render_block(alt.block, context, buffer)
+          break
+        end
+        index += 1
+      end
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @alts
+    end
+  end
+
+  class IfBlock < Markup
+    attr_reader :expression, :block
+
+    END_IF_BLOCK = Set["else", "elsif", "elif", "endif", "endunless"]
+
+    #: (Parser) -> Markup
+    def self.parse(tag_name, parser)
+      parser.eat(:token_tag_start)
+      parser.skip_whitespace_control
+      token = parser.eat(:token_tag_name)
+      parser.expect_expression
+      expression = parser.parse_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      IfBlock.new(token, tag_name, expression, parser.parse_block(stop: END_IF_BLOCK))
+    end
+
+    def initialize(token, tag_name, expression, block)
+      super(token)
+      @tag_name = tag_name
+      @expression = expression
+      @block = block
+      @blank = Luoma.blank_block?(block)
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      Luoma.render_block(@block, context, buffer)
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @block.grep_v(String) #: Array[Markup]
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      [@expression]
+    end
+
+    def filter_strings
+      @block.filter! { |node| !node.is_a?(String) }
+    end
+  end
+end

data/lib/luoma/tags/import.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ImportTag < Markup
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      name_expr = parser.parse_string_literal
+      name_value = name_expr.value
+
+      unless name_value
+        raise TemplateSyntaxError.new(
+          "expected a string literal",
+          name_expr.span,
+          parser.source,
+          parser.template_name
+        )
+      end
+
+      name = Name.new(name_expr.token, name_value)
+
+      namespace = if parser.current_value == "as"
+                    parser.next
+                    parser.parse_ident
+                  end
+
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, tag_name, name, namespace)
+    end
+
+    #: (t_token, String, Name, Name?) -> void
+    def initialize(token, tag_name, template_name, namespace)
+      super(token)
+      @tag_name = tag_name
+      @template_name = template_name
+      @namespace = namespace
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      begin
+        template = context.env.get_template(
+          @template_name.value,
+          context: context,
+          tag: "import"
+        )
+      rescue TemplateNotFoundError => e
+        raise NoSuchTemplateError.new(
+          e.message,
+          @template_name.span,
+          context.template.source,
+          context.template.name
+        )
+      end
+
+      ctx = context.copy(
+        {},
+        block_scope: false,
+        template: template
+      )
+
+      template.render_with_context(ctx, +"") # Discard output.
+      context.render_score_cumulative += ctx.render_score
+
+      # Update locals only.
+      if @namespace
+        context.assign(@namespace.value, ctx.locals) # steep:ignore
+      else
+        context.locals.update(ctx.locals)
+      end
+    end
+
+    #: (RenderContext) -> Partial?
+    def partial(static_context)
+      name = static_context.env.to_string(@template_name.evaluate(static_context), static_context)
+
+      template = static_context.env.get_template(
+        name,
+        context: static_context,
+        tag: "import"
+      )
+
+      Partial.new(
+        template,
+        :shared,
+        {}, #: untyped
+        Luoma.fnv1a32("im[ort-#{name}")
+      )
+    end
+  end
+end

data/lib/luoma/tags/include.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Luoma
+  class IncludeTag < Markup
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      name_expr = parser.parse_expression
+
+      # Leading commas are OK
+      parser.next if parser.kind == :token_comma
+
+      args = parser.parse_keyword_arguments(require_commas: true)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, tag_name, name_expr, args)
+    end
+
+    #: (t_token, String, Expression, Array[KeywordArgument]) -> void
+    def initialize(token, tag_name, template_name, args)
+      super(token)
+      @tag_name = tag_name
+      @template_name = template_name
+      @args = args
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      name = context.env.to_string(@template_name.evaluate(context), context)
+
+      begin
+        template = context.env.get_template(
+          name,
+          context: context,
+          tag: "include"
+        )
+      rescue TemplateNotFoundError => e
+        raise NoSuchTemplateError.new(
+          e.message,
+          @template_name.span,
+          context.template.source,
+          context.template.name
+        )
+      end
+
+      scope = @args.to_h { |arg| [arg.name.value, arg.expression.evaluate(context)] }
+
+      context.extends(scope, template: template) do
+        template.render_with_context(context, buffer, isolated: false)
+      end
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      @args.map(&:expression)
+    end
+
+    #: (RenderContext) -> Partial?
+    def partial(static_context)
+      name = static_context.env.to_string(@template_name.evaluate(static_context), static_context)
+
+      template = static_context.env.get_template(
+        name,
+        context: static_context,
+        tag: "include"
+      )
+
+      scope = @args.map(&:name)
+
+      Partial.new(
+        template,
+        :shared,
+        scope,
+        Luoma.fnv1a32("#{name}-#{scope.map(&:value).join(":")}")
+      )
+    end
+  end
+end

data/lib/luoma/tags/output.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Luoma
+  class OutputStatement < Markup
+    def initialize(token, expression)
+      super(token)
+      @expression = expression
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      buffer << context.env.serialize(@expression.evaluate(context), context)
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      [@expression]
+    end
+  end
+end

data/lib/luoma/tags/raw.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Luoma
+  class RawTag < Markup
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      text_token = parser.eat(:token_text)
+      parser.eat_empty_tag("endraw")
+      new(token, tag_name, Luoma.get_token_value(text_token, parser.source))
+    end
+
+    #: (t_token, String, String) -> void
+    def initialize(token, tag_name, text)
+      super(token)
+      @tag_name = tag_name
+      @text = text
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      buffer << @text
+    end
+  end
+end