luoma 0.1.0

data/sig/luoma/filters/math.rbs

@@ -0,0 +1,37 @@
+module Luoma
+  module Filters
+    # Return the absolute value of `left`.
+    def self.abs: (FilterContext context, untyped left) -> untyped
+
+    # Return the maximum of `left` and `right`.
+    def self.at_least: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return the minimum of `left` and `right`.
+    def self.at_most: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return `left` rounded up to the next whole number.
+    def self.ceil: (FilterContext context, untyped left) -> untyped
+
+    # Return the result of dividing `left` by `right`.
+    # If both `left` and `right` are integers, integer division is performed.
+    def self.divided_by: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return the result of multiplying `left` by `right`.
+    def self.times: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return `left` rounded down to the next whole number.
+    def self.floor: (FilterContext context, untyped left) -> untyped
+
+    # Return `right` subtracted from `left`.
+    def self.minus: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return the remainder of dividing `left` by `right`.
+    def self.modulo: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return `right` added to `left`.
+    def self.plus: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return `left` rounded to `ndigits` decimal digits.
+    def self.round: (FilterContext context, untyped left, ?::Integer ndigits) -> untyped
+  end
+end

data/sig/luoma/filters/size.rbs

@@ -0,0 +1,6 @@
+module Luoma
+  module Filters
+    # Return the size of _left_, or zero if _left_ has no size.
+    def self.size: (FilterContext context, untyped left) -> Integer
+  end
+end

data/sig/luoma/filters/slice.rbs

@@ -0,0 +1,10 @@
+module Luoma
+  module Filters
+    def self.slice: (
+      FilterContext context, 
+      untyped left, 
+      ?untyped start_, ?untyped stop_, ?untyped step_, 
+      ?start: untyped, ?stop: untyped, ?step: untyped
+    ) -> Array[untyped]
+  end
+end

data/sig/luoma/filters/sort.rbs

@@ -0,0 +1,17 @@
+module Luoma
+  module Filters
+    INFINITY_ARRAY: ::Array[untyped]
+
+    def self.sort: (FilterContext context, untyped left, ?untyped? key) -> untyped
+
+    def self.sort_natural: (FilterContext context, untyped left, ?untyped? key) -> untyped
+
+    def self.sort_numeric: (FilterContext context, untyped left, ?untyped? key) -> untyped
+
+    def self.nil_safe_casecmp: (untyped left, untyped right) -> (untyped | 0 | 1 | -1)
+
+    def self.numeric_compare: (untyped left, untyped right, FilterContext context) -> untyped
+
+    def self.ints: (untyped obj, FilterContext context) -> (::Array[untyped] | untyped)
+  end
+end

data/sig/luoma/filters/string.rbs

@@ -0,0 +1,103 @@
+module Luoma
+  module Filters
+    # Return _left_ concatenated with _right_.
+    # Coerce _left_ and _right_ to strings if they aren't strings already.
+    def self.append: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return _left_ with the first character in uppercase and the rest lowercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.capitalize: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with all characters converted to lowercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.downcase: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with all characters converted to uppercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.upcase: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with special HTML characters replaced with their HTML-safe escape sequences.
+    # Coerce _left_ to a string if it is not one already.
+    def self.escape: (FilterContext context, untyped left) -> (untyped | nil)
+
+    # Return _left_ with special HTML characters replaced with their HTML-safe escape sequences.
+    # Coerce _left_ to a string if it is not one already.
+    #
+    # It is safe to use `escape_once` on string values that already contain HTML-escape sequences.
+    def self.escape_once: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with leading whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.lstrip: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with trailing whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.rstrip: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with leading and trailing whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.strip: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with LF or CRLF replaced with `<br />\n`.
+    def self.newline_to_br: (FilterContext context, untyped left) -> untyped
+
+    # Return _right_ concatenated with _left_.
+    # Coerce _left_ and _right_ to strings if they aren't strings already.
+    def self.prepend_: (FilterContext context, untyped left, untyped right) -> untyped
+
+    # Return _left_ with all occurrences of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace: (FilterContext context, untyped left, untyped pattern, ?::String replacement) -> untyped
+
+    # Return _left_ with the first occurrence of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace_first: (FilterContext context, untyped left, untyped pattern, ?::String replacement) -> untyped
+
+    # Return _left_ with the last occurrence of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace_last: (FilterContext context, untyped left, untyped pattern, untyped replacement) -> untyped
+
+    # Return _left_ with all occurrences of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove: (FilterContext context, untyped left, untyped pattern) -> untyped
+
+    # Return _left_ with the first occurrence of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove_first: (FilterContext context, untyped left, untyped pattern) -> untyped
+
+    # Return _left_ with the last occurrence of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove_last: (FilterContext context, untyped left, untyped pattern) -> untyped
+
+    # Split _left_ on every occurrence of _pattern_.
+    def self.split: (FilterContext context, untyped left, untyped pattern) -> untyped
+
+    RE_HTML_BLOCKS: ::Regexp
+
+    RE_HTML_TAGS: ::Regexp
+
+    # Return _left_ with HTML tags removed.
+    def self.strip_html: (FilterContext context, untyped left) -> untyped
+
+    # Return _left_ with CR and LF removed.
+    def self.strip_newlines: (FilterContext context, untyped left) -> untyped
+
+    def self.truncate: (FilterContext context, untyped left, ?::Integer max_length, ?::String ellipsis) -> untyped
+
+    def self.truncatewords: (FilterContext context, untyped left, ?::Integer max_words, ?::String ellipsis) -> untyped
+
+    def self.url_encode: (FilterContext context, untyped left) -> untyped
+
+    def self.url_decode: (FilterContext context, untyped left) -> untyped
+
+    def self.base64_encode: (FilterContext context, untyped left) -> untyped
+
+    def self.base64_decode: (FilterContext context, untyped left) -> untyped
+
+    def self.base64_url_safe_encode: (FilterContext context, untyped left) -> untyped
+
+    def self.base64_url_safe_decode: (FilterContext context, untyped left) -> untyped
+
+    def self.squish: (FilterContext context, untyped left) -> untyped
+  end
+end

