luoma 0.1.0

data/lib/luoma/tags/render.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Luoma
+  class RenderTag < 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)
+
+      # 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, args)
+    end
+
+    #: (t_token, String, Name, 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 = @template_name.value
+
+      begin
+        template = context.env.get_template(
+          name,
+          context: context,
+          tag: "render"
+        )
+      rescue TemplateNotFoundError => e
+        raise NoSuchTemplateError.new(
+          e.message,
+          @template_name.span,
+          context.template.source,
+          context.template.name
+        )
+      end
+
+      ctx = context.copy(
+        @args.to_h { |arg| [arg.name.value, arg.expression.evaluate(context)] },
+        block_scope: false,
+        template: template
+      )
+
+      template.render_with_context(ctx, buffer)
+      context.render_score_cumulative += ctx.render_score
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      @args.map(&:expression)
+    end
+
+    #: (RenderContext) -> Partial?
+    def partial(static_context)
+      name = @template_name.value
+
+      template = static_context.env.get_template(
+        name,
+        context: static_context,
+        tag: "render"
+      )
+
+      scope = @args.map(&:name)
+
+      Partial.new(
+        template,
+        :isolated,
+        scope,
+        Luoma.fnv1a32("#{name}-#{scope.map(&:value).join(":")}")
+      )
+    end
+  end
+end

data/lib/luoma/tags/with.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Luoma
+  class WithTag < Markup
+    END_WITH_BLOCK = Set["endwith"]
+
+    #: (t_token, String, Parser) -> Markup
+    def self.parse(token, tag_name, parser)
+      args = parser.parse_keyword_arguments(require_commas: true)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(stop: END_WITH_BLOCK)
+      parser.eat_empty_tag("endwith")
+      new(token, tag_name, args, block)
+    end
+
+    #: (t_token, String, Array[KeywordArgument], t_block) -> void
+    def initialize(token, tag_name, args, block)
+      super(token)
+      @tag_name = tag_name
+      @args = args
+      @block = block
+      @blank = Luoma.blank_block?(block)
+    end
+
+    #: (RenderContext, String) -> void
+    def render(context, buffer)
+      scope = {} #: t_namespace
+
+      context.extends(scope) do
+        # NOTE: Later arguments can use earlier arguments.
+        @args.each do |arg|
+          scope[arg.name.value] = arg.expression.evaluate(context)
+        end
+
+        Luoma.render_block(@block, context, buffer)
+      end
+    end
+
+    #: (RenderContext) -> Array[Markup]
+    def children(static_context)
+      @block.grep_v(String) #: Array[Markup]
+    end
+
+    #: () -> Array[Expression]
+    def expressions
+      @args.map(&:expression)
+    end
+
+    #: () -> Array[Name]
+    def block_scope
+      @args.map(&:name)
+    end
+  end
+end

