rigortype 0.2.0 → 0.2.2

data/data/vendored_gem_sigs/bundler/bundler.rbs

@@ -0,0 +1,238 @@
+#
+# Rigor-side vendored RBS stub for the `bundler` gem.
+#
+# The `bundler` gem does not ship its own `sig/` and is not
+# covered by `ruby/gem_rbs_collection`. The shim in
+# `references/rbs/sig/shims/bundler.rbs` (rbs gem upstream)
+# carries a tiny subset (`LockfileParser`, `LazySpecification`,
+# `Dependency`, `Definition`, `default_lockfile`, `definition`,
+# `Source::Gemspec`) but is only loaded when the user opts in via
+# `library "bundler"` — that's rare in Rigor `.rigor.yml` setups,
+# so most projects analyse bundler-using code with NO `Bundler`
+# RBS in scope.
+#
+# This stub covers the Bundler module's top-25 singleton methods
+# surfaced by the `references/ruby/lib` survey
+# (`docs/CURRENT_WORK.md`), plus the handful of class-level
+# entries (`Definition`, `LockfileParser`, `LazySpecification`,
+# `Dependency`, `ConfigFile`, `Settings`, `UI`) that downstream
+# Rigor users routinely touch. Most return types are `untyped`
+# because Bundler's surface is dynamic / opaque; the goal is to
+# silence `call.undefined-method` rather than infer precise
+# returns.
+#
+# Declarations are intentionally a SUPERSET of the
+# `references/rbs/sig/shims/bundler.rbs` shim. When the user
+# opts into `library "bundler"`, the shim's typed declarations
+# (`LockfileParser#specs -> Array[LazySpecification]`, etc.)
+# would conflict; users who want both should drop the
+# `library "bundler"` entry from their config so this vendored
+# stub wins.
+#
+module Bundler
+  # `Bundler.<name>` — accessors / module-level entry points.
+  # Return types: `untyped` unless the surface is documented and
+  # widely-used (`bundle_path` -> Pathname).
+  def self.configure: () -> untyped
+  def self.ui: () -> untyped
+  def self.ui=: (untyped) -> untyped
+  def self.bundle_path: () -> Pathname
+  def self.create_bundle_path: () -> Pathname
+  def self.configured_bundle_path: () -> untyped
+  def self.bin_path: () -> Pathname
+  def self.setup: (*untyped groups) -> untyped
+  def self.auto_switch: () -> untyped
+  def self.auto_install: () -> untyped
+  def self.require: (*untyped groups) -> untyped
+  def self.load: () -> untyped
+  def self.environment: () -> untyped
+  def self.definition: (?untyped unlock, ?untyped lockfile) -> Definition
+  def self.frozen_bundle?: () -> bool
+  def self.locked_gems: () -> untyped
+  def self.ruby_scope: () -> String
+  def self.user_home: () -> Pathname
+  def self.user_bundle_path: (?untyped dir) -> Pathname
+  def self.user_cache: () -> Pathname
+  def self.home: () -> Pathname
+  def self.install_path: () -> Pathname
+  def self.specs_path: () -> Pathname
+  def self.root: () -> Pathname
+  def self.app_config_path: () -> Pathname
+  def self.app_cache: (?untyped custom_path) -> Pathname
+  def self.tmp: (?untyped name) -> Pathname
+  def self.rm_rf: (untyped path) -> untyped
+  def self.settings: () -> untyped
+  def self.original_env: () -> Hash[String, String]
+  def self.clean_env: () -> Hash[String, String]
+  def self.unbundled_env: () -> Hash[String, String]
+  def self.unbundle_env!: () -> untyped
+  def self.with_original_env: () { () -> untyped } -> untyped
+  def self.with_clean_env: () { () -> untyped } -> untyped
+  def self.with_unbundled_env: () { () -> untyped } -> untyped
+  def self.original_system: (*untyped) -> untyped
+  def self.clean_system: (*untyped) -> untyped
+  def self.unbundled_system: (*untyped) -> untyped
+  def self.original_exec: (*untyped) -> untyped
+  def self.clean_exec: (*untyped) -> untyped
+  def self.unbundled_exec: (*untyped) -> untyped
+  def self.local_platform: () -> untyped
+  def self.generic_local_platform: () -> untyped
+  def self.default_gemfile: () -> Pathname
+  def self.default_lockfile: () -> Pathname
+  def self.default_bundle_dir: () -> Pathname?
+  def self.system_bindir: () -> String?
+  def self.preferred_gemfile_name: () -> String
+  def self.use_system_gems?: () -> bool
+  def self.rubygems: () -> untyped
+  def self.which: (untyped) -> String?
+  def self.load_gemspec: (untyped path, ?bool validate) -> untyped
+  def self.read_file: (untyped path) -> String
+  def self.safe_load_marshal: (untyped data) -> untyped
+  def self.git_present?: () -> bool
+  def self.gem_version: () -> Gem::Version
+  def self.verbose_version: () -> String
+  def self.self_manager: () -> untyped
+  def self.reset!: () -> void
+
+  # Top-level classes touched in real-world bundler / rubygems
+  # code paths the survey analysed. Each class declares only the
+  # most-used members; the rest fall through to `untyped`-typed
+  # singleton-class dispatch via the surrounding module's
+  # untyped return contracts.
+  class Definition
+    def self.build: (untyped gemfile, untyped lockfile, untyped unlock) -> Definition
+
+    def initialize: (*untyped) -> void
+    def gemfiles: () -> Array[Pathname]
+    def lockfile: () -> Pathname
+    def lockfile=: (untyped) -> untyped
+    def locked_gems: () -> LockfileParser
+    def dependencies: () -> Array[Dependency]
+    def current_dependencies: () -> Array[Dependency]
+    def requested_dependencies: () -> Array[Dependency]
+    def dependencies_for: (untyped groups) -> Array[Dependency]
+    def specs: () -> untyped
+    def specs_for: (untyped groups) -> untyped
+    def missing_specs: () -> untyped
+    def validate_runtime!: () -> untyped
+    def check!: () -> untyped
+    def lock: (?untyped) -> untyped
+    def write_lock: () -> untyped
+    def to_lock: () -> String
+    def resolve: () -> untyped
+    def resolve_with_cache!: () -> untyped
+    def resolve_remotely!: () -> untyped
+    def remotely!: () -> untyped
+    def ensure_equivalent_gemfile_and_lockfile: (?bool) -> untyped
+    def normalize_platforms: () -> untyped
+    def platforms: () -> Array[untyped]
+    def add_platform: (untyped) -> untyped
+    def remove_platform: (untyped) -> untyped
+    def add_checksums: () -> untyped
+    def groups: () -> Array[Symbol]
+    def ruby_version: () -> untyped
+  end
+
+  class LockfileParser
+    def initialize: (String body) -> void
+    def specs: () -> Array[LazySpecification]
+    def platforms: () -> Array[untyped]
+    def sources: () -> Array[untyped]
+    def dependencies: () -> Array[Dependency]
+    def ruby_version: () -> untyped
+    def bundler_version: () -> untyped
+  end
+
+  class LazySpecification
+    def name: () -> String
+    def version: () -> Gem::Version
+    def platform: () -> untyped
+    def dependencies: () -> Array[Gem::Dependency]
+    def source: () -> untyped
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+    attr_reader source: untyped
+    attr_reader groups: Array[Symbol]
+    attr_reader platforms: Array[Symbol]
+  end
+
+  class ConfigFile
+    def []: (*untyped) -> untyped
+    def []=: (*untyped) -> untyped
+    def set_global: (untyped, untyped) -> untyped
+    def set_local: (untyped, untyped) -> untyped
+    def all: () -> Hash[String, untyped]
+  end
+
+  module Source
+    class Gemspec
+      def initialize: (*untyped) -> void
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+
+    class Path
+      def initialize: (*untyped) -> void
+      attr_accessor name: String?
+      attr_accessor version: String?
+      attr_accessor path: String?
+    end
+
+    class Git
+      def initialize: (*untyped) -> void
+      attr_accessor uri: String?
+      attr_accessor branch: String?
+      attr_accessor ref: String?
+      attr_accessor submodules: bool
+      attr_accessor glob: String?
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+
+    class Rubygems
+      def initialize: (*untyped) -> void
+      attr_accessor remotes: Array[String]
+      attr_accessor name: String?
+      attr_accessor version: String?
+    end
+  end
+
+  module UI
+    class Shell
+      def initialize: (?untyped) -> void
+      def info: (untyped, ?bool newline) -> void
+      def confirm: (untyped, ?bool newline) -> void
+      def warn: (untyped, ?bool newline) -> void
+      def debug: (untyped, ?bool newline) -> void
+      def debug?: () -> bool
+      def error: (untyped, ?bool newline) -> void
+      def trace: (untyped, ?untyped newline, ?bool force) -> void
+      def silence: () { () -> untyped } -> untyped
+      def ask: (untyped) -> String?
+      def yes?: (untyped) -> bool
+      def no?: () -> bool
+      def level: (?String name) -> String
+      def level=: (untyped) -> untyped
+      def quiet?: () -> bool
+      def quiet=: (bool) -> bool
+    end
+
+    class RGProxy
+      def initialize: (?untyped) -> void
+    end
+  end
+
+  class GemfileError < StandardError
+  end
+
+  class GemfileNotFound < StandardError
+  end
+
+  class LockfileError < StandardError
+  end
+
+  class GemNotFound < StandardError
+  end
+end