data/sig/luoma/fnv.rbs

@@ -0,0 +1,3 @@
+module Luoma
+  def self.fnv1a32: (String s) -> Integer
+end

data/sig/luoma/lexer.rbs

@@ -0,0 +1,42 @@
+module Luoma
+  class BaseLexer
+    @env: Environment
+
+    @source: String
+
+    @scanner: StringScanner
+
+    @start: Integer
+
+    @tokens: Array[t_token]
+
+    attr_reader tokens: Array[t_token]
+
+    def self.tokenize: (Environment env, String source) -> Array[t_token]
+
+    def initialize: (Environment env, String source) -> void
+
+    def go: () -> void
+
+    #  () -> Symbol?
+    def scan_markup: () -> Symbol?
+
+    #  (t_token_kind) -> void
+    def emit: (t_token_kind kind) -> void
+
+    #  (Regexp) -> Integer?
+    def index: (Regexp pattern) -> Integer?
+
+    #  (Regexp) -> String?
+    def scan: (Regexp pattern) -> String?
+
+    #  (Regexp) -> bool
+    def scan_until?: (Regexp pattern) -> bool
+
+    #  (Regexp) -> bool
+    def skip?: (Regexp pattern) -> bool
+
+    #  (Regexp) -> bool
+    def skip_until?: (Regexp pattern) -> bool
+  end
+end

data/sig/luoma/lexer_legacy.rbs

@@ -0,0 +1,81 @@
+module Luoma
+  # A single-pass template tokenizer that matches Shopify/liquid v5.12.0 strict
+  # mode syntax and semantics.
+  #
+  # We use lookahead and byte offset limits to achieve behavior equivalent to
+  # Shopify's two-pass tokenizer/parser.
+  class LegacyLexer < BaseLexer
+    RE_MARKUP: ::Regexp
+
+    RE_OUT_END: ::Regexp
+
+    RE_UP_TO_OUT_END: ::Regexp
+
+    RE_TAG_END: ::Regexp
+
+    RE_UP_TO_TAG_END: ::Regexp
+
+    RE_TRIVIA: ::Regexp
+
+    RE_LINE_TRIVIA: ::Regexp
+
+    RE_TAG_NAME: ::Regexp
+
+    RE_PUNCTUATION: ::Regexp
+
+    RE_IDENT: ::Regexp
+
+    RE_FLOAT: ::Regexp
+
+    RE_INT: ::Regexp
+
+    RE_COMMENT_SEGMENT: ::Regexp
+
+    RE_LINE_COMMENT_SEGMENT: ::Regexp
+
+    RE_END_DOC: ::Regexp
+
+    RE_END_RAW: ::Regexp
+
+    TOKEN_MAP: Hash[String, t_token_kind]
+
+    #  () -> Symbol?
+    def scan_markup: () -> Symbol?
+
+    #  (Integer) -> void
+    def accept_tag: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_expression: (Integer limit , ?Regexp trivia) -> void
+                         
+    #  (Integer) -> void
+    def accept_inline_comment: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_block_comment: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_doc_comment: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_raw_tag: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_line_statements: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_line_block_comment: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_line_doc_comment: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_line_raw_tag: (Integer limit) -> void
+                         
+    #  (Integer) -> void
+    def accept_string_literal: (Integer limit) -> void
+
+    #  () -> bool
+    def accept_whitespace_control?: () -> bool
+  end
+end