data/lib/luoma/template.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Luoma
+  class Template
+    attr_reader :env, :source, :nodes, :globals, :name, :overlay, :up_to_date
+
+    #: (Environment,
+    #   String,
+    #   t_block,
+    #   ?globals: t_namespace?,
+    #   ?name: String?,
+    #   ?overlay: t_namespace?,
+    #   ?up_to_date: Proc::_Callable?) -> void
+    def initialize(env, source, nodes, globals: nil, name: nil, overlay: nil, up_to_date: nil)
+      @env = env
+      @source = source
+      @nodes = nodes
+      @globals = globals
+      @name = name || ""
+      @overlay = overlay
+      @up_to_date = up_to_date
+      @lines = nil
+    end
+
+    # Render this template with template variables from `data`.
+    #: (t_namespace?) -> String
+    def render(data = nil)
+      buffer = +""
+      context = RenderContext.new(self, globals: make_globals(data))
+      render_with_context(context, buffer)
+    end
+
+    # Render this template to `buffer` with data from `context`.
+    # Returns buffer.
+    #
+    # _isolated_ templates raise errors for orphaned `{% break %}` and
+    # `{% continue %}` tags.
+    #
+    #: (RenderContext, String, ?isolated: bool) -> String
+    def render_with_context(context, buffer, isolated: true)
+      Luoma.render_block(@nodes, context, buffer, root: isolated)
+      buffer
+    end
+
+    # Return a copy of this template with different globals.
+    #: (t_namespace) -> Template
+    def with_globals(globals)
+      Template.new(
+        @env, @source, @nodes,
+        globals: globals,
+        name: @name,
+        overlay: @overlay,
+        up_to_date: @up_to_date
+      )
+    end
+
+    # Return this template's source code split into lines.
+    #
+    #: () -> Array[String]
+    def lines
+      @lines ||= @source.lines(chomp: false)
+    end
+
+    # Return `false` if this template is stale and needs to be loaded again.
+    # `nil` is returned if an `up_to_date` proc is not available.
+    def up_to_date?
+      @up_to_date&.call
+    end
+
+    # TODO: static analysis methods
+
+    # Statically analyze this template and report variable, tag and filter usage.
+    #
+    #: (?include_partials: bool) -> Luoma::StaticAnalysis::Result
+    def analyze(include_partials: false)
+      Luoma::StaticAnalysis.analyze(self, include_partials: include_partials)
+    end
+
+    # Return an array of variable names used in this template, without path segments.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def variables(include_partials: false)
+      analyze(include_partials: include_partials).variables.keys
+    end
+
+    # Return an array of variables used in this template, including path segments.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def variable_paths(include_partials: false)
+      analyze(include_partials: include_partials).variables.values.flatten.map { |v| v[:path] }.uniq
+    end
+
+    # Return an array of variables used in this template, each as an array of segments.
+    #
+    #: (?include_partials: bool) -> Array[Segments]
+    def variable_segments(include_partials: false)
+      analyze(include_partials: include_partials).variables.values.flatten.map { |v| v[:segments] }.uniq
+    end
+
+    # Return an array of global variables used in this template, without path segments.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def global_variables(include_partials: false)
+      analyze(include_partials: include_partials).globals.keys
+    end
+
+    # Return an array of global variables used in this template, including path segments.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def global_variable_paths(include_partials: false)
+      analyze(include_partials: include_partials).globals.values.flatten.map { |v| v[:path] }.uniq
+    end
+
+    # Return an array of global variables used in this template, each as an array of segments.
+    #
+    #: (?include_partials: bool) -> Array[Segments]
+    def global_variable_segments(include_partials: false)
+      analyze(include_partials: include_partials).globals.values.flatten.map { |v| v[:segments] }.uniq
+    end
+
+    # Return the names of all filters used in this template.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def filter_names(include_partials: false)
+      analyze(include_partials: include_partials).filters.keys
+    end
+
+    # Return the names of all tags used in this template.
+    #
+    #: (?include_partials: bool) -> Array[String]
+    def tag_names(include_partials: false)
+      analyze(include_partials: include_partials).tags.keys
+    end
+
+    # Return an array of comment nodes found in this template.
+    #
+    # Comment nodes have `token` and `text` attributes. Use `template.comments.map(&:text)`
+    # to get an array of comment strings. Each comment string includes leading and trailing
+    # whitespace.
+    #
+    # Note that this method does not try to load included or render templates when looking.
+    # for comment nodes.
+    #
+    #: () -> Array[Comment]
+    def comments
+      context = RenderContext.new(self)
+      nodes = [] # : Array[Comment]
+
+      # @type var visit: ^(Markup) -> void
+      visit = lambda do |node|
+        nodes << node if node.is_a?(Comment)
+
+        node.children(context).each do |child|
+          visit.call(child)
+        end
+      end
+
+      @nodes.each { |node| visit.call(node) unless node.is_a?(String) }
+
+      nodes
+    end
+
+    protected
+
+    # Return a new namespace including data from `namespace` and other
+    # namespaces pinned to this template.
+    #: (t_namespace?) -> t_namespace?
+    def make_globals(namespace)
+      return @globals if namespace.nil? && @overlay.nil?
+
+      namespace_ = {} #: t_namespace
+      namespace_.merge!(@globals) if @globals # steep:ignore
+      namespace_.merge!(@overlay) if @overlay # steep:ignore
+      namespace_.merge!(namespace) if namespace
+      namespace_
+    end
+  end
+end

