fmt 0.1.3 → 0.3.0

data/sig/generated/fmt/models/arguments.rbs

@@ -0,0 +1,115 @@
+# Generated from lib/fmt/models/arguments.rb with RBS::Inline
+
+module Fmt
+  # Represents arguments for a method call
+  #
+  # Arguments are comprised of:
+  # 1. args: Array[Object]
+  # 2. kwargs: Hash[Symbol, Object]
+  class Arguments < Model
+    # Constructor
+    # @rbs ast: Node
+    def initialize: (Node ast) -> untyped
+
+    attr_reader args: untyped
+
+    attr_reader kwargs: untyped
+
+    # Hash representation of the model (required for pattern matching)
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    # Processes an arguments AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_arguments: (Node node) -> void
+
+    # Processes a tokens AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_tokens: (Node node) -> void
+
+    # Processes a keyword AST node
+    # @rbs node: Node
+    # @rbs return: nil | true | false | Object
+    def on_kw: (Node node) -> (nil | true | false | Object)
+
+    # Processes a string AST node
+    # @rbs node: Node
+    # @rbs return: String
+    def on_tstring_content: (Node node) -> String
+
+    # Processes a symbol AST Node
+    # @rbs node: Node
+    # @rbs return: Symbol
+    def on_symbol: (Node node) -> Symbol
+
+    # Processes a symbol start AST Node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_symbeg: (Node node) -> void
+
+    # Processes an identifier AST Node
+    # @rbs node: Node
+    # @rbs return: Symbol?
+    def on_ident: (Node node) -> Symbol?
+
+    # Processes an integer AST node
+    # @rbs node: Node
+    # @rbs return: Integer
+    def on_int: (Node node) -> Integer
+
+    # Processes a float AST node
+    # @rbs node: Node
+    # @rbs return: Float
+    def on_float: (Node node) -> Float
+
+    # Processes a rational AST node
+    # @rbs node: Node
+    # @rbs return: Rational
+    def on_rational: (Node node) -> Rational
+
+    # Processes an imaginary (complex) AST node
+    # @rbs node: Node
+    # @rbs return: Complex
+    def on_imaginary: (Node node) -> Complex
+
+    # Processes a left bracket AST node
+    # @rbs node: Node
+    # @rbs return: Array
+    def on_lbracket: (Node node) -> Array
+
+    # Processes a left brace AST node
+    # @rbs node: Node
+    # @rbs return: Hash
+    def on_lbrace: (Node node) -> Hash
+
+    # Process a label (hash key) AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_label: (Node node) -> void
+
+    private
+
+    # Assigns a value to the receiver
+    # @rbs value: Object -- value to assign
+    # @rbs label: Symbol? -- label to use (if applicable)
+    # @rbs return: Object
+    def assign: (Object value, ?label: Symbol?) -> Object
+
+    # Receiver that the processed value will be assigned to
+    # @rbs label: Symbol? -- label to use (if applicable)
+    # @rbs return: Array | Hash
+    def receiver: (?label: Symbol?) -> (Array | Hash)
+
+    # Finds the receiver that the processed value will be assigned to
+    # @rbs obj: Object
+    # @rbs return: Array? | Hash?
+    def find_receiver: (Object obj) -> (Array? | Hash?)
+
+    # Indicates if the value is a composite type (Array or Hash)
+    # @rbs value: Object -- value to check
+    # @rbs return: bool
+    def composite?: (Object value) -> bool
+  end
+end

data/sig/generated/fmt/models/embed.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/fmt/models/embed.rb with RBS::Inline
+
+module Fmt
+  class Embed < Model
+    attr_reader key: untyped
+
+    attr_reader placeholder: untyped
+
+    attr_reader template: untyped
+
+    # Hash representation of the model (required for pattern matching)
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    # Processes an embed AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_embed: (Node node) -> void
+
+    # Processes a key AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_key: (Node node) -> void
+
+    # Processes a placeholder AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_placeholder: (Node node) -> void
+
+    # Processes a template AST node
+    # @rbs node: Node
+    def on_template: (Node node) -> untyped
+  end
+end

