ibex 0.1.0

data/sig/ibex/cli.rbs

@@ -0,0 +1,108 @@
+# Generated from lib/ibex/cli.rb with RBS::Inline
+
+module Ibex
+  interface _CLIOutput
+    def puts: (*untyped) -> untyped
+
+    def write: (String) -> untyped
+  end
+
+  type cli_options = { emit: String, mode: Symbol, table: Symbol, line_convert: bool, ?line_convert_all: bool, counterexample_max_tokens: Integer, counterexample_max_configurations: Integer, ?from: String, ?algorithm: Symbol, ?warnings: Array[Symbol], ?output: String, ?embedded: bool, ?debug: bool, ?verbose: bool, ?rbs: String | true, ?dot: String, ?html: String, ?log_file: String, ?executable: String, ?frozen: bool, ?omit_actions: bool, ?superclass: String, ?check_only: bool, ?status: bool, ?profile: bool, ?debug_flags: String, ?version: bool, ?runtime_version: bool, ?copyright: bool, ?help: bool }
+
+  # Command-line pipeline coordinator.
+  # rubocop:disable Metrics/ClassLength -- inline type contracts add lines without adding runtime responsibilities.
+  class CLI
+    include CLICounterexampleOptions
+
+    include CLIOutputs
+
+    @options: cli_options
+
+    @stderr: _CLIOutput
+
+    @stdout: _CLIOutput
+
+    # @rbs (Array[String] arguments, ?stdout: _CLIOutput, ?stderr: _CLIOutput) -> Integer
+    def self.start: (Array[String] arguments, ?stdout: _CLIOutput, ?stderr: _CLIOutput) -> Integer
+
+    # @rbs (stdout: _CLIOutput, stderr: _CLIOutput) -> void
+    def initialize: (stdout: _CLIOutput, stderr: _CLIOutput) -> void
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run: (Array[String] arguments) -> Integer
+
+    private
+
+    # @rbs () -> OptionParser
+    def option_parser: () -> OptionParser
+
+    # @rbs (OptionParser options) -> void
+    def add_pipeline_options: (OptionParser options) -> void
+
+    # @rbs (OptionParser options) -> void
+    def add_output_options: (OptionParser options) -> void
+
+    # @rbs (OptionParser options) -> void
+    def add_compatibility_options: (OptionParser options) -> void
+
+    # @rbs (OptionParser options) -> void
+    def add_information_options: (OptionParser options) -> void
+
+    # @rbs (OptionParser parser) -> Integer?
+    def informational_result: (OptionParser parser) -> Integer?
+
+    # @rbs (Array[String] remaining) -> String
+    def input_path: (Array[String] remaining) -> String
+
+    # @rbs (String path) -> Integer
+    def process_grammar: (String path) -> Integer
+
+    # @rbs (String path) -> Integer
+    def process_ir: (String path) -> Integer
+
+    # @rbs (IR::Grammar grammar, String path) -> Integer
+    def dispatch_grammar: (IR::Grammar grammar, String path) -> Integer
+
+    # @rbs (IR::Automaton automaton, String path) -> Integer
+    def dispatch_automaton: (IR::Automaton automaton, String path) -> Integer
+
+    # @rbs () -> Integer
+    def print_version: () -> Integer
+
+    # @rbs (OptionParser parser) -> Integer
+    def print_help: (OptionParser parser) -> Integer
+
+    # @rbs () -> Integer
+    def print_copyright: () -> Integer
+
+    # @rbs (Frontend::AST::Root ast) -> Integer
+    def emit_ast: (Frontend::AST::Root ast) -> Integer
+
+    # @rbs (IR::Grammar grammar) -> Integer
+    def emit_grammar: (IR::Grammar grammar) -> Integer
+
+    # @rbs (IR::Grammar grammar, String input_path) -> Integer
+    def emit_automaton: (IR::Grammar grammar, String input_path) -> Integer
+
+    # @rbs (IR::Grammar grammar, String input_path) -> Integer
+    def emit_ruby: (IR::Grammar grammar, String input_path) -> Integer
+
+    # @rbs (IR::Automaton automaton, String input_path) -> Integer
+    def generate_ruby: (IR::Automaton automaton, String input_path) -> Integer
+
+    # @rbs (IR::Automaton automaton, String output_path) -> void
+    def write_rbs: (IR::Automaton automaton, String output_path) -> void
+
+    # @rbs (IR::Automaton automaton, String input_path) -> Integer
+    def emit_loaded_automaton: (IR::Automaton automaton, String input_path) -> Integer
+
+    # @rbs (IR::Grammar grammar, String input_path) -> IR::Automaton
+    def build_automaton: (IR::Grammar grammar, String input_path) -> IR::Automaton
+
+    # @rbs (IR::Automaton automaton, String input_path) -> void
+    def prepare_loaded_automaton: (IR::Automaton automaton, String input_path) -> void
+
+    # @rbs (IR::Automaton automaton) -> void
+    def write_visualizations: (IR::Automaton automaton) -> void
+  end
+end