data/data/vendored_gem_sigs/cgi/cgi_extras.rbs

@@ -0,0 +1,34 @@
+#
+# Rigor-side supplement to the rbs gem's
+# `stdlib/cgi/0/core.rbs` declarations.
+#
+# Re-opens `class CGI` to bring in the instance methods that
+# real-world Ruby code calls on a CGI instance: `params`,
+# `params=`, `cookies`, `cookies=`, `multipart?`, `query_string`,
+# the parsed-request bits.
+#
+# Why this isn't already in the upstream RBS: at runtime
+# `CGI#initialize` does `extend CGI::QueryExtension`, which
+# attaches the methods to each instance via singleton-class
+# inheritance. The static-RBS surface can't represent
+# per-instance `extend` calls. Declaring `class CGI; include
+# CGI::QueryExtension; end` here is a deliberate
+# over-approximation that matches the real surface every CGI
+# instance you actually use (you got it from `CGI.new`) has.
+#
+# Driven by the tdiary-core survey
+# (`docs/notes/20260519-oss-library-survey.md`) where
+# `lib/tdiary/core_ext.rb:62`'s `cgi.params['key']` /
+# `self.params[param]` surfaced as `undefined method 'params'
+# for CGI` (3 errors per call site, 6 total).
+#
+# Adds new declarations only — never redeclares anything the
+# upstream RBS already covers, so the loader does not raise
+# `RBS::DuplicatedDeclarationError`. `include` is permitted
+# because the upstream `class CGI` declaration already does
+# `include CGI::Util` + `extend CGI::Util`; adding a sibling
+# `include CGI::QueryExtension` is purely additive.
+#
+class CGI
+  include CGI::QueryExtension
+end