data/sig/generated/fmt/models/macro.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/fmt/models/macro.rb with RBS::Inline
+
+module Fmt
+  # Represents an uninvoked method call
+  #
+  # A Macro is comprised of:
+  # 1. name: Symbol
+  # 2. arguments: Arguments
+  class Macro < Model
+    attr_reader name: untyped
+
+    attr_reader arguments: untyped
+
+    # Constructor
+    # @rbs ast: Node
+    def initialize: (Node ast) -> untyped
+
+    # Hash representation of the model (required for pattern matching)
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    # Processes a macro AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_macro: (Node node) -> void
+
+    # Processes a procedure AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_name: (Node node) -> void
+
+    # Processes an arguments AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_arguments: (Node node) -> void
+  end
+end

data/sig/generated/fmt/models/model.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/fmt/models/model.rb with RBS::Inline
+
+module Fmt
+  # Superclass for all models
+  # @note Models are constructed from AST nodes
+  class Model
+    include AST::Processor::Mixin
+
+    include Matchable
+
+    # Constructor
+    # @rbs ast: Node
+    def initialize: (Node ast) -> untyped
+
+    attr_reader ast: untyped
+
+    attr_reader urtext: untyped
+
+    attr_reader source: untyped
+
+    # Model inspection
+    # @rbs return: String
+    def inspect: () -> String
+
+    # Indicates if a given AST node is the same AST used to construct the model
+    # @rbs node: Node
+    # @rbs return: bool
+    def self?: (Node node) -> bool
+
+    # Hash representation of the model (required for pattern matching)
+    # @note Subclasses should override this method and call: super.merge(**)
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    private
+
+    # Hash of instance variables for inspection
+    # @rbs return: Hash[String, Object]
+    def inspectable_properties: () -> Hash[String, Object]
+
+    # String of inspectable properties for inspection
+    # @rbs return: String
+    def inspect_properties: () -> String
+  end
+end

data/sig/generated/fmt/models/pipeline.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/fmt/models/pipeline.rb with RBS::Inline
+
+module Fmt
+  # Represents a series of Macros
+  #
+  # A Pipeline is comprised of:
+  # 1. macros: Array[Macro]
+  #
+  # @note Pipelines are processed in sequence (left to right)
+  class Pipeline < Model
+    # Constructor
+    # @rbs ast: Node
+    def initialize: (Node ast) -> untyped
+
+    attr_reader macros: untyped
+
+    # Hash representation of the model (required for pattern matching)
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    # Processes a pipeline AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_pipeline: (Node node) -> void
+
+    # Processes a macro AST node
+    # @rbs node: Node
+    # @rbs return: void
+    def on_macro: (Node node) -> void
+  end
+end

data/sig/generated/fmt/models/template.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/fmt/models/template.rb with RBS::Inline
+
+module Fmt
+  # Represents a formattable string
+  #
+  # A Template is comprised of:
+  # 1. embeds: Array[Template] -- embedded templates
+  # 2. pipelines :: Array[Pipeline] -- sets of Macros
+  #
+  # @note Embeds are processed from inner to outer
+  class Template < Model
+    # Constructor
+    # @rbs ast: Node
+    def initialize: (Node ast) -> untyped
+
+    attr_reader embeds: untyped
+
+    attr_reader pipelines: untyped
+
+    # @rbs return: Hash[Symbol, Object]
+    def to_h: () -> Hash[Symbol, Object]
+
+    def on_template: (untyped node) -> untyped
+
+    def on_embeds: (untyped node) -> untyped
+
+    def on_embed: (untyped node) -> untyped
+
+    def on_pipelines: (untyped node) -> untyped
+
+    def on_pipeline: (untyped node) -> untyped
+  end
+end

