luoma 0.1.0

data/lib/luoma/loader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Luoma
+  # The base class for all template loaders.
+  class TemplateLoader
+    # Load and return template source text and any associated data.
+    #: (Environment, String, ?context: RenderContext?, **untyped) -> TemplateSource
+    def get_source(env, name, context: nil, **kwargs)
+      raise "not implemented"
+    end
+
+    #: (Environment, String, ?globals: t_namespace?, ?context: RenderContext?, **kwargs) -> Template
+    def load(env, name, globals: nil, context: nil, **kwargs)
+      data = get_source(env, name, context: context, **kwargs)
+      env.parse(data.source,
+                name: data.name,
+                globals: globals,
+                up_to_date: data.up_to_date,
+                overlay: data.matter)
+    end
+  end
+
+  # Template source text and meta data.
+  class TemplateSource
+    attr_accessor :source, :name, :up_to_date, :matter
+
+    def initialize(source:, name:, up_to_date: nil, matter: nil)
+      @source = source
+      @name = name
+      @up_to_date = up_to_date
+      @matter = matter
+    end
+  end
+
+  # A template loader that reads templates from a hash.
+  class HashLoader < TemplateLoader
+    #: (Hash<String, String>) -> void
+    def initialize(templates)
+      super()
+      @templates = templates
+    end
+
+    def get_source(env, name, context: nil, **kwargs)
+      source = @templates[name]
+      raise TemplateNotFoundError.new("template not found #{name}") unless source
+
+      TemplateSource.new(source: source, name: name)
+    end
+  end
+end

data/lib/luoma/loaders/choice_loader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ChoiceLoader < TemplateLoader
+    def initialize(*loaders)
+      super
+      @loaders = loaders
+    end
+
+    def load(env, name, **kwargs)
+      @loaders.each do |loader|
+        return loader.load(env, name, **kwargs)
+      rescue TemplateNotFoundError
+        next
+      end
+
+      raise TemplateNotFoundError.new("template not found #{name.inspect}")
+    end
+  end
+end

data/lib/luoma/loaders/file_system_loader.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Luoma
+  # A template loader that reads template from a file system.
+  class FileSystemLoader < TemplateLoader
+    def initialize(search_path, default_extension: nil)
+      super()
+      @search_path = if search_path.is_a?(Array)
+                       search_path.map { |p| Pathname.new(p) }
+                     else
+                       [Pathname.new(search_path)]
+                     end
+
+      @default_extension = default_extension
+    end
+
+    def get_source(_env, name, context: nil, **_kwargs)
+      path = resolve_path(name)
+      mtime = path.mtime
+      up_to_date = -> { path.mtime == mtime }
+      TemplateSource.new(source: path.read, name: path.basename.to_s, up_to_date: up_to_date)
+    end
+
+    def resolve_path(template_name)
+      template_path = Pathname.new(template_name)
+
+      # Append the default file extension if needed.
+      if @default_extension && template_path.extname.empty?
+        template_path = template_path.sub_ext(@default_extension || raise)
+      end
+
+      # TODO: better relative path check
+
+      # Don't alow template names to escape the search path with "../".
+      template_path.each_filename do |part|
+        next unless part == ".."
+
+        raise TemplateNotFoundError.new("template not found #{template_name}")
+      end
+
+      # Search each path in turn.
+      @search_path.each do |path|
+        source_path = path.join(template_path)
+        return source_path if source_path.file?
+      end
+
+      raise TemplateNotFoundError.new("template not found #{template_name}")
+    end
+  end
+
+  # A file system template loader that caches parsed templates.
+  class CachingFileSystemLoader < FileSystemLoader
+    include CachingLoaderMixin
+
+    def initialize(
+      search_path,
+      default_extension: nil,
+      auto_reload: true,
+      namespace_key: "",
+      capacity: 300,
+      thread_safe: false
+    )
+      super(search_path, default_extension: default_extension)
+
+      initialize_cache(
+        auto_reload: auto_reload,
+        namespace_key: namespace_key,
+        capacity: capacity,
+        thread_safe: thread_safe
+      )
+    end
+  end
+end

