luoma 0.1.0

data/lib/luoma/context.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require_relative "chain_hash"
+
+module Luoma
+  class RenderContext
+    attr_reader :env, :template, :disabled_tags, :context_depth, :assign_score, :assign_score_cumulative,
+                :registers, :globals, :scopes, :locals
+
+    attr_accessor :render_score, :render_score_cumulative, :interrupts
+
+    #: (Template, ?globals: _Namespace?) -> void
+    def initialize(
+      template,
+      globals: nil,
+      disabled_tags: nil,
+      context_depth: nil,
+      assign_score_carry: nil,
+      render_score_carry: nil
+    )
+      # The template being rendered.
+      @template = template
+
+      # The environment this render context and associated template is
+      # bound to.
+      @env = template.env
+
+      # Developer-defined template variables passed down from the environment
+      # and template.
+      @globals = globals || {} # steep:ignore
+
+      # The namespace for variables defined with `{% assign %}` and
+      # `{% capture %}`.
+      @locals = {} #: t_namespace
+
+      # A namespace for `{% increment %}` and `{% decrement %}`.
+      @counters = {} #: t_namespace
+
+      # 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.new(@counters, @globals, @locals)
+
+      # Names of tags that are disallowed in this context.
+      @disabled_tags = disabled_tags
+
+      # The number of times this render context has been extended or copied.
+      @context_depth = context_depth || 0
+
+      # A non-specific indicator of template local scope usage.
+      @assign_score = 0
+
+      # A non-specific indicator of template local scope usage for the current
+      # template and all partial templates combined.
+      @assign_score_cumulative = assign_score_carry || 0
+
+      # The number of nodes rendered for the current template.
+      @render_score = 0
+
+      # The number of nodes rendered for the current template and all partial
+      # templates.
+      @render_score_cumulative = render_score_carry || 0
+
+      # 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 = {}
+    end
+
+    #: (String) -> untyped
+    def resolve(name)
+      @scopes[name]
+    end
+
+    # Follow path segments starting at `obj`. If the path from `obj` does not
+    # exist, :nothing is returned along with the index of the last segment to
+    # be successfully resolved.
+    #
+    #: (untyped, Array[untyped]) -> [untyped, Integer]
+    def resolve_path(obj, segments)
+      segment_index = -1
+
+      segments.each do |segment|
+        segment_index += 1
+
+        return [segment.call(self, obj), segment_index] if segment.is_a?(PredicateFunction)
+
+        obj = case obj
+              when Drop
+                segment = segment.to_primitive(:string, self) if segment.is_a?(Drop)
+                obj.fetch(segment, self, default: :nothing)
+              when Array
+                segment = segment.to_primitive(:numeric, self) if segment.is_a?(Drop)
+                resolve_array_segment(obj, segment)
+              when Hash
+                segment = segment.to_primitive(:data, self) if segment.is_a?(Drop)
+                resolve_hash_segment(obj, segment)
+              else
+                :nothing
+              end
+
+        return [:nothing, segment_index] if obj == :nothing
+      end
+
+      [obj, segment_index]
+    end
+
+    #: (String, untyped) -> void
+    def assign(name, value)
+      if @env.max_assign_score || @env.max_assign_score_cumulative
+        score = assign_score_of(value)
+        @assign_score += score
+        @assign_score_cumulative += score
+
+        if (@env.max_assign_score && @assign_score > @env.max_assign_score) || # steep:ignore
+           (@env.max_assign_score_cumulative &&
+            @assign_score_cumulative > @env.max_assign_score_cumulative) # steep:ignore
+          raise ResourceLimitError.new("memory limits reached")
+        end
+
+      end
+
+      @locals[name] = value
+    end
+
+    # Return a new render context with render state from this context.
+    #
+    # The caller is responsible for updating renderScoreCumulative when the new
+    # context is no longer needed.
+    #: (t_namespace, bool?, Set[String]?, Template?) -> RenderContext
+    def copy(namespace, block_scope: nil, disabled_tags: nil, template: nil)
+      raise_for_context_depth
+
+      ctx = RenderContext.new(
+        template || @template,
+        globals: block_scope ? ChainHash.new(namespace, @scopes) : ChainHash.new(namespace, @globals),
+        context_depth: @context_depth + 1,
+        assign_score_carry: @assign_score_cumulative,
+        render_score_carry: @render_score_cumulative
+      )
+
+      @env.persistent_registers.each { |r| ctx.registers[r] = @registers[r] if @registers.include?(r) }
+      ctx
+    end
+
+    # Extend the scope of this context with the given namespace for the
+    # duration of a block.
+    #
+    #: (t_namespace, ?template: Template?) { () -> untyped } -> void
+    def extends(namespace, template: nil)
+      raise_for_context_depth
+
+      assign_score_ = @assign_score
+      render_score_ = @render_score
+      template_ = @template
+
+      @template = template if template
+      @scopes << namespace
+      @context_depth += 1
+      @assign_score = 0
+      @render_score = 0
+
+      begin
+        yield
+      ensure
+        @template = template_ if template
+        @scopes.pop
+        @context_depth -= 1
+        @assign_score = assign_score_
+        @render_score = render_score_
+      end
+    end
+
+    private
+
+    #: () -> void
+    def raise_for_context_depth
+      if @context_depth + 1 > @env.max_context_depth
+        raise ContextDepthError.new(
+          "maximum context depth reached, possible recursive render"
+        )
+      end
+    end
+
+    #: (untyped) -> Integer
+    def assign_score_of(value)
+      case value
+      when String
+        value.bytesize
+      when Array
+        value.sum { |i| assign_score_of(i) } + 1
+      when Hash
+        value.reduce(1) { |a, p| a + assign_score_of(p.first) + assign_score_of(p.last) }
+      else
+        1
+      end
+    end
+
+    #: (Array[untyped], untyped) -> untyped
+    def resolve_array_segment(obj, segment)
+      index = if segment.is_a?(Integer)
+                segment.negative? && obj.length >= segment.abs ? obj.length + segment : segment
+              end
+
+      if index && index < obj.length
+        obj[index]
+      else
+        :nothing
+      end
+    end
+
+    #: (Hash[untyped, untyped], untyped) -> untyped
+    def resolve_hash_segment(obj, segment)
+      if obj.key?(segment)
+        obj[segment]
+      else
+        :nothing
+      end
+    end
+  end
+end