data/lib/luoma/token.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Luoma
+  #: (t_token, String) -> String
+  def self.get_token_value(token, source)
+    source.byteslice(token[1]..token[2]) || raise
+  end
+
+  # Return a new token spanning `start` and `stop`.
+  #: (t_token, t_token) -> t_token
+  def self.span(start, stop)
+    [:token_span, start[1], stop[2]]
+  end
+
+  TOKEN_KIND_MAP = {
+    token_add: "ADD",
+    token_and: "AND",
+    token_arrow: "ARROW",
+    token_assign: "ASSIGN",
+    token_colon: "COLON",
+    token_comma: "COMMA",
+    token_comment: "COMMENT",
+    token_comment_end: "COMMENT_END",
+    token_comment_start: "COMMENT_START",
+    token_contains: "CONTAINS",
+    token_div: "DIV",
+    token_dot: "DOT",
+    token_double_dot: "DOUBLE_DOT",
+    token_double_escaped: "DOUBLE_ESCAPED",
+    token_double_quote: "DOUBLE_QUOTE",
+    token_double_quoted: "DOUBLE_QUOTED",
+    token_else: "ELSE",
+    token_eq: "EQ",
+    token_false: "FALSE",
+    token_float: "FLOAT",
+    token_ge: "GE",
+    token_gt: "GT",
+    token_ident: "IDENT",
+    token_if: "IF",
+    token_in: "IN",
+    token_int: "INT",
+    token_interpolation_end: "INTERPOLATION_END",
+    token_interpolation_start: "INTERPOLATION_START",
+    token_lbrace: "LBRACE",
+    token_lbracket: "LBRACKET",
+    token_le: "LE",
+    token_lparen: "LPAREN",
+    token_lt: "LT",
+    token_mod: "MOD",
+    token_mul: "MUL",
+    token_ne: "NE",
+    token_nil: "NIL",
+    token_not: "NOT",
+    token_null: "NULL",
+    token_or_else: "OR_ELSE",
+    token_or: "OR",
+    token_out_end: "OUT_END",
+    token_out_start: "OUT_START",
+    token_pipe: "PIPE",
+    token_question: "QUESTION",
+    token_rbrace: "RBRACE",
+    token_rbracket: "RBRACKET",
+    token_rparen: "RPAREN",
+    token_single_escaped: "SINGLE_ESCAPED",
+    token_single_quote: "SINGLE_QUOTE",
+    token_single_quoted: "SINGLE_QUOTED",
+    token_sub: "SUB",
+    token_tag_end: "TAG_END",
+    token_tag_name: "TAG_NAME",
+    token_tag_start: "TAG_START",
+    token_text: "TEXT",
+    token_triple_dot: "TRIPLE_DOT",
+    token_true: "TRUE",
+    token_wc: "WC",
+    token_eoi: "EOI",
+    token_unknown: "UNKNOWN",
+    token_hash: "HASH",
+    token_span: "SPAN",
+    token_blank: "BLANK",
+    token_empty: "EMPTY",
+    token_for: "FOR",
+    token_with: "WITH"
+  }.freeze #: Hash[t_token_kind, String]
+end

data/lib/luoma/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Luoma
+  VERSION = "0.1.0"
+end