data/lib/luoma/loaders/mixins.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../cache"
+
+module Luoma
+  # A mixin that adds caching to a template loader.
+  module CachingLoaderMixin
+    def initialize_cache(auto_reload: true, namespace_key: "", capacity: 300, thread_safe: false)
+      @auto_reload = auto_reload
+      @namespace_key = namespace_key
+      @cache = if thread_safe
+                 ThreadSafeLRUCache.new(capacity)
+               else
+                 LRUCache.new(capacity)
+               end
+    end
+
+    def load(env, name, globals: nil, context: nil, **)
+      key = cache_key(name, context: context, **)
+
+      # @type var template: Template
+      # @type var cached_template: Template
+      if (cached_template = @cache[key])
+        if @auto_reload && cached_template.up_to_date? == false
+          template = super
+          @cache[key] = template
+          template
+        else
+          cached_template
+        end
+      else
+        template = super
+        @cache[key] = template
+        template
+      end
+    end
+
+    def cache_key(name, context: nil, **kwargs)
+      return name unless @namespace_key
+
+      key = (@namespace_key || raise).to_sym
+      return "#{kwargs[key]}/#{name}" if kwargs.include?(key)
+      return name unless context
+
+      if (namespace = context.globals[@namespace_key || raise])
+        "#{namespace}/#{name}"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/luoma/markup.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Luoma
+  # The base class for all tag nodes and the output statement.
+  class Markup
+    attr_reader :token, :blank, :tag_name
+
+    #: (t_token) -> void
+    def initialize(token)
+      @token = token
+      @blank = false
+      @tag_name = ""
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      raise "not implemented"
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      []
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      []
+    end
+
+    #: () -> Array[Name]
+    def block_scope
+      []
+    end
+
+    #: () -> Array[Name]
+    def template_scope
+      []
+    end
+
+    #: (RenderContext) -> Partial?
+    def partial(static_context)
+      nil
+    end
+  end
+
+  class Partial
+    attr_reader :template, :scope_kind, :in_scope, :key
+
+    #: (Template, :shared | :isolated | :inherited, Array[Name], Integer) -> void
+    def initialize(template, scope_kind, in_scope, key)
+      @template = template
+      @scope_kind = scope_kind
+      @in_scope = in_scope
+      @key = key
+    end
+  end
+
+  #: (t_block, RenderContext, String, ?root: false) -> void
+  def self.render_block(block, context, buffer, root: false)
+    if context.env.max_render_score || context.env.max_render_score_cumulative
+      context.render_score += block.length
+      context.render_score_cumulative += block.length
+
+      if (context.env.max_render_score && context.render_score > context.env.max_render_score) ||
+         (context.env.max_render_score_cumulative &&
+          context.render_score_cumulative > context.env.max_render_score_cumulative)
+        raise ResourceLimitError.new("memory limits reached")
+      end
+    end
+
+    block.each do |node|
+      if node.is_a?(String)
+        buffer << node
+      else
+        if context.disabled_tags&.include?(node.tag_name)
+          raise DisabledTagError.new(
+            "#{node.tag_name.inspect} is not allowed in this context",
+            node.token,
+            context.template.source,
+            context.template.name
+          )
+        end
+
+        node.render(context, buffer)
+
+        # TODO: disable these when strict is false?
+        if root && !context.interrupts.empty?
+          raise TemplateSyntaxError.new(
+            "unexpected #{context.interrupts.last}",
+            node.token,
+            context.template.source,
+            context.template.name
+          )
+        end
+      end
+
+      if context.env.max_render_size && buffer.bytesize > context.env.max_render_size
+        raise ResourceLimitError.new("memory limits exceeded")
+      end
+
+      break unless context.interrupts.empty?
+    end
+  end
+
+  #: (t_block) -> bool
+  def self.blank_block?(block)
+    block.all? { |node| node.is_a?(String) ? node.match?(/\A\s*\Z/) : node.blank }
+  end
+end