data/lib/luoma/drop.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Luoma
+  class Drop
+    include Enumerable
+
+    #: (untyped, RenderContext) -> bool
+    def key?(obj, context)
+      false
+    end
+
+    #: (String, RenderContext) -> untyped
+    def fetch(name, context, default: :nothing)
+      default
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      [].to_enum # steep:ignore
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def eq?(obj, context)
+      false
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def lt?(obj, context)
+      false
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def gt?(obj, context)
+      false
+    end
+
+    #: (obj, RenderContext) -> bool
+    def contains?(obj, context)
+      false
+    end
+
+    # Return the length of this object.
+    # Along with `#slice`,  `#length` is part of the iterator protocol.
+    #: (RenderContext) -> Integer
+    def length(context)
+      0
+    end
+
+    # TODO: pass context
+    #: (Integer, Integer, Integer) -> Enumerable[untyped]
+    def slice(start, stop, step)
+      self
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :data
+        nil
+      when :numeric
+        0
+      when :string
+        ""
+      when :boolean
+        false
+      end
+    end
+
+    #: () -> String
+    def to_s
+      ""
+    end
+
+    #: (RenderContext) -> String?
+    def render(context)
+      nil
+    end
+  end
+end

data/lib/luoma/drops/block.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Luoma
+  class BlockDrop < Drop
+    #: (t_block) -> void
+    def initialize(block)
+      super()
+      @block = block
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :numeric
+        :nothing
+      when :data, :string
+        render(context)
+      when :boolean
+        true
+      end
+    end
+
+    def render(context)
+      buf = +""
+
+      context.extends({}) do # For recursive block detection.
+        Luoma.render_block(@block, context, buf)
+      end
+
+      buf
+    end
+  end
+end

data/lib/luoma/drops/expression.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Luoma
+  class ExpressionDrop < Drop
+    attr_reader :expr
+
+    #: (LambdaExpr) -> void
+    def initialize(expr)
+      super()
+      @expr = expr
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :numeric
+        :nothing
+      when :data, :string
+        render(context)
+      when :boolean
+        true
+      end
+    end
+
+    def render(context)
+      @expr.to_s
+    end
+  end
+end