data/sig/generated/fmt/node.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/fmt/node.rb with RBS::Inline
+
+module Fmt
+  # Extends behavior of AST::Node
+  class Node < AST::Node
+    extend Forwardable
+
+    # Finds all Node child nodes
+    # @rbs node: Node -- node to search
+    # @rbs return: Array[Node]
+    def self.node_children: (Node node) -> Array[Node]
+
+    # Recursively finds all Nodes in the tree
+    # @rbs node: Node -- node to search
+    # @rbs return: Array[Node]
+    def self.node_descendants: (Node node) -> Array[Node]
+
+    # Constructor
+    # @rbs type: Symbol
+    # @rbs children: Array[Node]
+    # @rbs properties: Hash[Symbol, Object]
+    def initialize: (Symbol type, ?Array[Node] children, ?Hash[Symbol, Object] properties) -> untyped
+
+    attr_reader properties: untyped
+
+    # Recursively searches the tree for a descendant node
+    # @rbs types: Array[Object] -- node types to find
+    # @rbs return: Node?
+    def dig: (*untyped types) -> Node?
+
+    # Finds the first child node of the specified type
+    # @rbs type: Object -- node type to find
+    # @rbs return: Node?
+    def find: (Object type) -> Node?
+
+    # Flattens Node descendants into a one dimensional array
+    # @rbs return: Array[Node]
+    def flatten: () -> Array[Node]
+
+    # Finds all child nodes of the specified type
+    # @rbs type: Object -- node type to select
+    # @rbs return: Node?
+    def select: (Object type) -> Node?
+
+    # String representation of the node (AST)
+    # @rbs squish: bool -- remove extra whitespace
+    # @rbs return: String
+    def to_s: (?squish: bool) -> String
+
+    private
+
+    # Finds all Node child nodes
+    # @rbs return: Array[Node]
+    def node_children: () -> Array[Node]
+
+    # Recursively finds all Node nodes in the tree
+    # @rbs return: Array[Node]
+    def node_descendants: () -> Array[Node]
+
+    # Defines accessor methods for properties on the receiver
+    # @rbs properties: Hash[Symbol, Object] -- exposed as instance methods
+    def define_properties: (Hash[Symbol, Object] properties) -> untyped
+  end
+end

data/sig/generated/fmt/parsers/arguments_parser.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/fmt/parsers/arguments_parser.rb with RBS::Inline
+
+module Fmt
+  # Parses arguments from a string and builds an AST (Abstract Syntax Tree)
+  class ArgumentsParser < Parser
+    # Constructor
+    # @rbs tokens: Array[Token] -- wrapped ripper tokens
+    def initialize: (?Array[Token] tokens) -> untyped
+
+    attr_reader tokens: untyped
+
+    # Parses the urtext (original source code)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @rbs return: Hash[Symbol, Object] -- extracted components
+    def extract: () -> Hash[Symbol, Object]
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs tokens: Array[Token] -- extracted tokens
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (tokens: Array[Token]) -> Node
+  end
+end

data/sig/generated/fmt/parsers/embed_parser.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/fmt/parsers/embed_parser.rb with RBS::Inline
+
+module Fmt
+  # Parses embeds from a string and builds an AST (Abstract Syntax Tree)
+  class EmbedParser < Parser
+    # Constructor
+    # @rbs urtext: String -- original source code
+    # @rbs key: Symbol -- key for embed
+    # @rbs placeholder: String -- placeholder for embed
+    def initialize: (?String urtext, key: Symbol, placeholder: String) -> untyped
+
+    attr_reader urtext: untyped
+
+    attr_reader key: untyped
+
+    attr_reader placeholder: untyped
+
+    # Parses the urtext (original source code)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @rbs return: Hash[Symbol, Object] -- extracted components
+    def extract: () -> Hash[Symbol, Object]
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (**untyped) -> Node
+
+    private
+
+    # Returns the template urtext
+    # @rbs return: String
+    def template_urtext: () -> String
+  end
+end

data/sig/generated/fmt/parsers/macro_parser.rbs