data/lib/luoma.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+require "time"
+require_relative "luoma/chain_hash"
+require_relative "luoma/context"
+require_relative "luoma/drop"
+require_relative "luoma/environment"
+require_relative "luoma/errors"
+require_relative "luoma/expression"
+require_relative "luoma/filter"
+require_relative "luoma/fnv"
+require_relative "luoma/lexer"
+require_relative "luoma/lexer_unified"
+require_relative "luoma/loader"
+require_relative "luoma/loaders/choice_loader"
+require_relative "luoma/loaders/mixins"
+require_relative "luoma/loaders/file_system_loader"
+require_relative "luoma/markup"
+require_relative "luoma/parser"
+require_relative "luoma/parser_unified"
+require_relative "luoma/template"
+require_relative "luoma/token"
+require_relative "luoma/version"
+require_relative "luoma/drops/block"
+require_relative "luoma/drops/expression"
+require_relative "luoma/drops/range"
+require_relative "luoma/drops/undefined"
+require_relative "luoma/filters/array"
+require_relative "luoma/filters/date"
+require_relative "luoma/filters/default"
+require_relative "luoma/filters/json"
+require_relative "luoma/filters/math"
+require_relative "luoma/filters/size"
+require_relative "luoma/filters/slice"
+require_relative "luoma/filters/sort"
+require_relative "luoma/filters/string"
+require_relative "luoma/predicates/type"
+require_relative "luoma/predicates/blank"
+require_relative "luoma/predicates/empty"
+require_relative "luoma/predicates/defined"
+require_relative "luoma/static_analysis"
+require_relative "luoma/tags/assign"
+require_relative "luoma/tags/break"
+require_relative "luoma/tags/capture"
+require_relative "luoma/tags/case"
+require_relative "luoma/tags/comment"
+require_relative "luoma/tags/continue"
+require_relative "luoma/tags/define"
+require_relative "luoma/tags/else"
+require_relative "luoma/tags/for"
+require_relative "luoma/tags/if"
+require_relative "luoma/tags/import"
+require_relative "luoma/tags/include"
+require_relative "luoma/tags/output"
+require_relative "luoma/tags/raw"
+require_relative "luoma/tags/render"
+require_relative "luoma/tags/with"
+
+module Luoma
+  DEFAULT_ENVIRONMENT = Environment.new
+
+  # Parse _source_ text as a template using the default template environment.
+  #: (String, ?globals: Hash[String, untyped]?) -> Template
+  def self.parse(source, globals: nil)
+    DEFAULT_ENVIRONMENT.parse(source, globals: globals)
+  end
+
+  # Parse and render template _source_ with _data_ as template variables and
+  # the default template environment.
+  #: (String, ?Hash[String, untyped]?) -> String
+  def self.render(source, data = nil)
+    DEFAULT_ENVIRONMENT.render(source, data)
+  end
+end

data/sig/luoma/cache.rbs

@@ -0,0 +1,44 @@
+module Luoma
+  # A least recently used cache relying on Ruby hash insertion order.
+  class LRUCache
+    @data: Hash[untyped, untyped]
+
+    @max_size: Integer
+
+    attr_reader max_size: Integer
+
+    def initialize: (?::Integer max_size) -> void
+
+    # Return the cached value or nil if _key_ does not exist.
+    def []: (untyped key) -> (nil | untyped)
+
+    def []=: (untyped key, untyped value) -> untyped
+
+    def length: () -> Integer
+
+    def keys: () -> Array[untyped]
+  end
+
+  # A thread safe least recently used cache.
+  class ThreadSafeLRUCache < LRUCache
+    include MonitorMixin
+
+    alias unsafe_get []
+
+    alias unsafe_set []=
+
+    alias unsafe_length length
+
+    alias unsafe_keys keys
+
+    def initialize: (?::Integer max_size) -> void
+
+    def []: (untyped key) -> untyped
+
+    def []=: (untyped key, untyped value) -> untyped
+
+    def length: () -> Integer
+
+    def keys: () -> Array[Integer]
+  end
+end

data/sig/luoma/chain_hash.rbs

@@ -0,0 +1,26 @@
+module Luoma
+  # Combine multiple hashes for sequential lookup.
+  class ChainHash
+    @hashes: Array[Luoma::_Namespace]
+
+    #  (*_Namespace) -> void
+    def initialize: (*_Namespace hashes) -> void
+
+    #  (String) -> untyped
+    def []: (String key) -> untyped
+
+    #  (String) -> bool
+    def key?: (String key) -> untyped
+
+    #  (String, untyped) -> untyped
+    def fetch: (String key, ?untyped default) -> untyped
+
+    def size: () -> Integer
+
+    def push: (_Namespace hash) -> void
+
+    alias << push
+
+    def pop: () -> _Namespace?
+  end
+end