data/lib/luoma/drops/html_safe.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Luoma
+  class HTMLSafe < Drop
+    #: (String | HTMLSafe) -> HTMLSafe
+    def self.escape(value)
+      value.is_a?(String) ? HTMLSafe.new(Luoma.escape(value)) : value
+    end
+
+    #: (String | HTMLSafe) -> HTMLSafe
+    def self.from(value)
+      value.is_a?(String) ? HTMLSafe.new(value) : value
+    end
+
+    #: (String) -> void
+    def initialize(s)
+      super()
+      @s = s
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :string, :data
+        @s
+      else
+        :nothing
+      end
+    end
+
+    #: (RenderContext) -> String?
+    def render(context)
+      @s
+    end
+  end
+end

data/lib/luoma/drops/range.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Luoma
+  class RangeDrop < Drop
+    attr_reader :start, :stop
+
+    def initialize(start, stop)
+      super()
+      @start = start
+      @stop = stop
+      @range = (start..stop)
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def key?(obj, context)
+      obj == "first" || obj == "last" || obj == "size"
+    end
+
+    #: (String, RenderContext) -> untyped
+    def fetch(name, context, default: :nothing)
+      case name
+      when "first"
+        @start
+      when "last"
+        @stop
+      when "size"
+        @range.size
+      else
+        default
+      end
+    end
+
+    def to_a
+      @range.to_a
+    end
+
+    def each(&)
+      @range.each
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def eq?(obj, context)
+      obj.is_a?(RangeDrop) && obj.start == obj.stop
+    end
+
+    #: (RenderContext) -> Integer
+    def length(context) # steep:ignore
+      @range.size
+    end
+
+    def slice(start, stop, step)
+      @range.to_a[(start...stop).step(step)] # steep:ignore
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :data
+        @range.to_a
+      when :numeric
+        :nothing
+      when :string
+        JSON.generate(@range.to_a)
+      when :boolean
+        false
+      end
+    end
+  end
+end

data/lib/luoma/drops/undefined.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Luoma
+  attr_reader :path
+
+  # The default and base "undefined" type.
+  class UndefinedDrop < Drop
+    #: (String, t_token, String, String) -> void
+    def initialize(path, token, source, template_name)
+      super()
+      @path = path
+      @token = token
+      @source = source
+      @template_name = template_name
+    end
+
+    #: (String, RenderContext) -> untyped
+    def fetch(name, context, default: :nothing)
+      self
+    end
+
+    #: (untyped, RenderContext) -> bool
+    def eq?(obj, context)
+      obj.is_a?(UndefinedDrop)
+    end
+
+    #: (:data | :numeric | :string | :boolean, RenderContext) -> untyped
+    def to_primitive(hint, context)
+      case hint
+      when :data
+        nil
+      when :numeric
+        :nothing
+      when :string
+        ""
+      when :boolean
+        false
+      end
+    end
+  end
+
+  # An "undefined" type that raises `UndefinedVariableError` in all contexts.
+  class StrictUndefinedDrop < UndefinedDrop
+    def key?(obj, context)
+      error
+    end
+
+    def fetch(name, context, default: :nothing)
+      error
+    end
+
+    def each(&)
+      error
+    end
+
+    def eq?(obj, context)
+      error
+    end
+
+    def lt?(obj, context)
+      error
+    end
+
+    def gt?(obj, context)
+      error
+    end
+
+    def contains?(obj, context)
+      error
+    end
+
+    def length(context)
+      error
+    end
+
+    def slice(start, stop, step)
+      error
+    end
+
+    def to_primitive(hint, context)
+      error
+    end
+
+    def to_s
+      error
+    end
+
+    def render(context)
+      error
+    end
+
+    protected
+
+    def error
+      raise UndefinedVariableError.new(
+        "#{@path.inspect} is undefined",
+        @token,
+        @source,
+        @template_name
+      )
+    end
+  end
+
+  # An "undefined" type that can be tested for truthiness and compared to
+  # other objects without raising an error.
+  class FalsyStrictUndefinedDrop < StrictUndefinedDrop
+    def eq?(obj, context)
+      context.env.nothing?(obj)
+    end
+
+    def to_primitive(hint, context)
+      hint == :boolean ? false : error
+    end
+
+    def key?(obj, context)
+      false
+    end
+  end
+end