luoma 0.1.0

data/sig/luoma/parser_unified.rbs

@@ -0,0 +1,150 @@
+module Luoma
+  class UnifiedParser < Parser
+    class Precedence
+      LOWEST: Integer
+
+      COALESCE: Integer
+
+      LOGICAL_OR: Integer
+
+      LOGICAL_AND: Integer
+
+      LOGICAL_NOT: Integer
+
+      COMPARISON: Integer
+
+      MEMBERSHIP: Integer
+
+      PIPE: Integer
+
+      FILTER_ARG: Integer
+
+      ADD: Integer
+
+      MUL: Integer
+
+      NEG: Integer
+
+    end
+
+    PRECEDENCES: Hash[t_token_kind, Integer]
+
+    INFIX_OPERATORS: Hash[t_token_kind, untyped]
+
+    TERMINATE_EXPRESSION: Set[t_token_kind]
+
+    TERMINATE_FILTER: Set[t_token_kind]
+
+    PATH_PUNCTUATION: Set[t_token_kind]
+
+    STRING_LITERAL_KINDS: Set[t_token_kind]
+
+    PATH_SEGMENT_KINDS: Set[t_token_kind]
+    
+    KEYWORD_ARGUMENT_DELIMITERS: Set[t_token_kind]
+
+    RE_SLASH_U: ::Regexp
+
+    RE_ESCAPE_INTERPOLATION: ::Regexp
+
+    #  (?require_commas: bool?) -> Array[Expression | KeywordArgument]
+    def parse_arguments: (?require_commas: bool?) -> Array[Expression | KeywordArgument]
+
+    #  (?stop: Set[String]?) -> t_block
+    def parse_block: (?stop: Set[String]?) -> t_block
+
+    #  () -> Name
+    def parse_ident: () -> Name
+
+    #  (?require_commas: bool?) -> Array[KeywordArgument]
+    def parse_keyword_arguments: (?require_commas: bool?) -> Array[KeywordArgument]
+
+    # Parse an identifier, possibly surrounded by quotes.
+    #  () -> Name
+    def parse_name: () -> Name
+
+    #  (?require_commas: bool?) -> Array[Expression]
+    def parse_positional_arguments: (?require_commas: untyped?) -> Array[Expression]
+
+    #  () -> StringLiteral
+    def parse_string_literal: () -> StringLiteral
+
+    #  (?precedence: Integer) -> Expression
+    def parse_primary: (?precedence: Integer) -> Expression
+
+    #  (Expression) -> Expression
+    def parse_ternary: (Expression consequence) -> Expression
+
+    #  () -> Expression
+    def parse_array_or_path: () -> Expression
+
+    #  (t_token, Expression|Spread) -> Expression
+    def parse_partial_array: (t_token token, (Expression|Spread) first) -> Expression
+
+    #  () -> ObjectLiteral
+    def parse_object_literal: () -> ObjectLiteral
+
+    #  () -> Item | Spread
+    def parse_object_item: () -> (Item | Spread)
+
+    #  (precedence: Integer) -> Expression
+    def parse_lambda_range_or_group: (precedence: Integer) -> Expression
+
+    #  (Expression, precedence: Integer) -> Lambda
+    def parse_partial_lambda: (Expression expr, precedence: Integer) -> Expression
+
+    #  () -> Expression
+    def parse_prefix: () -> Expression
+
+    #  () -> Markup
+    def parse_output: () -> Markup
+
+    #  () -> Markup
+    def parse_comment: () -> Markup
+
+    #  () -> Markup
+    def parse_tag: () -> Markup
+
+    #  () -> Variable
+    def parse_path: () -> Variable
+
+    #  () -> Array[t_path_segment]
+    def parse_path_segments: () -> Array[t_path_segment]
+
+    #  () -> t_path_segment
+    def parse_bracketed_segment: () -> t_path_segment
+
+    #  () -> Expression
+    def parse_range_literal: () -> Expression
+
+    #  () -> Expression
+    def parse_true_literal: () -> Expression
+
+    #  () -> Expression
+    def parse_false_literal: () -> Expression
+
+    #  () -> Expression
+    def parse_null_literal: () -> Expression
+
+    #  () -> Expression
+    def parse_int_literal: () -> Expression
+
+    #  () -> Expression
+    def parse_float_literal: () -> Expression
+
+    #  (t_token, Expression) -> FilteredExpression
+    def parse_filter: (t_token token, Expression left) -> FilteredExpression
+                    
+    #  (precedence: Integer) -> Lambda
+    def parse_lambda: (precedence: Integer) -> Lambda
+
+    #  (Expression) -> Expression
+    def parse_infix: (Expression left) -> Expression
+                   
+    def unescape: (t_token token) -> String
+
+    def high_surrogate?: (Integer code_point) -> bool
+
+    def low_surrogate?: (Integer code_point) -> bool
+  end
+end