data/sig/luoma/context.rbs

@@ -0,0 +1,115 @@
+module Luoma
+  class RenderContext
+    # The template being rendered.
+    @template: Template
+
+    # The Luoma environment this render context and associated template is
+    # bound to.
+    @env: Environment
+
+    # Developer-defined template variables passed down from the environment
+    # and template.
+    @globals: _Namespace
+
+    # The namespace for variables defined with `{% assign %}` and
+    # `{% capture %}`.
+    @locals: Hash[String, untyped]
+
+    # A namespace for `{% increment %}` and `{% decrement %}`.
+    @counters: Hash[String, untyped]
+
+    # The current template scope including `locals`, `globals` and `counters`.
+    # New block-scoped namespaces get pushed onto and popped off this chain
+    # map.
+    #
+    # Scopes are searched from right to left. New scopes are push on the
+    # right.
+    @scopes: ChainHash
+
+    # Names of tags that are disallowed in this context.
+    @disabled_tags: Set[String]?
+
+    # The number of times this render context has been extended or copied.
+    @context_depth: Integer
+
+    # A non-specific indicator of template local scope usage.
+    @assign_score: Integer
+
+    # A non-specific indicator of template local scope usage for the current
+    # template and all partial templates combined.
+    @assign_score_cumulative: Integer
+
+    # The number of nodes rendered for the current template.
+    @render_score: Integer
+
+    # The number of nodes rendered for the current template and all partial
+    # templates.
+    @render_score_cumulative: Integer
+
+    # A stack of interrupt signals used by `{% break %}` and
+    # `{% continue %}`, for example.
+    @interrupts: Array[Symbol]
+
+    # Registers supporting stateful tags. It's OK to use this map for storing
+    # custom tag state.
+    @registers: Hash[Symbol, untyped]
+
+    attr_reader env: Environment
+
+    attr_reader template: Template
+
+    attr_reader scopes: ChainHash
+
+    attr_reader disabled_tags: Set[String]?
+
+    attr_reader context_depth: Integer
+
+    attr_reader assign_score: Integer
+
+    attr_reader assign_score_cumulative: Integer
+
+    attr_accessor render_score: Integer
+
+    attr_accessor render_score_cumulative: Integer
+
+    attr_accessor interrupts: Array[Symbol]
+
+    attr_reader registers: Hash[Symbol, untyped]
+
+    attr_reader globals: _Namespace
+
+    attr_reader locals: Hash[String, untyped]
+
+    #  (Template, ?globals: _Namespace?) -> void
+    def initialize: (Template template, ?globals: _Namespace?, ?disabled_tags: Set[String]?, ?context_depth: Integer?, ?assign_score_carry: Integer?, ?render_score_carry: Integer?) -> void
+
+    #  (String) -> untyped
+    def resolve: (String name) -> untyped
+
+    #  (untyped, Array[untyped]) -> untyped
+    def resolve_path: (untyped obj, untyped segments) -> untyped
+
+    #  (String, untyped) -> void
+    def assign: (String name, untyped value) -> void
+
+    #  (t_namespace, bool?, Set[String]?, Template?) -> RenderContext
+    def copy: (t_namespace namespace, ?block_scope: bool?, ?disabled_tags: Set[String]?, ?template: Template?) -> RenderContext
+
+    #  (t_namespace, ?template: Template?) { () -> untyped } -> void
+    def extends: (t_namespace namespace, ?template: Template?) { () -> untyped } -> void
+                 
+    private
+
+    #  (untyped) -> Integer
+    def assign_score_of: (untyped value) -> Integer
+                       
+    #: () -> void
+    def raise_for_context_depth: () -> void
+                               
+    #  (Array[untyped], untyped) -> untyped
+    def resolve_array_segment: (Array[untyped] obj, untyped segment) -> untyped
+
+    #  (Hash[untyped, untyped], untyped) -> untyped
+    def resolve_hash_segment: (Hash[untyped, untyped] obj, untyped segment) -> untyped
+  end
+end