@@ -0,0 +1,60 @@
+# Generated from lib/fmt/parsers/macro_parser.rb with RBS::Inline
+
+module Fmt
+  # Parses a macro from a string and builds an AST (Abstract Syntax Tree)
+  class MacroParser < Parser
+    # Constructor
+    # @rbs urtext: String -- original source code
+    def initialize: (?String urtext) -> untyped
+
+    attr_reader urtext: untyped
+
+    # Parses the urtext (original source code)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @rbs return: Hash[Symbol, Object] -- extracted components
+    def extract: () -> Hash[Symbol, Object]
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs method: Symbol?
+    # @rbs arguments_tokens: Array[Token] -- arguments tokens
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (method: Symbol?, arguments_tokens: Array[Token]) -> Node
+
+    private
+
+    # Tokenizes source code
+    # @rbs code: String -- source code to tokenize
+    # @rbs return: Array[Token] -- wrapped ripper tokens
+    def tokenize: (String code) -> Array[Token]
+
+    # Indicates if there is a set of arguments in the tokens
+    # @rbs tokens: Array[Token] -- tokens to check
+    # @rbs return: bool
+    def arguments?: (Array[Token] tokens) -> bool
+
+    # Indicates if arguments have started
+    # @rbs tokens: Array[Token] -- tokens to check
+    # @rbs return: bool
+    def arguments_started?: (Array[Token] tokens) -> bool
+
+    # Indicates if arguments have finished
+    # @note Call this after a whitespace has been detected
+    # @rbs tokens: Array[Token] -- tokens to check
+    # @rbs return: bool
+    def arguments_finished?: (Array[Token] tokens) -> bool
+
+    # Indicates if a macro token array is complete or finished
+    # @note Call this after a whitespace has been detected
+    # @rbs tokens: Array[Token] -- tokens to check
+    # @rbs return: bool
+    def finished?: (Array[Token] tokens) -> bool
+
+    # Indicates if a value is a Ruby native format string
+    # @rbs value: String -- value to check
+    # @rbs return: bool
+    def native_format_string?: (String value) -> bool
+  end
+end

data/sig/generated/fmt/parsers/parser.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/fmt/parsers/parser.rb with RBS::Inline
+
+module Fmt
+  # Responsible for parsing various inputs and returning an AST (Abstract Syntax Tree)
+  #
+  # Mechanics are similar to an ETL pipeline (Extract, Transform, Load), however,
+  # parsers only handle extracting and transforming.
+  #
+  # Loading is handled by AST processors (Models)
+  # @see lib/fmt/models/
+  class Parser
+    Cache: untyped
+
+    # Escapes a string for use in a regular expression
+    # @rbs value: String -- string to escape
+    # @rbs return: String -- escaped string
+    def self.esc: (String value) -> String
+
+    # Parses input passed to the constructor and returns an AST (Abstract Syntax Tree)
+    #
+    # 1. Extract components
+    # 2. Transform to AST
+    #
+    # @note Subclasses must implement the extract and transform methods
+    #
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @rbs return: Hash[Symbol, Object] -- extracted components
+    def extract: () -> Hash[Symbol, Object]
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs kwargs: Hash[Symbol, Object] -- extracted components
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (**untyped kwargs) -> Node
+
+    # Cache helper that fetches a value from the cache
+    # @rbs key: String -- cache key
+    # @rbs block: Proc -- block to execute if the value is not found in the cache
+    # @rbs return: Object
+    def cache: (String key) ?{ (?) -> untyped } -> Object
+  end
+end

data/sig/generated/fmt/parsers/pipeline_parser.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/fmt/parsers/pipeline_parser.rb with RBS::Inline
+
+module Fmt
+  # Parses a pipeline from a string and builds an AST (Abstract Syntax Tree)
+  class PipelineParser < Parser
+    # Constructor
+    # @rbs urtext: String -- original source code
+    def initialize: (?String urtext) -> untyped
+
+    attr_reader urtext: untyped
+
+    # Parses the urtext (original source code)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @rbs return: Hash[Symbol, Object] -- extracted components
+    def extract: () -> Hash[Symbol, Object]
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs macros: Array[Array[Token]] -- extracted macro tokens
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (macros: Array[Array[Token]]) -> Node
+  end
+end