data/sig/luoma/predicates/blank.rbs

@@ -0,0 +1,6 @@
+module Luoma
+  module Predicates
+    #  (RenderContext, untyped) -> bool
+    def self.blank?: (RenderContext context, untyped value) -> bool
+  end
+end

data/sig/luoma/predicates/defined.rbs

@@ -0,0 +1,6 @@
+module Luoma
+  module Predicates
+    #  (RenderContext, untyped) -> bool
+    def self.defined?: (RenderContext context, untyped value) -> bool
+  end
+end

data/sig/luoma/predicates/empty.rbs

@@ -0,0 +1,6 @@
+module Luoma
+  module Predicates
+    #  (RenderContext, untyped) -> bool
+    def self.empty?: (RenderContext context, untyped obj) -> bool
+  end
+end

data/sig/luoma/predicates/type.rbs

@@ -0,0 +1,21 @@
+module Luoma
+  module Predicates
+    #  (RenderContext, untyped) -> bool
+    def self.null?: (RenderContext context, untyped obj) -> bool
+
+    #  (RenderContext, untyped) -> bool
+    def self.string?: (RenderContext context, untyped obj) -> bool
+
+    #  (RenderContext, untyped) -> bool
+    def self.number?: (RenderContext context, untyped obj) -> bool
+
+    #  (RenderContext, untyped) -> bool
+    def self.array?: (RenderContext context, untyped obj) -> bool
+
+    #  (RenderContext, untyped) -> bool
+    def self.object?: (RenderContext context, untyped obj) -> bool
+                    
+    #  (RenderContext, untyped) -> bool
+    def self.numeric?: (RenderContext context, untyped obj) -> bool
+  end
+end

data/sig/luoma/static_analysis.rbs

@@ -0,0 +1,141 @@
+module Luoma
+  # Template static analysis.
+  module StaticAnalysis
+    # The location of a variable, tag or filter.
+    class Location
+      @template: Luoma::Template
+
+      @token: Luoma::t_token
+
+      attr_reader template: Luoma::Template
+
+      attr_reader token: Luoma::t_token
+
+      #  (Template, t_token) -> void
+      def initialize: (Luoma::Template template, Luoma::t_token token) -> void
+
+      # Return the line and column number of the given index.
+      #
+      #  (Integer) -> [Integer, Integer]
+      def line_col: (Numeric index) -> [Numeric, Numeric]
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> untyped
+
+      # Return the line and column number for the start and end index spanning
+      # this location.
+      #
+      #  () -> [[Integer, Integer],[Integer, Integer]]
+      def span: () -> [[Numeric, Numeric],[Numeric, Numeric]]
+
+      # Return the substring spanning this location.
+      #
+      #  () -> String
+      def value: () -> String
+    end
+
+    # A variable as a sequence of segments and its location.
+    class StaticVariable
+      @segments: untyped
+
+      @location: Location
+
+      attr_reader segments: untyped
+
+      attr_reader location: Location
+
+      RE_PROPERTY: ::Regexp
+
+      def initialize: (untyped segments, Location location) -> void
+
+      def to_s: () -> String
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> untyped
+
+      #  () -> String
+      def root: () -> String
+
+      def segments_to_s: (untyped segments) -> String
+    end
+
+    # Helper to manage variable scope during static analysis.
+    class StaticScope
+      @stack: Array[Set[String]]
+
+      #  (Set[String]) -> void
+      def initialize: (Set[String] globals) -> void
+
+      def include?: (String key) -> bool
+
+      def push: (Set[String] scope) -> self
+
+      def pop: () -> untyped
+
+      def add: (String name) -> void
+    end
+
+    # Helper to group variables by their root segment during static analysis.
+    class VariableMap
+      @data: Hash[String, Array[StaticVariable]]
+
+      attr_reader data: Hash[String, Array[StaticVariable]]
+
+      def initialize: () -> void
+
+      def []: (StaticVariable var) -> Array[StaticVariable]?
+
+      def add: (StaticVariable var) -> void
+
+      #  () -> Hash[String, Array[_Var]]
+      def to_h: () -> untyped
+    end
+
+    # The result of analyzing a template.
+    class Result
+      @variables: untyped
+
+      @globals: untyped
+
+      @locals: untyped
+
+      @filters: untyped
+
+      @tags: untyped
+
+      attr_reader variables: untyped
+
+      attr_reader globals: untyped
+
+      attr_reader locals: untyped
+
+      attr_reader filters: untyped
+
+      attr_reader tags: untyped
+
+      def initialize: (untyped variables, untyped globals, untyped locals, untyped filters, untyped tags) -> void
+                    
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    def self.analyze: (Luoma::Template template, include_partials: bool) -> Result
+
+    #  (Luoma::_Traversable, Luoma::Template, Luoma::RenderContext) -> Array[[String, Location]]
+    def self.extract_filters: (Luoma::_Traversable expression, Luoma::Template template, Luoma::RenderContext static_context) -> Array[[String, Location]]
+
+    # (Luoma:_Traversable, Luoma::Template, StaticScope, VariableMap, VariableMap, RenderContext) -> void
+    def self.analyze_variables: (Luoma::_Traversable expression, Luoma::Template template, StaticScope scope, VariableMap globals, VariableMap variables, Luoma::RenderContext static_context) -> untyped
+
+    #  (Luoma::Variable, Luoma::Template) -> Array[untyped]
+    def self.segments: (Luoma::Variable var, Luoma::Template template) -> Array[untyped]
+
+    #  (Hash[String, Array[Location]]) -> Hash[String, Array[untyped]]
+    def self.to_locations: (untyped map) -> untyped
+  end
+end

