luoma 0.1.0

data/sig/luoma/expression.rbs

@@ -0,0 +1,514 @@
+module Luoma
+  type t_path_segment = Name | StringLiteral | IndexSelector | Variable | Predicate
+
+  interface _Traversable
+    def children: () -> Array[_Traversable]
+    def to_s: () -> String
+    def class: () -> untyped
+  end
+
+  class Expression
+    @token: t_token
+
+    @span: t_token
+
+    attr_reader token: t_token
+
+    attr_reader span: t_token
+
+    #  (t_token) -> void
+    def initialize: (t_token token) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> Array[_Traversable]
+                
+    #  () -> Array[Name]
+    def scope: () -> Array[Name]
+                
+    def to_s: () -> String
+  end
+
+  class GroupExpression < Expression
+    @expr: Expression
+
+    @segments: Array[t_path_segment]
+
+    #  (t_token, Expression, Array[t_path_segment]) -> void
+    def initialize: (t_token token, Expression expr, Array[t_path_segment] segments) -> void
+
+    #  (t_token) -> self
+    def with: (t_token token) -> self
+            
+    #  (Array[t_path_segment]) -> String
+    def path: (Array[t_path_segment]) -> String
+  end
+
+  class TernaryExpression < Expression
+    @consequence: Expression
+
+    @condition: Expression
+
+    @alternative: Expression?
+
+    #  (t_token, Expression, Expression, Expression?) -> void
+    def initialize: (t_token token, Expression consequence, Expression condition, Expression? alternative) -> void
+  end
+
+  class FilteredExpression < Expression
+    @left: Expression
+
+    @filter: Filter
+
+    @name: String?
+
+    @span: t_token
+
+    def initialize: (t_token token, Expression left, Filter filter) -> void
+                  
+    def evaluate_lambda: (LambdaExpr expr, RenderContext context) -> untyped
+                       
+    def evaluate_filter: (String name, RenderContext context) -> untyped
+                       
+    def normalize_arguments: (RenderContext context, ::Method method, Array[untyped] args, Hash[Symbol, untyped] kwargs) -> [Array[untyped], Hash[Symbol, untyped]]
+
+    def validate_arguments: (
+      RenderContext context, 
+      ::Method method, 
+      Array[untyped] args, 
+      Hash[Symbol, untyped] kwargs,
+      required_positional: untyped, 
+      optional_positional: untyped, 
+      has_rest: untyped, 
+      required_keys: untyped, 
+      optional_keys: untyped, 
+      has_keyrest: untyped
+    ) -> void
+  end
+
+  class PrefixExpression < Expression
+    @right: Expression
+
+    #  (t_token, Expression) -> void
+    def initialize: (t_token token, Expression right) -> void
+  end
+
+  class NotExpression < PrefixExpression
+  end
+
+  class PosExpression < PrefixExpression
+  end
+
+  class NegExpression < PrefixExpression
+  end
+
+  class InfixExpression < Expression
+    @left: untyped
+
+    @right: untyped
+
+    @span: untyped
+
+    #  (t_token, Expression, Expression) -> void
+    def initialize: (t_token token, Expression left, Expression right) -> void
+  end
+
+  class CoalesceExpression < InfixExpression
+  end
+
+  class OrExpression < InfixExpression
+  end
+
+  class AndExpression < InfixExpression
+  end
+
+  class EqExpression < InfixExpression
+  end
+
+  class NeExpression < InfixExpression
+  end
+
+  class LtExpression < InfixExpression
+  end
+
+  class LeExpression < InfixExpression
+  end
+
+  class GtExpression < InfixExpression
+  end
+
+  class GeExpression < InfixExpression
+  end
+
+  class ContainsExpression < InfixExpression
+  end
+
+  class InExpression < InfixExpression
+  end
+
+  class AddExpression < InfixExpression
+  end
+
+  class SubExpression < InfixExpression
+  end
+
+  class MulExpression < InfixExpression
+  end
+
+  class DivExpression < InfixExpression
+  end
+
+  class ModExpression < InfixExpression
+  end
+
+  class Variable < Expression
+    @root: Name | StringLiteral | Variable
+
+    @segments: Array[t_path_segment]
+
+    @span: t_token
+
+    attr_reader root: Name | StringLiteral | Variable
+
+    attr_reader segments: Array[t_path_segment]
+
+    #  (t_token, Name | StringLiteral | Variable, Array[PathSegment])
+    def initialize: (t_token token, Name | StringLiteral | Variable, Array[t_path_segment]) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> String
+    def to_s: () -> String
+            
+    
+    def ident?: (String name) -> bool
+
+    private
+
+    #  (Array[PathSegment]) -> String
+    def path: (Array[t_path_segment] segments) -> String
+  end
+
+  class IndexSelector < Expression
+    @value: Integer
+
+    attr_reader value: Integer
+
+    #  (t_token, Integer)
+    def initialize: (t_token token, Integer value) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[Luoma::_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+
+    def with: (t_token token) -> self
+  end
+
+  class Lambda < Expression
+    @params: Array[Name]
+
+    @expr: Expression
+
+    #  (t_token, Array[Name], Expression) -> void
+    def initialize: (t_token token, Array[Name] params, Expression expr) -> void
+  end
+
+  class StringLiteral < Expression
+    @segments: Array[String|Expression]
+
+    attr_reader segments: Array[String|Expression]
+
+    #  (t_token, Array[String|Expression], t_token)
+    def initialize: (t_token token, Array[String|Expression] segments, t_token end_token) -> void
+
+    def with: (t_token token) -> self
+            
+    #  () -> String?
+    def value: () -> String?
+  end
+
+  class IntegerLiteral < Expression
+    @value: Integer
+
+    attr_reader value: Integer
+
+    #  (t_token, Integer)
+    def initialize: (t_token token, Integer value) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+  end
+
+  class FloatLiteral < Expression
+    @value: Float
+
+    attr_reader value: Float
+
+    #  (t_token, Float)
+    def initialize: (t_token token, Float value) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+  end
+
+  class BooleanLiteral < Expression
+    @value: bool
+
+    attr_reader value: bool
+
+    #  (t_token, bool)
+    def initialize: (t_token token, bool value) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+  end
+
+  class NullLiteral < Expression
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+  end
+
+  class RangeLiteral < Expression
+    @start: Expression
+
+    @stop: Expression
+
+    #  (t_token, Expression, Expression) -> void
+    def initialize: (t_token token, Expression start, Expression stop) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> ::String
+  end
+
+  class ArrayLiteral < Expression
+    @items: Array[Expression|Spread]
+
+    def initialize: (t_token token, Array[Expression|Spread] items) -> void
+
+    def with: (t_token token) -> self
+  end
+
+  class ObjectLiteral < Expression
+    @items: Array[Item|Spread]
+
+    #   (t_token token, Array[Item|Spread] items) -> void
+    def initialize: (t_token token, Array[Item|Spread] items) -> void
+
+    def with: (untyped token) -> self
+  end
+
+  class Predicate < Expression
+    @value: String
+
+    attr_reader value: String
+
+    #   (t_token, String) -> void
+    def initialize: (t_token token, String value) -> void
+  end
+
+  class Spread
+    @token: t_token
+
+    @expr: Expression
+
+    attr_reader token: t_token
+
+    attr_reader expr: Expression
+
+    def initialize: (t_token token, Expression expr) -> void
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> ::String
+  end
+
+  class Item
+    @token: t_token
+
+    @key: Name
+
+    @expr: Expression
+
+    attr_reader token: t_token
+
+    attr_reader key: Name
+
+    attr_reader expr: Expression
+
+    #  (t_token, Name, Expression) -> void
+    def initialize: (t_token token, Name key, Expression expr) -> void
+
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> ::String
+  end
+
+  class Name
+    @token: t_token
+
+    @value: String
+
+    @span: t_token
+
+    attr_reader token: t_token
+
+    attr_reader span: t_token
+
+    attr_reader value: String
+
+    #  (t_token, String) -> void
+    def initialize: (t_token token, String value) -> void
+
+    #  (RenderContext) -> untyped
+    def evaluate: (RenderContext context) -> untyped
+                
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[Luoma::_Traversable]
+
+    #  () -> String
+    def to_s: () -> String
+  end
+
+  class Filter
+    @token: t_token
+
+    @name: Variable
+
+    @args: Array[Expression]
+
+    @kwargs: Array[KeywordArgument]
+
+    @span: t_token
+
+    attr_reader token: t_token
+
+    attr_reader span: t_token
+
+    attr_reader name: Variable
+
+    attr_reader kwargs: Array[KeywordArgument]
+
+    attr_reader args: Array[Expression]
+
+    #  (t_token, Name, Array[Expression | KeywordArgument])
+    def initialize: (t_token token, Variable name, Array[Expression] args, Array[KeywordArgument] kwargs) -> void
+
+    def children: () -> Array[Luoma::_Traversable]
+
+    def to_s: () -> (::String)
+  end
+
+  class KeywordArgument
+    @token: t_token
+
+    @name: Name
+
+    @expression: Expression
+
+    @span: t_token
+
+    attr_reader token: t_token
+
+    attr_reader span: t_token
+
+    attr_reader name: Name
+
+    attr_reader expression: Expression
+
+    #  (t_token, Name, Expression) -> void
+    def initialize: (t_token token, Name name, Expression expression) -> void
+                  
+    #  () -> Array[_Traversable]
+    def children: () -> ::Array[_Traversable]
+
+    #  () -> String
+    def to_s: () -> ::String
+            
+    def deconstruct: () -> ::Array[untyped]
+
+    def deconstruct_keys: (untyped keys) -> { name: untyped, expression: untyped }
+  end
+
+  class PredicateFunction
+    @name: String
+
+    @func: untyped
+
+    attr_reader name: String
+
+    attr_reader func: untyped
+
+    #  (String, untyped) -> void
+    def initialize: (String name, untyped func) -> void
+
+    #  (RenderContext, untyped) -> bool
+    def call: (RenderContext context, untyped obj) -> bool
+  end
+
+  class LambdaExpr
+    @params: Array[String]
+
+    @expr: Expression
+
+    @context: RenderContext
+
+    attr_reader params: Array[String]
+
+    #  (Array[String], Expression, RenderContext) -> void
+    def initialize: (Array[String] params, Expression expr, RenderContext context) -> void
+
+    #  (Array[Untyped]) -> untyped
+    def call: (Array[untyped] args) -> untyped
+
+    #  (Enumerable[untyped]) -> Array[untyped]
+    def broadcast_with_index: (Enumerable[untyped] enum) -> Array[untyped]
+
+    #  (untyped, Integer) -> untyped
+    def call_with_index: (untyped value, Integer index) -> untyped
+  end
+
+  #  (Expression) -> String
+  def self.tree_view: (Expression) -> String
+end

data/sig/luoma/filter.rbs

@@ -0,0 +1,66 @@
+module Luoma
+  class FilterContext
+    @token: t_token
+
+    @render_context: RenderContext
+
+    @env: Environment
+
+    attr_reader token: t_token
+
+    attr_reader render_context: RenderContext
+
+    attr_reader env: Environment
+
+    #  (t_token, RenderContext)
+    def initialize: (t_token token, RenderContext render_context) -> void
+                  
+    # (String) -> TemplateTypeError
+    def type_error: (String message) -> TemplateTypeError
+                  
+    # (String) -> FilterArgumentError
+    def argument_error: (String message) -> FilterArgumentError
+                  
+    #  (untyped) -> Array[untyped]
+    def to_a: (untyped obj) -> Array[untyped]
+            
+    #  (untyped) -> Hash[untyped, untyped]
+    def to_h: (untyped obj) -> Hash[untyped, untyped]
+
+    # [X] (untyped, ?default: X) -> (Integer | X)
+    def to_i: [X] (untyped obj, ?default: X) -> (Integer | X)
+
+    #  (untyped) -> String
+    def to_string: (untyped obj) -> String
+
+    #  [X] (untyped, ?default: X) -> (Numeric | X)
+    def to_numeric: [X] (untyped obj, ?default: X) -> (Numeric | X)
+
+    #  (untyped) -> Enumerable[untyped]
+    def to_enumerable: (untyped obj) -> Enumerable[untyped]
+                     
+    #  (untyped) -> untyped
+    def to_date: (untyped obj) -> untyped
+               
+    #  (untyped) -> bool
+    def nothing?: (untyped obj) -> bool
+                
+    #  (untyped) -> bool
+    def truthy?: (untyped obj) -> untyped
+                
+    #  (untyped, untyped) -> bool
+    def eq?: (untyped obj, untyped other) -> untyped
+                
+    #  (untyped, untyped) -> bool
+    def lt?: (untyped obj, untyped other) -> untyped
+           
+    #  (untyped, untyped) -> (-1 | 1 | 0 | nil)
+    def cmp: (untyped left, untyped right) -> (-1 | 1 | 0 | nil)
+               
+    #  (untyped) -> bool
+    def empty?: (untyped obj) -> bool
+               
+    #  (untyped, untyped, ?default: untyped?) -> untyped
+    def fetch: (untyped obj, untyped key, ?default: untyped) -> untyped
+  end
+end

data/sig/luoma/filters/array.rbs

@@ -0,0 +1,74 @@
+module Luoma
+  module Filters
+    # Return the concatenation of items in _left_ separated by _sep_.
+    # Coerce items in _left_ to strings if they aren't strings already.
+    def self.join: (FilterContext context, untyped left, ?::String sep) -> untyped
+
+    # If _left_ is enumerable, return _left_ flattened to _depth_. Otherwise
+    # return _left_.
+    def self.flatten: (FilterContext context, untyped left, ?untyped? depth) -> untyped
+                    
+    # Return _true_ if at least one item in _left_ is truthy.
+    def self.any: (FilterContext context, untyped left, ?untyped key, ?untyped value) -> untyped
+                
+    # Return true if all items in _left_ are truthy.
+    def self.all: (FilterContext context, untyped left, ?untyped key, ?untyped value) -> untyped
+
+    # Return a copy of _left_ with nil items removed.
+    # Coerce _left_ to an array-like object if it is not one already.
+    #
+    # If _key_ is given, assume items in _left_ are hash-like and remove items from _left_
+    # where `item.fetch(key, nil)` is nil.
+    #
+    # If key is not `:nothing`, coerce it to a string before calling `fetch` on items in
+    # _left_.
+    def self.compact: (FilterContext context, untyped left, ?untyped key) -> untyped
+
+    # Return _left_ concatenated with _right_, or nil if _right_ is not an array.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.concat: (FilterContext context, untyped left, untyped right) -> untyped
+
+    def self.find: (FilterContext context, untyped left, untyped key, ?untyped? value) -> (untyped | nil)
+
+    def self.find_index: (FilterContext context, untyped left, untyped key, ?untyped? value) -> (untyped | nil)
+
+    def self.has: (FilterContext context, untyped left, untyped key, ?untyped? value) -> (true | false)
+
+    # Return the first item in _left_, or `nil` if _left_ does not have a first item.
+    def self.first: (FilterContext context, untyped left) -> untyped
+
+    # Return the last item in _left_, or `nil` if _left_ does not have a last item.
+    def self.last: (FilterContext context, untyped left) -> untyped
+
+    def self.map: (FilterContext context, untyped left, untyped key) -> untyped
+                
+    def self.flat_map: (FilterContext context, untyped left, untyped key) -> untyped
+
+    # Return _left_ with all items in reverse order.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.reverse: (FilterContext context, untyped left) -> untyped
+
+    def self.reject: (FilterContext context, untyped left, untyped key, ?untyped? value) -> untyped
+
+    def self.where: (FilterContext context, untyped left, untyped key, ?untyped? value) -> untyped
+
+    # Deduplicate items in _left_.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.uniq: (FilterContext context, untyped left, ?untyped? key) -> untyped
+                 
+    # Return the sum of all numeric values in the input array.
+    def self.sum: (FilterContext context, untyped left, ?untyped? key) -> untyped
+
+    # Combine _left_ with _right_, producing an array or pairs.
+    # Coerce _left_ and _right_ to arrays if they aren't arrays already.
+    def self.zip: (FilterContext context, untyped left, untyped right) -> untyped
+                
+    # Return the minimum numeric value found in _left_.
+    # Coerce _left_ to an array if it's not an array already.
+    def self.min: (FilterContext context, untyped left, ?untyped key) -> untyped
+
+    # Return the maximum numeric value found in _left_.
+    # Coerce _left_ to an array if it's not an array already.
+    def self.max: (FilterContext context, untyped left, ?untyped key) -> untyped
+  end
+end

data/sig/luoma/filters/date.rbs

@@ -0,0 +1,9 @@
+module Luoma
+  
+  module Filters
+    # Format date and time object _left_ with _format_.
+    # Coerce _left_ to a `Time` if it is not a time-like object already.
+    # Coerce _format_ to a string if it is not a string already.
+    def self.date: (FilterContext context, untyped left, untyped format) -> untyped
+  end
+end

data/sig/luoma/filters/default.rbs

@@ -0,0 +1,8 @@
+module Luoma
+  
+  module Filters
+    # Return _left_, or _default_ if _obj_ is `nil`, `false` or empty.
+    # If _allow_false_ is `true`, _left_ is returned if _left_ is `false`.
+    def self.default: (FilterContext context, untyped left, ?::String default, ?allow_false: bool) -> untyped
+  end
+end

data/sig/luoma/filters/json.rbs

@@ -0,0 +1,7 @@
+module Luoma
+  
+  module Filters
+    # Return _left_ serialized in JSON format.
+    def self.json: (FilterContext context, untyped left, ?pretty: bool) -> untyped
+  end
+end