data/lib/luoma/parser.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module Luoma
+  class Parser
+    attr_reader :source, :template_name, :env
+
+    TERMINATE_EXPRESSION = Set.new(%i[
+                                     token_wc
+                                     token_out_end
+                                     token_tag_end
+                                     token_text
+                                     token_rparen
+                                     token_eoi
+                                     token_if
+                                     token_else
+                                     token_interpolation_end
+                                   ]).freeze #: Set[t_token_kind]
+
+    #: (Environment, String, String, Array[t_token]) -> t_block
+    def self.parse(env, source, template_name, tokens)
+      new(env, source, template_name, tokens).parse_block
+    end
+
+    #: (Environment, String, String, Array[t_token]) -> void
+    def initialize(env, source, template_name, tokens)
+      @env = env
+      @source = source
+      @template_name = template_name
+      @tokens = tokens
+
+      @pos = 0
+      @eoi = [:token_eoi, source.length, source.length]
+      @whitespace_control_carry = nil #: "-" | "+" | "~" | nil
+    end
+
+    #: () -> void
+    def carry_whitespace_control
+      @whitespace_control_carry = (Luoma.get_token_value(self.next, @source) if kind == :token_wc)
+    end
+
+    #: () -> t_token
+    def current
+      @tokens[@pos] || @eoi
+    end
+
+    #: () -> t_token_kind
+    def kind
+      (@tokens[@pos] || @eoi).first #: t_token_kind
+    end
+
+    #: () -> String
+    def current_value
+      Luoma.get_token_value(@tokens[@pos] || @eoi, @source)
+    end
+
+    #: () -> t_token
+    def next
+      token = @tokens[@pos] || @eoi
+      @pos += 1
+      token
+    end
+
+    def peek(offset = 1)
+      @tokens[@pos + offset] || @eoi
+    end
+
+    #: (t_token_kind, ?message: String?) -> t_token
+    def eat(kind, message: nil)
+      token = @tokens[@pos] || @eoi
+      unless token.first == kind
+        kind_ = Luoma::TOKEN_KIND_MAP[token.first]
+        value = Luoma.get_token_value(token, @source).inspect
+        raise TemplateSyntaxError.new(
+          message || "unexpected #{kind_} (#{value})",
+          token,
+          @source,
+          @template_name
+        )
+      end
+
+      @pos += 1
+      token
+    end
+
+    #: (String) -> t_token
+    def eat_empty_tag(name)
+      eat(:token_tag_start, message: "expected tag #{name}")
+      @pos += 1 if kind == :token_wc # steep:ignore
+      token = eat(:token_tag_name, message: "expected tag #{name}")
+      got = Luoma.get_token_value(token, @source)
+
+      unless got == name
+        raise TemplateSyntaxError.new(
+          "unexpected tag #{got.inspect}",
+          token,
+          @source,
+          @template_name
+        )
+      end
+
+      carry_whitespace_control
+      eat(:token_tag_end, message: "expected a closing tag delimiter")
+      token
+    end
+
+    #: (Set[t_token_kind]) -> t_token
+    def eat_one_of(kinds)
+      token = @tokens[@pos] || @eoi
+      unless kinds.include?(token.first)
+        kind_ = Luoma::TOKEN_KIND_MAP[token.first]
+        value = Luoma.get_token_value(token, @source).inspect
+        raise TemplateSyntaxError.new(
+          "unexpected #{kind_} (#{value})",
+          token,
+          @source,
+          @template_name
+        )
+      end
+
+      @pos += 1
+      token
+    end
+
+    #: (String) -> t_token
+    def eat_tag(name)
+      eat(:token_tag_start, message: "expected tag #{name}")
+      @pos += 1 if kind == :token_wc # steep:ignore
+      token = eat(:token_tag_name, message: "expected tag #{name}")
+      got = Luoma.get_token_value(token, @source)
+
+      unless got == name
+        raise TemplateSyntaxError.new(
+          "unexpected tag #{got.inspect}",
+          token,
+          @source,
+          @template_name
+        )
+      end
+
+      # Ignore everything between the tag name and the closing tag delimiter.
+      @pos += 1 until TERMINATE_EXPRESSION.include?(kind)
+
+      carry_whitespace_control
+      eat(:token_tag_end, message: "expected a closing tag delimiter")
+      token
+    end
+
+    # Raise an error if we're not at the start of an expression.
+    #: () -> void
+    def expect_expression
+      if TERMINATE_EXPRESSION.include?(kind)
+        raise TemplateSyntaxError.new(
+          "missing expression",
+          current,
+          @source,
+          @template_name
+        )
+      end
+    end
+
+    #: (?require_commas: bool?) -> Array[Expression | KeywordArgument]
+    def parse_arguments(require_commas: nil)
+      raise "not implemented"
+    end
+
+    #: (?stop: Set[String]?) -> t_block
+    def parse_block(stop: nil)
+      raise "not implemented"
+    end
+
+    #: (?precedence: Integer) -> Expression
+    def parse_expression(precedence: 1)
+      raise "not implemented"
+    end
+
+    #: () -> Name
+    def parse_ident
+      raise "not implemented"
+    end
+
+    #: (?require_commas: bool?) -> Array[KeywordArgument]
+    def parse_keyword_arguments(require_commas: nil)
+      raise "not implemented"
+    end
+
+    # Parse an identifier, possibly surrounded by quotes.
+    #: () -> Name
+    def parse_name
+      raise "not implemented"
+    end
+
+    #: (?require_commas: bool?) -> Array[Expression]
+    def parse_positional_arguments(require_commas: nil)
+      raise "not implemented"
+    end
+
+    #: () -> StringLiteral
+    def parse_string_literal
+      raise "not implemented"
+    end
+
+    #: () -> String
+    def peek_tag_name
+      token = current
+      token = peek if token.first == :token_wc
+
+      unless token.first == :token_tag_name
+        raise TemplateSyntaxError.new(
+          "missing tag name",
+          token,
+          @source,
+          @template_name
+        )
+      end
+
+      Luoma.get_token_value(token, @source)
+    end
+
+    #: () -> String?
+    def peek_whitespace_control
+      token = peek
+      Luoma.get_token_value(token, @source) if token.first == :token_wc
+    end
+
+    #: () -> void
+    def skip_whitespace_control
+      @pos += 1 if kind == :token_wc
+    end
+
+    # Return `true` if we're at the start of a tag named `name`.
+    #: (String) -> bool
+    def tag?(name)
+      token = peek
+      token = peek(2) if token.first == :token_wc
+
+      token.first == :token_tag_name && Luoma.get_token_value(token, @source) == name
+    end
+
+    # Return a tag name if we're at the start of a tag and that tag's name is
+    # in `names`.
+    #: (Set[String]) -> String?
+    def tags(names)
+      token = peek
+      token = peek(2) if token.first == :token_wc
+
+      return unless token.first == :token_tag_name
+
+      name = Luoma.get_token_value(token, @source)
+      name if names.include?(name)
+    end
+  end
+end