data/sig/luoma/tags/assign.rbs

@@ -0,0 +1,12 @@
+module Luoma
+  class AssignTag < Markup
+
+    @bindings: Array[Item]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, Array[Item]) -> void
+    def initialize: (t_token token, String tag_name, Array[Item]) -> void
+  end
+end

data/sig/luoma/tags/break.rbs

@@ -0,0 +1,11 @@
+module Luoma
+  class BreakTag < Markup
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    def initialize: (t_token token, String tag_name) -> void
+
+    #  (RenderContext, String) -> void
+    def render: (RenderContext context, String buffer) -> void
+  end
+end

data/sig/luoma/tags/capture.rbs

@@ -0,0 +1,14 @@
+module Luoma
+  class CaptureTag < Markup
+    @identifier: Name
+
+    @block: t_block
+
+    END_CAPTURE_BLOCK: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    def initialize: (t_token token, String tag_name, Name identifier, t_block block) -> void
+  end
+end

data/sig/luoma/tags/case.rbs

@@ -0,0 +1,36 @@
+module Luoma
+  class CaseTag < Markup
+    @expression: Expression
+
+    @blocks: Array[WhenBlock|ElseBlock]
+
+    END_CASE_BLOCK: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, Expression, Array[WhenBlock], ElseBlock?) -> void
+    def initialize: (t_token token, String tag_name, Expression expression, Array[WhenBlock|ElseBlock] blocks) -> void
+  end
+
+  class WhenBlock < Markup
+    @right: Array[Expression]
+
+    @block: t_block
+
+    END_CASE_BLOCK: Set[String]
+
+    attr_reader block: t_block
+
+    attr_reader right: Array[Expression]
+
+    #  (String, Parser) -> WhenBlock
+    def self.parse: (String tag_name, Parser parser) -> WhenBlock
+
+    #  (t_token, String, Array[Expression], t_block) -> void
+    def initialize: (t_token token, String tag_name, Array[Expression] right, t_block block) -> void
+
+    #: () -> void
+    def filter_strings: () -> void
+  end
+end

data/sig/luoma/tags/comment.rbs

@@ -0,0 +1,11 @@
+module Luoma
+  class Comment < Markup
+    @text: String
+
+    attr_reader text: String
+
+    #  (t_token, String) -> void
+    def initialize: (t_token token, String text) -> void
+
+  end
+end

data/sig/luoma/tags/continue.rbs

@@ -0,0 +1,11 @@
+module Luoma
+  class ContinueTag < Markup
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    def initialize: (t_token token, String tag_name) -> void
+
+    #  (RenderContext, String) -> void
+    def render: (RenderContext context, String buffer) -> void
+  end
+end

data/sig/luoma/tags/define.rbs

@@ -0,0 +1,16 @@
+module Luoma
+  class DefineTag < Markup
+    @identifier: Name
+
+    @block: t_block
+
+    @drop: BlockDrop
+
+    END_DEFINE_BLOCK: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    def initialize: (t_token token, String tag_name, Name identifier, t_block block) -> void
+  end
+end

data/sig/luoma/tags/else.rbs