data/sig/generated/fmt/parsers/template_parser.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/fmt/parsers/template_parser.rb with RBS::Inline
+
+module Fmt
+  # Parses a template from a string and builds an AST (Abstract Syntax Tree)
+  class TemplateParser < Parser
+    PIPELINE_HEAD: ::Regexp
+
+    PIPELINE_TAIL: ::Regexp
+
+    EMBED_HEAD: ::Regexp
+
+    EMBED_TAIL: ::Regexp
+
+    # Constructor
+    # @rbs urtext: String -- original source code
+    # @rbs scanner: StringScanner?
+    def initialize: (?String urtext, ?scanner: StringScanner?) -> untyped
+
+    attr_reader urtext: untyped
+
+    attr_reader scanner: untyped
+
+    # Parses the urtext (original source code)
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def parse: () -> Node
+
+    # Extracts components for building the AST (Abstract Syntax Tree)
+    # @note Extraction is delegated to the PipelineParser and EmbedParser in transform
+    # @rbs return: Hash
+    def extract: () -> Hash
+
+    # Transforms extracted components into an AST (Abstract Syntax Tree)
+    # @rbs embeds: Array[Hash] -- extracted embeds
+    # @rbs pipelines: Array[String] -- extracted pipelines
+    # @rbs source: String -- parsed source code
+    # @rbs return: Node -- AST (Abstract Syntax Tree)
+    def transform: (embeds: Array[Hash], pipelines: Array[String], source: String) -> Node
+
+    private
+
+    # Extracts embed metadata from the urtext
+    # @rbs return: Array[Hash] -- extracted embeds
+    def extract_embeds: () -> Array[Hash]
+
+    # Extracts pipelines from the source
+    # @rbs source: String -- source code to extract pipelines from
+    # @rbs return: Array[String] -- extracted pipelines
+    def extract_pipelines: (String source) -> Array[String]
+  end
+end

data/sig/generated/fmt/refinements/kernel_refinement.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/fmt/refinements/kernel_refinement.rb with RBS::Inline
+
+module Fmt
+  module KernelRefinement
+    # Formats an object with Fmt
+    # @rbs object [Object] -- object to format (coerced to String)
+    # @rbs pipeline [Array[String | Symbol]] -- Fmt pipeline
+    # @rbs return [String] -- formatted text
+    def fmt: ([ Object ] object, *untyped pipeline) -> [ String ]
+
+    # Formats an object with Fmt and prints to STDOUT
+    # @rbs object [Object] -- object to format (coerced to String)
+    # @rbs pipeline [Array[String | Symbol]] -- Fmt pipeline
+    # @rbs return void
+    def fmt_print: ([ Object ] object, *untyped pipeline) -> void
+
+    # Formats an object with Fmt and puts to STDOUT
+    # @rbs object [Object] -- object to format (coerced to String)
+    # @rbs pipeline [Array[String | Symbol]] -- Fmt pipeline
+    # @rbs return void
+    def fmt_puts: ([ Object ] object, *untyped pipeline) -> void
+  end
+end

data/sig/generated/fmt/registries/native_registry.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/fmt/registries/native_registry.rb with RBS::Inline
+
+module Fmt
+  # Extends native Ruby String format specifications with native Ruby methods
+  # @see https://ruby-doc.org/3.3.4/format_specifications_rdoc.html
+  class NativeRegistry < Registry
+    SUPPORTED_CLASSES: untyped
+
+    # Constructor
+    def initialize: () -> untyped
+
+    private
+
+    # Array of supported method names for a Class
+    # @rbs klass: Class
+    # @rbs return: Array[Symbol]
+    def supported_method_names: (Class klass) -> Array[Symbol]
+  end
+end

data/sig/generated/fmt/registries/rainbow_registry.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/fmt/registries/rainbow_registry.rb with RBS::Inline
+
+module Fmt
+  # Extends native Ruby String format specifications with Rainbow methods
+  # @see https://ruby-doc.org/3.3.4/format_specifications_rdoc.html
+  # @note Rainbow macros convert the Object to a String
+  class RainbowRegistry < Registry
+    # Constructor
+    def initialize: () -> untyped
+  end
+end