data/sig/luoma/lexer_unified.rbs

@@ -0,0 +1,49 @@
+module Luoma
+  class UnifiedLexer < BaseLexer
+    RE_FLOAT: ::Regexp
+
+    RE_INT: ::Regexp
+
+    RE_MARKUP_START: ::Regexp
+
+    RE_OUTPUT_END: ::Regexp
+
+    RE_PUNCTUATION: ::Regexp
+
+    RE_RAW_END: ::Regexp
+
+    RE_TAG_END: ::Regexp
+
+    RE_TAG_NAME: ::Regexp
+
+    RE_TRIVIA: ::Regexp
+
+    RE_WHITESPACE_CONTROL: ::Regexp
+
+    RE_WORD: ::Regexp
+
+    RE_HASH_COUNT: Hash[Integer, Regexp]
+
+    # Keywords and symbols that get their own token kind.
+    TOKEN_MAP: Hash[String, t_token_kind]
+
+
+    #  () -> void?
+    def accept_tag: () -> void
+                         
+    #  () -> void
+    def accept_expression: () -> void
+                         
+    #  () -> void
+    def accept_comment: () -> void
+                         
+    #  () -> void
+    def accept_string: () -> void
+                         
+    #  () -> void
+    def accept_object: () -> void
+
+    #  () -> bool
+    def accept_whitespace_control?: () -> bool
+  end
+end

data/sig/luoma/loader.rbs

@@ -0,0 +1,40 @@
+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: (Environment env, String name, ?context: RenderContext?, **untyped kwargs) -> TemplateSource
+
+    #  (Environment, String, ?globals: t_namespace?, ?context: RenderContext?, **kwargs) -> Template
+    def load: (Environment env, String name, ?globals: t_namespace?, ?context: RenderContext?, **untyped kwargs) -> Template
+  end
+
+  # Template source text and meta data.
+  class TemplateSource
+    @source: String
+
+    @name: String
+
+    @up_to_date: Proc::_Callable?
+
+    @matter: t_namespace?
+
+    attr_accessor source: String
+
+    attr_accessor name: String
+
+    attr_accessor up_to_date: Proc::_Callable?
+
+    attr_accessor matter: t_namespace?
+
+    def initialize: (source: String, name: String, ?up_to_date: Proc::_Callable?, ?matter: t_namespace?) -> void
+  end
+
+  # A template loader that reads templates from a hash.
+  class HashLoader < TemplateLoader
+    @templates: Hash[String, String]
+
+    #: (Hash<String, String>) -> void
+    def initialize: (Hash[String, String] templates) -> void
+  end
+end

data/sig/luoma/loaders/choice_loader.rbs

@@ -0,0 +1,9 @@
+module Luoma
+  class ChoiceLoader < TemplateLoader
+    @loaders: Array[TemplateLoader]
+
+    def initialize: (*TemplateLoader loaders) -> void
+
+    def load: (Environment env, String name, **untyped) -> Template
+  end
+end

data/sig/luoma/loaders/file_system_loader.rbs

@@ -0,0 +1,19 @@
+module Luoma
+  # A template loader that reads template from a file system.
+  class FileSystemLoader < TemplateLoader
+    @search_path: Array[Pathname]
+
+    @default_extension: String?
+
+    def initialize: (String | Array[String] search_path, ?default_extension: String?) -> void
+
+    def resolve_path: (String template_name) -> Pathname
+  end
+
+  # A file system template loader that caches parsed templates.
+  class CachingFileSystemLoader < FileSystemLoader
+    include CachingLoaderMixin
+
+    def initialize: (String | Array[String] search_path, ?default_extension: String?, ?auto_reload: bool, ?namespace_key: ::String, ?capacity: ::Integer, ?thread_safe: bool) -> void
+  end
+end

data/sig/luoma/loaders/mixins.rbs

@@ -0,0 +1,16 @@
+module Luoma
+  # A mixin that adds caching to a template loader.
+  module CachingLoaderMixin
+    @auto_reload: bool
+
+    @namespace_key: String?
+
+    @cache: LRUCache
+
+    def initialize_cache: (?auto_reload: bool, ?namespace_key: ::String, ?capacity: ::Integer, ?thread_safe: bool) -> untyped
+
+    def load: (Environment env, String name, ?globals: _Namespace?, ?context: RenderContext?, **untyped kwargs) -> Template
+
+    def cache_key: (String name, ?context: RenderContext?, **untyped kwargs) -> String
+  end
+end