data/data/vendored_gem_sigs/did_you_mean/did_you_mean_extras.rbs

@@ -0,0 +1,34 @@
+#
+# Rigor-side supplement to the rbs gem's
+# `stdlib/did_you_mean/0/did_you_mean.rbs` declarations.
+#
+# Re-opens `module DidYouMean` to add the top-level singleton
+# methods the upstream RBS omits — every method below is defined
+# in `lib/did_you_mean.rb` and called by rubygems / bundler /
+# optparse / thor without an RBS declaration to back it.
+#
+# Adds new declarations only; never redeclares anything the
+# upstream RBS already covers, so the loader does not raise
+# `RBS::DuplicatedDeclarationError`.
+#
+module DidYouMean
+  # Sharable hash of error-class names to spell-checker objects.
+  # Defaults to `Hash.new(NullChecker)` — the value's runtime
+  # default makes any missing-key lookup return `NullChecker`.
+  def self.spell_checkers: () -> Hash[String, untyped]
+
+  # `correct_error(error_class, spell_checker)` registers a
+  # spell-checker for the named error class, prepending
+  # `Correctable` to it when the class doesn't already include
+  # it. Returns the registered spell_checker (the assignment's
+  # value).
+  def self.correct_error: (untyped error_class, untyped spell_checker) -> untyped
+
+  # The active formatter. Returns the per-Ractor override when
+  # one is set; otherwise `DidYouMean::Formatter` (the module).
+  def self.formatter: () -> untyped
+
+  # Per-Ractor formatter override. Returns the assigned
+  # formatter under Ractor; nil otherwise.
+  def self.formatter=: (untyped) -> untyped
+end

data/data/vendored_gem_sigs/idn-ruby/idn.rbs