@@ -0,0 +1,17 @@
+module Luoma
+  class ElseBlock < Markup
+    @expression: Expression
+
+    @block: t_block
+
+    attr_reader expression: Expression
+
+    attr_reader block: t_block
+
+    #  (t_token, String, t_block) -> void
+    def initialize: (t_token token, String tag_name, t_block block) -> void
+
+
+    def filter_strings: () -> untyped
+  end
+end

data/sig/luoma/tags/for.rbs

@@ -0,0 +1,26 @@
+module Luoma
+  class ForTag < Markup
+    @params: Array[Name]
+
+    @expression: Expression
+
+    @block: t_block
+
+    @default: t_block?
+
+    END_FOR_BLOCK: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #: (t_token, String, Array[Name], Expression, t_block, t_block?) -> void
+    def initialize: (
+      t_token token, 
+      String tag_name, 
+      Array[Name] params, 
+      Expression expression, 
+      t_block block, 
+      t_block? default, 
+      ) -> void
+  end
+end

data/sig/luoma/tags/if.rbs

@@ -0,0 +1,45 @@
+module Luoma
+  class IfTag < Markup
+    @alts: Array[IfBlock | ElseBlock]
+
+    END_IF_BLOCK: Set[String]
+
+    ELSE_IF_TAGS: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    def initialize: (t_token token, String tag_name, Array[IfBlock | ElseBlock] alts) -> void
+
+    #  (RenderContext, String) -> void
+    def render: (RenderContext context, String buffer) -> void
+
+    #  (RenderContext) -> Array[Markup]
+    def children: (RenderContext static_context) -> Array[Markup]
+  end
+
+  class IfBlock < Markup
+    @expression: Expression
+
+    @block: t_block
+
+    END_IF_BLOCK: Set[String]
+
+    attr_reader expression: Expression
+
+    attr_reader block: t_block
+
+    #  (Parser) -> Markup
+    def self.parse: (String tag_name, Parser parser) -> IfBlock
+
+    def initialize: (t_token token, String tag_name, Expression expression, t_block block) -> void
+
+    #  (RenderContext) -> Array[Markup]
+    def children: (RenderContext static_context) -> Array[Markup]
+
+    #  () -> Array[Expression]
+    def expressions: () -> ::Array[Expression]
+
+    def filter_strings: () -> void
+  end
+end

data/sig/luoma/tags/import.rbs

@@ -0,0 +1,13 @@
+module Luoma
+  class ImportTag < Markup
+    @template_name: Name
+
+    @namespace: Name?
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, Name?) -> void
+    def initialize: (t_token token, String tag_name, Name template_name, Name? namespace) -> void
+  end
+end

data/sig/luoma/tags/include.rbs

@@ -0,0 +1,13 @@
+module Luoma
+  class IncludeTag < Markup
+    @template_name: Expression
+
+    @args: Array[KeywordArgument]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, Expression, Array[KeywordArgument]) -> void
+    def initialize: (t_token token, String tag_name, Expression template_name, Array[KeywordArgument] args) -> void
+  end
+end

data/sig/luoma/tags/output.rbs

@@ -0,0 +1,13 @@
+module Luoma
+  class OutputStatement < Markup
+    @expression: Expression
+
+    def initialize: (t_token token, Expression expression) -> void
+
+    #  (RenderContext, String) -> void
+    def render: (RenderContext context, String buffer) -> void
+
+    #  () -> Array[Expression]
+    def expressions: () -> ::Array[Expression]
+  end
+end

data/sig/luoma/tags/raw.rbs

@@ -0,0 +1,11 @@
+module Luoma
+  class RawTag < Markup
+    @text: String
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, String) -> void
+    def initialize: (t_token token, String tag_name, String text) -> void
+  end
+end

data/sig/luoma/tags/render.rbs

@@ -0,0 +1,13 @@
+module Luoma
+  class RenderTag < Markup
+    @template_name: Name
+
+    @args: Array[KeywordArgument]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, Name, Array[KeywordArgument]) -> void
+    def initialize: (t_token token, String tag_name, Name template_name, Array[KeywordArgument] args) -> void
+  end
+end

data/sig/luoma/tags/with.rbs

@@ -0,0 +1,15 @@
+module Luoma
+  class WithTag < Markup
+    @args: Array[KeywordArgument]
+    
+    @block: t_block
+
+    END_WITH_BLOCK: Set[String]
+
+    #  (t_token, String, Parser) -> Markup
+    def self.parse: (t_token token, String tag_name, Parser parser) -> Markup
+
+    #  (t_token, String, Array[KeywordArgument], t_block) -> void
+    def initialize: (t_token token, String tag_name, Array[KeywordArgument] args, t_block block) -> void
+  end
+end