data/sig/luoma/markup.rbs

@@ -0,0 +1,68 @@
+module Luoma
+  interface _Tag
+    def parse: (t_token, String, Parser) -> Markup
+  end
+  
+  # The base class for all tag nodes and the output statement.
+  class Markup
+    @token: t_token
+
+    @blank: bool
+
+    @tag_name: String
+
+    attr_reader token: t_token
+
+    attr_reader blank: bool
+
+    attr_reader tag_name: String
+
+    #  (t_token) -> void
+    def initialize: (t_token token) -> void
+
+    #  (RenderContext, String) -> void
+    def render: (RenderContext context, String buffer) -> void
+
+    #  (RenderContext) -> Array[Markup]
+    def children: (RenderContext static_context) -> ::Array[Markup]
+
+    #  () -> Array[Expression]
+    def expressions: () -> ::Array[Expression]
+
+    #  () -> Array[Name]
+    def block_scope: () -> ::Array[Name]
+
+    #  () -> Array[Name]
+    def template_scope: () -> ::Array[Name]
+
+    #  (RenderContext) -> Partial?
+    def partial: (RenderContext static_context) -> Partial?
+  end
+
+  class Partial
+    @template: Template
+
+    @scope_kind: (:shared | :isolated | :inherited)
+
+    @in_scope: Array[Name]
+
+    @key: Integer
+
+    attr_reader template: Template
+
+    attr_reader scope_kind: :shared | :isolated | :inherited
+
+    attr_reader in_scope: Array[Name]
+
+    attr_reader key: Integer
+
+    #  (Template, :shared | :isolated | :inherited, Array[Name], Integer) -> void
+    def initialize: (Template template, :shared | :isolated | :inherited scope_kind, Array[Name] in_scope, Integer key) -> void
+  end
+
+  #  (t_block, RenderContext, String) -> void
+  def self.render_block: (t_block block, RenderContext context, String buffer, ?root: bool) -> void
+
+  #  (t_block) -> bool
+  def self.blank_block?: (t_block block) -> bool
+end

data/sig/luoma/parser.rbs

@@ -0,0 +1,105 @@
+module Luoma
+  class Parser
+    @env: Environment
+
+    @source: String
+
+    @template_name: String
+
+    @tokens: Array[t_token]
+
+    @pos: Integer
+
+    @eoi: t_token
+
+    @whitespace_control_carry: "-" | "+" | "~" | nil
+
+    TERMINATE_EXPRESSION: Set[t_token_kind]
+
+    attr_reader env: Environment
+
+    attr_reader source: String
+
+    attr_reader template_name: String
+
+    #  (Environment, String, String, Array[t_token]) -> t_block
+    def self.parse: (Environment env, String source, String template_name, Array[t_token] tokens) -> t_block
+
+    #  (Environment, String, String, Array[t_token]) -> void
+    def initialize: (Environment env, String source, String template_name, Array[t_token] tokens) -> void
+
+    #  () -> void
+    def carry_whitespace_control: () -> void
+
+    #  () -> t_token
+    def current: () -> t_token
+
+    #  () -> t_token_kind
+    def kind: () -> t_token_kind
+
+    #  () -> String
+    def current_value: () -> String
+
+    #  () -> t_token
+    def next: () -> t_token
+
+    def peek: (?::Integer offset) -> t_token
+
+    #  (t_token_kind, ?message: String?) -> t_token
+    def eat: (t_token_kind kind, ?message: String?) -> t_token
+
+    #  (String) -> t_token
+    def eat_empty_tag: (String name) -> t_token
+
+    #  (Set[t_token_kind]) -> t_token
+    def eat_one_of: (Set[t_token_kind] kinds) -> t_token
+
+    #  (String) -> t_token
+    def eat_tag: (String name) -> t_token
+
+    # Raise an error if we're not at the start of an expression.
+    #  () -> void
+    def expect_expression: () -> void
+                         
+    #  (?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
+
+    #  (?precedence: Integer) -> Expression
+    def parse_expression: (?precedence: Integer) -> Expression
+
+    #  () -> 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: bool?) -> Array[Expression]
+
+    #  () -> StringLiteral
+    def parse_string_literal: () -> StringLiteral
+
+    #  () -> String
+    def peek_tag_name: () -> String
+
+    #  () -> String?
+    def peek_whitespace_control: () -> String?
+
+    #  () -> void
+    def skip_whitespace_control: () -> void
+
+    # Return `true` if we're at the start of a tag named `name`.
+    #  (String) -> bool
+    def tag?: (String name) -> bool
+
+    #  (Set[String]) -> String?
+    def tags: (Set[String] names) -> String?
+  end
+end