@@ -0,0 +1,54 @@
+# Minimal hand-authored RBS stub for the `idn-ruby` gem
+# (libidn binding for Internationalised Domain Names).
+#
+# `idn-ruby` is not in `ruby/gem_rbs_collection` as of 2026-05-15.
+# Authorship: hand-written by Rigor maintainers based on the
+# upstream README (https://github.com/idnruby/idn-ruby).
+
+module IDN
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class Stringprep
+    class StringprepError < IDN::Error
+    end
+
+    NAMEPREP: String
+    ISCSIPREP: String
+    NODEPREP: String
+    RESOURCEPREP: String
+    PLAIN: String
+    TRACE: String
+    SASLPREP: String
+
+    def self.with_profile: (String profile, String input) -> String
+    def self.nameprep: (String input) -> String
+    def self.iscsiprep: (String input) -> String
+    def self.nodeprep: (String input) -> String
+    def self.resourceprep: (String input) -> String
+    def self.plain: (String input) -> String
+    def self.trace: (String input) -> String
+    def self.saslprep: (String input) -> String
+  end
+
+  class Punycode
+    class PunycodeError < IDN::Error
+    end
+
+    def self.encode: (String input) -> String
+    def self.decode: (String input) -> String
+  end
+
+  class Idna
+    class IdnaError < IDN::Error
+    end
+
+    ALLOW_UNASSIGNED: Integer
+    USE_STD3_ASCII_RULES: Integer
+
+    def self.toASCII: (String input, ?Integer flags) -> String
+    def self.toUnicode: (String input, ?Integer flags) -> String
+  end
+end

data/data/vendored_gem_sigs/mysql2/client.rbs

@@ -0,0 +1,55 @@
+module Mysql2
+  class Client[ResultType]
+    MULTI_STATEMENTS: Integer
+
+    self.@default_query_options: untyped
+
+    @read_timeout: untyped
+
+    @query_options: untyped
+
+    attr_reader query_options: untyped
+
+    attr_reader read_timeout: untyped
+
+    def self.default_query_options: () -> untyped
+
+    def initialize: (Hash[(String | Symbol), untyped] opts) -> void
+
+    def self.new: (as: :hash, **untyped) -> Mysql2::Client[Mysql2::ResultAsHash]
+                | (as: :array, **untyped) -> Mysql2::Client[Mysql2::ResultAsArray]
+                | (as: Symbol, **untyped) -> Mysql2::Client[Mysql2::ResultAsHash | Mysql2::ResultAsArray]
+                | (**untyped) -> Mysql2::Client[Mysql2::ResultAsHash]
+
+    def parse_ssl_mode: (untyped mode) -> untyped
+
+    def parse_flags_array: (untyped flags, ?::Integer initial) -> untyped
+
+    # Find any default system CA paths to handle system roots
+    # by default if stricter validation is requested and no
+    # path is provide.
+    def find_default_ca_path: () -> untyped
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs: (untyped conn_attrs) -> (::Hash[untyped, untyped] | untyped)
+
+    def query: (String sql, as: :hash, **untyped) -> ResultAsHash
+             | (String sql, as: :array, **untyped) -> ResultAsArray
+             | (String sql, **untyped) -> ResultType
+
+    def query_info: () -> (::Hash[untyped, untyped] | untyped)
+
+    def info: () -> untyped
+
+    def last_id: () -> Integer
+
+    def affected_rows: () -> Integer
+
+    def prepare: (String sql) -> Mysql2::Statement
+
+    private
+
+    def self.local_offset: () -> untyped
+  end
+end

data/data/vendored_gem_sigs/mysql2/error.rbs

@@ -0,0 +1,5 @@
+module Mysql2
+  class Error < StandardError
+    attr_reader error_number: Integer
+  end
+end

data/data/vendored_gem_sigs/mysql2/result.rbs

@@ -0,0 +1,31 @@
+module Mysql2
+  type row_value_type = String | Integer | BigDecimal | Float | Time | Date | nil
+
+  class ResultAsHash
+    attr_reader server_flags: untyped
+
+    # NOTE:
+    #   The type of key is controlled by `symbolize_keys` option of `Mysql2::Client.new`.
+    #   It can be expressed using a type argument such as `Client[ResultType]`,
+    #   but since the state becomes complicated. So `String | Symbol` is allowed.
+    type key_type = String | Symbol
+
+    include Enumerable[Hash[key_type, row_value_type]]
+
+    def each: () { (Hash[key_type, row_value_type]) -> void } -> void
+    def count: () -> Integer
+    def to_a: () -> Array[untyped]
+    alias size count
+  end
+
+  class ResultAsArray
+    attr_reader server_flags: untyped
+
+    include Enumerable[Array[row_value_type]]
+
+    def each: () { (Array[row_value_type]) -> void } -> void
+    def count: () -> Integer
+    def to_a: () -> Array[untyped]
+    alias size count
+  end
+end

data/data/vendored_gem_sigs/mysql2/statement.rbs

@@ -0,0 +1,5 @@
+module Mysql2
+  class Statement
+    def execute: (*untyped, **untyped) -> (Mysql2::ResultAsHash | Mysql2::ResultAsArray)
+  end
+end