data/sig/ibex/codegen/dot.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/ibex/codegen/dot.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Renders Graphviz DOT from Automaton IR.
+    module Dot
+      private def escape: (String value) -> String
+
+      private def self.escape: (String value) -> String
+
+      private def symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      # @rbs (IR::Automaton automaton) -> String
+      def self?.render: (IR::Automaton automaton) -> String
+    end
+  end
+end

data/sig/ibex/codegen/html.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/codegen/html.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Renders a self-contained navigable automaton report.
+    module HTML
+      private def state_sections: (IR::Automaton automaton, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def self.state_sections: (IR::Automaton automaton, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def item_html: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def self.item_html: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def rule_sections: (IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def self.rule_sections: (IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def conflict_sections: (IR::Automaton automaton) -> String
+
+      private def self.conflict_sections: (IR::Automaton automaton) -> String
+
+      private def escape: (String value) -> String
+
+      private def self.escape: (String value) -> String
+
+      private def symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      # @rbs (IR::Automaton automaton) -> String
+      def self?.render: (IR::Automaton automaton) -> String
+    end
+  end
+end

data/sig/ibex/codegen/rbs.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/ibex/codegen/rbs.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Generates an RBS declaration for the public surface of a generated parser.
+    class RBS
+      @automaton: IR::Automaton
+
+      @grammar: IR::Grammar
+
+      @superclass: String
+
+      # @rbs (IR::Automaton automaton, ?superclass: String?) -> void
+      def initialize: (IR::Automaton automaton, ?superclass: String?) -> void
+
+      # @rbs () -> String
+      def generate: () -> String
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_contract: (Array[String] lines) -> void
+
+      # @rbs () -> [Array[String], String]
+      def class_parts: () -> [ Array[String], String ]
+
+      # @rbs () -> String
+      def grammar_digest_comment: () -> String
+    end
+  end
+end

data/sig/ibex/codegen/report.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/ibex/codegen/report.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Renders a human-readable state and conflict report from Automaton IR.
+    module Report
+      private def append_state: (Array[String] lines, IR::AutomatonState state, IR::Grammar grammar, Array[IR::counterexample] examples, Hash[Integer, String] labels) -> void
+
+      private def self.append_state: (Array[String] lines, IR::AutomatonState state, IR::Grammar grammar, Array[IR::counterexample] examples, Hash[Integer, String] labels) -> void
+
+      private def append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar, Hash[Integer, String] labels) -> void
+
+      private def self.append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar, Hash[Integer, String] labels) -> void
+
+      private def append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar, Hash[Integer, String] labels) -> void
+
+      private def self.append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar, Hash[Integer, String] labels) -> void
+
+      private def format_item: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def self.format_item: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+
+      private def format_action: (IR::parser_action action) -> String
+
+      private def self.format_action: (IR::parser_action action) -> String
+
+      private def symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+
+      private def tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+
+      private def self.tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+
+      # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> String
+      def self?.render: (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> String
+    end
+  end
+end

data/sig/ibex/codegen/ruby.rbs

@@ -0,0 +1,92 @@
+# Generated from lib/ibex/codegen/ruby.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Generates a standalone Ruby parser class from Automaton IR.
+    class Ruby
+      @executable: String?
+
+      @superclass: String
+
+      @omit_action_call: bool
+
+      @debug: bool
+
+      @line_convert_all: bool
+
+      @line_convert: bool
+
+      @embedded: bool
+
+      @table_format: Symbol
+
+      @grammar: IR::Grammar
+
+      @automaton: IR::Automaton
+
+      # @rbs (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool,
+      #   ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?,
+      #   ?executable: String?) -> void
+      def initialize: (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool, ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?, ?executable: String?) -> void
+
+      # @rbs () -> String
+      def generate: () -> String
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_runtime: (Array[String] lines) -> void
+
+      # @rbs (String relative_path) -> String
+      def embedded_source: (String relative_path) -> String
+
+      # @rbs (Array[String] lines) -> void
+      def append_tables: (Array[String] lines) -> void
+
+      # @rbs (untyped table) -> String
+      def table_literal: (untyped table) -> String
+
+      # @rbs () -> String
+      def token_ids_literal: () -> String
+
+      # @rbs (IR::GrammarSymbol terminal) -> String
+      def external_token_expression: (IR::GrammarSymbol terminal) -> String
+
+      # @rbs () -> String
+      def token_names_literal: () -> String
+
+      # @rbs () -> String
+      def productions_literal: () -> String
+
+      # @rbs (Array[String] lines) -> void
+      def append_actions: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_constant: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_method: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (Array[String] lines, IR::Action? action) -> void
+      def append_named_bindings: (Array[String] lines, IR::Action? action) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_semantic_code: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (IR::Production production) -> bool
+      def action_method?: (IR::Production production) -> bool
+
+      # @rbs (Array[String] lines, String name, ?indent: Integer) -> void
+      def append_user_code: (Array[String] lines, String name, ?indent: Integer) -> void
+
+      # @rbs (String name) -> bool
+      def map_user_code?: (String name) -> bool
+
+      # @rbs () -> [Array[String], String]
+      def class_parts: () -> [ Array[String], String ]
+
+      # @rbs () -> String
+      def grammar_digest_comment: () -> String
+    end
+  end
+end

data/sig/ibex/codegen/symbol_labels.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/ibex/codegen/symbol_labels.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Builds human-facing symbol labels without changing Grammar IR identities.
+    module SymbolLabels
+      # @rbs (IR::Grammar grammar) -> Hash[Integer, String]
+      def self.build: (IR::Grammar grammar) -> Hash[Integer, String]
+    end
+  end
+end

data/sig/ibex/error.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/ibex/error.rb with RBS::Inline
+
+module Ibex
+  # Base error raised for invalid grammars and command failures.
+  class Error < StandardError
+  end
+end

data/sig/ibex/frontend/action_scanner.rbs

@@ -0,0 +1,74 @@
+# Generated from lib/ibex/frontend/action_scanner.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Extracts a balanced Ruby action while ignoring braces inside literals.
+    class ActionScanner
+      type heredoc = { identifier: String, indented: bool, length: Integer, location: Location }
+
+      PAIRED_DELIMITERS: Hash[String, String]
+
+      REGEX_PREFIXES: String
+
+      @pending_heredocs: Array[heredoc]
+
+      @cursor: SourceCursor
+
+      # @rbs (SourceCursor cursor) -> void
+      def initialize: (SourceCursor cursor) -> void
+
+      # @rbs () -> Token
+      def scan: () -> Token
+
+      private
+
+      # @rbs (Integer depth) -> void
+      def scan_code: (Integer depth) -> void
+
+      # @rbs () -> void
+      def scan_special_character: () -> void
+
+      # @rbs (String quote) -> void
+      def scan_quoted: (String quote) -> void
+
+      # @rbs () -> void
+      def scan_interpolation: () -> void
+
+      # @rbs () -> void
+      def scan_percent_literal: () -> void
+
+      # @rbs (String opener, String closer) -> void
+      def scan_delimited: (String opener, String closer) -> void
+
+      # @rbs () -> bool
+      def regexp_start?: () -> bool
+
+      # @rbs () -> void
+      def scan_regexp: () -> void
+
+      # @rbs () -> void
+      def scan_comment: () -> void
+
+      # @rbs () -> void
+      def scan_character_literal: () -> void
+
+      # @rbs () -> void
+      def scan_heredoc: () -> void
+
+      # @rbs () -> heredoc?
+      def heredoc_opener: () -> heredoc?
+
+      # @rbs (String prefix, String quote) -> [String, Integer]?
+      def quoted_heredoc_identifier: (String prefix, String quote) -> [ String, Integer ]?
+
+      # @rbs (String prefix) -> [String?, Integer]
+      def bare_heredoc_identifier: (String prefix) -> [ String?, Integer ]
+
+      # @rbs () -> void
+      def scan_pending_heredocs: () -> void
+
+      # @rbs (heredoc heredoc) -> void
+      def scan_heredoc_body: (heredoc heredoc) -> void
+    end
+  end
+end

data/sig/ibex/frontend/ast.rbs

@@ -0,0 +1,223 @@
+# Generated from lib/ibex/frontend/ast.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Grammar frontend node types.
+    module AST
+      type declaration = Tokens | Precedence | Options | Expect | Start | Convert
+
+      type item = SymbolReference | InlineAction | Optional | Star | Plus | Group | SeparatedList
+
+      type user_code = Hash[String, Array[UserCode]]
+
+      # Adds deterministic, recursively serializable hashes to Struct nodes.
+      # @rbs module-self Struct[untyped]
+      module Node : Struct[untyped]
+        def to_h: () -> untyped
+
+        private
+
+        def serialize: (untyped value) -> untyped
+      end
+
+      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location]
+        attr_accessor class_name(): String
+
+        attr_accessor superclass(): String?
+
+        attr_accessor declarations(): Array[declaration]
+
+        attr_accessor rules(): Array[Rule]
+
+        attr_accessor user_code(): user_code
+
+        attr_accessor loc(): Location
+
+        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location) -> instance
+                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location }) -> instance
+      end
+
+      class Tokens < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class Precedence < Struct[Symbol | Array[PrecedenceLevel] | Location]
+        attr_accessor direction(): Symbol
+
+        attr_accessor levels(): Array[PrecedenceLevel]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?direction: Symbol, ?levels: Array[PrecedenceLevel], ?loc: Location) -> instance
+                    | ({ ?direction: Symbol, ?levels: Array[PrecedenceLevel], ?loc: Location }) -> instance
+      end
+
+      class PrecedenceLevel < Struct[Symbol | Array[String] | Location]
+        attr_accessor associativity(): Symbol
+
+        attr_accessor symbols(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?associativity: Symbol, ?symbols: Array[String], ?loc: Location) -> instance
+                    | ({ ?associativity: Symbol, ?symbols: Array[String], ?loc: Location }) -> instance
+      end
+
+      class Options < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class Expect < Struct[Integer | Location]
+        attr_accessor conflicts(): Integer
+
+        attr_accessor loc(): Location
+
+        def self.new: (?conflicts: Integer, ?loc: Location) -> instance
+                    | ({ ?conflicts: Integer, ?loc: Location }) -> instance
+      end
+
+      class Start < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?loc: Location }) -> instance
+      end
+
+      class Convert < Struct[Array[Conversion] | Location]
+        attr_accessor pairs(): Array[Conversion]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?pairs: Array[Conversion], ?loc: Location) -> instance
+                    | ({ ?pairs: Array[Conversion], ?loc: Location }) -> instance
+      end
+
+      class Conversion < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor expression(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?expression: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?expression: String, ?loc: Location }) -> instance
+      end
+
+      class Rule < Struct[String | Array[Alternative] | Location]
+        attr_accessor lhs(): String
+
+        attr_accessor alternatives(): Array[Alternative]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?lhs: String, ?alternatives: Array[Alternative], ?loc: Location) -> instance
+                    | ({ ?lhs: String, ?alternatives: Array[Alternative], ?loc: Location }) -> instance
+      end
+
+      class Alternative < Struct[Array[item] | InlineAction? | String? | Location]
+        attr_accessor items(): Array[item]
+
+        attr_accessor action(): InlineAction?
+
+        attr_accessor precedence(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location) -> instance
+                    | ({ ?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location }) -> instance
+      end
+
+      class SymbolReference < Struct[String | String? | Location]
+        attr_accessor name(): String
+
+        attr_accessor named_reference(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?named_reference: String?, ?loc: Location) -> instance
+                    | ({ ?name: String, ?named_reference: String?, ?loc: Location }) -> instance
+      end
+
+      class InlineAction < Struct[String | Location]
+        attr_accessor code(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?code: String, ?loc: Location) -> instance
+                    | ({ ?code: String, ?loc: Location }) -> instance
+      end
+
+      class Optional < Struct[item | Location]
+        attr_accessor item(): item
+
+        attr_accessor loc(): Location
+
+        def self.new: (?item: item, ?loc: Location) -> instance
+                    | ({ ?item: item, ?loc: Location }) -> instance
+      end
+
+      class Star < Struct[item | Location]
+        attr_accessor item(): item
+
+        attr_accessor loc(): Location
+
+        def self.new: (?item: item, ?loc: Location) -> instance
+                    | ({ ?item: item, ?loc: Location }) -> instance
+      end
+
+      class Plus < Struct[item | Location]
+        attr_accessor item(): item
+
+        attr_accessor loc(): Location
+
+        def self.new: (?item: item, ?loc: Location) -> instance
+                    | ({ ?item: item, ?loc: Location }) -> instance
+      end
+
+      class Group < Struct[Array[Array[item]] | Location]
+        attr_accessor alternatives(): Array[Array[item]]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?alternatives: Array[Array[item]], ?loc: Location) -> instance
+                    | ({ ?alternatives: Array[Array[item]], ?loc: Location }) -> instance
+      end
+
+      class SeparatedList < Struct[item | bool | Location]
+        attr_accessor item(): item
+
+        attr_accessor separator(): item
+
+        attr_accessor nonempty(): bool
+
+        attr_accessor loc(): Location
+
+        def self.new: (?item: item, ?separator: item, ?nonempty: bool, ?loc: Location) -> instance
+                    | ({ ?item: item, ?separator: item, ?nonempty: bool, ?loc: Location }) -> instance
+      end
+
+      class UserCode < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor code(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?code: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?code: String, ?loc: Location }) -> instance
+      end
+    end
+  end
+end