rigortype 0.2.0 → 0.2.2

data/data/gem_overlay/activesupport/core_ext.rbs

@@ -0,0 +1,473 @@
+# ActiveSupport core_ext — Gemfile.lock-gated bundled RBS overlay (ADR-72).
+#
+# Rigor loads this overlay AUTOMATICALLY when `activesupport` is locked
+# in the project's Gemfile.lock but ships no RBS through any resolution
+# path (the `:missing` coverage class — no `rbs collection`, no bundled
+# `sig/`, not a default library). It turns the systematic false
+# `call.undefined-method` on Rails core-ext call sites (`3.minutes`,
+# `"x".underscore`, `hash.symbolize_keys`, …) into a no-op, while a
+# project WITHOUT activesupport still sees the genuine diagnostic.
+#
+# This is the auto-applied twin of the opt-in, hand-curated
+# `rigor-activesupport-core-ext` plugin (`plugins/rigor-activesupport-
+# core-ext/sig/active_support/core_ext.rbs`). The two files carry the
+# same surface on purpose; the plugin remains the authoring home and
+# may grow more exhaustive, and when its plugin id is loaded this
+# overlay stands down (Environment.for_project) to avoid a duplicate
+# declaration. Keep the two in sync when extending coverage.
+#
+# Scope: the most-frequently-flagged ActiveSupport extension methods
+# from a four-project Rails survey (Redmine, Discourse, Mastodon,
+# GitLab FOSS — see `docs/notes/20260515-real-world-rails-survey.md`),
+# roughly the top ~40 selectors by `call.undefined-method` frequency.
+# Not exhaustive.
+
+# ---------------------------------------------------------------
+# Object — universal predicates and helpers
+# ---------------------------------------------------------------
+
+class Object
+  # @return [bool]
+  def blank?: () -> bool
+
+  # @return [bool]
+  def present?: () -> bool
+
+  # @return [self?]
+  def presence: () -> self?
+
+  # `active_support/core_ext/object/json` monkey-patches
+  # `as_json` onto Object (default returns the object's
+  # `instance_values` hash) plus per-class overrides on
+  # NilClass / TrueClass / FalseClass / Numeric / String /
+  # Symbol / Time / Date / Array / Hash / Range / Regexp /
+  # Struct / Enumerable. Most call-site code uses the
+  # universal `obj.as_json` shape so a single Object row
+  # restores type coverage at the Mastodon-derived
+  # `as_json` call sites (`fan_out_on_write_service.rb`,
+  # `push_update_worker.rb`, `media_component_helper.rb`).
+  # `options` is the standard `only:` / `except:` / `methods:`
+  # / `include:` hash — left as untyped because the surface
+  # is large and per-call-site precision is rarely useful.
+  def as_json: (?untyped options) -> untyped
+
+  # `try` swallows NoMethodError; declared return is `untyped`
+  # because the called method's signature is not known to RBS
+  # at this call site.
+  def try: (Symbol | String) -> untyped
+         | (Symbol | String, *untyped) -> untyped
+         | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  def try!: (Symbol | String) -> untyped
+          | (Symbol | String, *untyped) -> untyped
+          | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
+  # is ActiveSupport's "duck-typing helper" predicate.
+  def acts_like?: (Symbol | String) -> bool
+end
+
+# `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
+# call sites the survey turned up.
+class NilClass
+  def blank?: () -> true
+  def present?: () -> false
+  def presence: () -> nil
+  def try: (*untyped) -> nil
+  def try!: (*untyped) -> nil
+end
+
+class TrueClass
+  def blank?: () -> false
+  def present?: () -> true
+end
+
+class FalseClass
+  def blank?: () -> true
+  def present?: () -> false
+end
+
+# ---------------------------------------------------------------
+# String — ActiveSupport `core_ext/string/*`
+# ---------------------------------------------------------------
+
+class String
+  # `core_ext/string/inflections`
+  def underscore: () -> String
+  def camelize: (?Symbol upper_case_first) -> String
+  def camelcase: (?Symbol upper_case_first) -> String
+  def classify: () -> String
+  def constantize: () -> untyped
+  def safe_constantize: () -> untyped
+  def demodulize: () -> String
+  def deconstantize: () -> String
+  def titleize: () -> String
+  def parameterize: (?separator: String, ?preserve_case: bool, ?locale: Symbol?) -> String
+  def tableize: () -> String
+  def foreign_key: (?bool separate_class_name_and_id_with_underscore) -> String
+  def pluralize: (?Integer count, ?Symbol locale) -> String
+  def singularize: (?Symbol locale) -> String
+  def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
+
+  # `core_ext/string/filters`
+  def squish: () -> String
+  def squish!: () -> String
+  def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
+  def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
+  def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+
+  # `core_ext/string/output_safety` — `html_safe` returns an
+  # `ActiveSupport::SafeBuffer` (a String subclass). The closest
+  # RBS-canonical carrier is plain `String`; precision lost is the
+  # `html_safe?` predicate value.
+  def html_safe: () -> String
+  def html_safe?: () -> bool
+
+  # `core_ext/string/indent`
+  def indent: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String
+  def indent!: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String?
+
+  # `core_ext/string/starts_ends_with` — also covered by core
+  # `start_with?` / `end_with?`; these are the ActiveSupport aliases.
+  def starts_with?: (*String prefixes) -> bool
+  def ends_with?: (*String suffixes) -> bool
+
+  # `core_ext/string/conversions` — `to_time` / `to_date` /
+  # `to_datetime` return Time / Date / DateTime.
+  def to_time: (?Symbol form) -> Time?
+  def to_date: () -> Date?
+  def to_datetime: () -> DateTime
+  def to_hours: () -> Float
+
+  # `core_ext/string/access`
+  def at: (Integer | Range[Integer] | Regexp position) -> String?
+  def from: (Integer position) -> String
+  def to: (Integer position) -> String
+  def first: (?Integer limit) -> String
+  def last: (?Integer limit) -> String
+
+  # `core_ext/string/strip` — leading-blank strip with shared margin.
+  def strip_heredoc: () -> String
+
+  # `core_ext/string/multibyte`
+  def mb_chars: () -> untyped
+
+  # `core_ext/string/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::StringInquirer
+
+  # `core_ext/string/exclude` (an ActiveSupport addition)
+  def exclude?: (String) -> bool
+end
+
+# ---------------------------------------------------------------
+# Integer — `core_ext/integer/*`
+# ---------------------------------------------------------------
+
+class Integer
+  # `core_ext/numeric/time` — Duration multipliers.
+  def second: () -> untyped # ActiveSupport::Duration
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def fortnight: () -> untyped
+  def fortnights: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  # `core_ext/numeric/bytes`
+  def byte: () -> Integer
+  def bytes: () -> Integer
+  def kilobyte: () -> Integer
+  def kilobytes: () -> Integer
+  def megabyte: () -> Integer
+  def megabytes: () -> Integer
+  def gigabyte: () -> Integer
+  def gigabytes: () -> Integer
+  def terabyte: () -> Integer
+  def terabytes: () -> Integer
+  def petabyte: () -> Integer
+  def petabytes: () -> Integer
+  def exabyte: () -> Integer
+  def exabytes: () -> Integer
+
+  # `core_ext/integer/multiple`
+  def multiple_of?: (Integer) -> bool
+
+  # `core_ext/integer/inflections`
+  def ordinal: () -> String
+  def ordinalize: () -> String
+end
+
+# ---------------------------------------------------------------
+# Float — same Duration / Bytes pattern as Integer
+# ---------------------------------------------------------------
+
+class Float
+  def second: () -> untyped
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  def byte: () -> Float
+  def bytes: () -> Float
+  def kilobyte: () -> Float
+  def kilobytes: () -> Float
+  def megabyte: () -> Float
+  def megabytes: () -> Float
+  def gigabyte: () -> Float
+  def gigabytes: () -> Float
+end
+
+# ---------------------------------------------------------------
+# Time — singleton + instance extensions
+# ---------------------------------------------------------------
+
+class Time
+  def self.current: () -> Time
+  def self.zone: () -> untyped # ActiveSupport::TimeZone | nil
+  def self.zone=: (String | Symbol | untyped) -> untyped
+
+  # `core_ext/time/conversions` — also `Time.parse` from stdlib
+  # `time`, which is already in core RBS.
+  def self.httpdate: (String) -> Time
+  def self.iso8601: (String) -> Time
+
+  # `core_ext/time/calculations`
+  def yesterday: () -> Time
+  def tomorrow: () -> Time
+  def beginning_of_day: () -> Time
+  def end_of_day: () -> Time
+  def beginning_of_hour: () -> Time
+  def end_of_hour: () -> Time
+  def beginning_of_minute: () -> Time
+  def end_of_minute: () -> Time
+  def beginning_of_week: (?Symbol start_day) -> Time
+  def end_of_week: (?Symbol start_day) -> Time
+  def beginning_of_month: () -> Time
+  def end_of_month: () -> Time
+  def beginning_of_year: () -> Time
+  def end_of_year: () -> Time
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def in: (Numeric seconds) -> Time
+  def change: (**untyped) -> Time
+  def at_beginning_of_day: () -> Time
+  def at_end_of_day: () -> Time
+  def at_beginning_of_week: () -> Time
+  def at_end_of_week: () -> Time
+  def at_midnight: () -> Time
+  def at_noon: () -> Time
+  def midday: () -> Time
+  def midnight: () -> Time
+  def noon: () -> Time
+  def utc?: () -> bool
+  def acts_like_time?: () -> true
+end
+
+# ---------------------------------------------------------------
+# Date — `core_ext/date/*`
+# ---------------------------------------------------------------
+
+class Date
+  def self.current: () -> Date
+  def self.yesterday: () -> Date
+  def self.tomorrow: () -> Date
+  def self.beginning_of_week: () -> Date
+  def self.end_of_week: () -> Date
+  def self.beginning_of_month: () -> Date
+  def self.end_of_month: () -> Date
+  def self.beginning_of_year: () -> Date
+  def self.end_of_year: () -> Date
+
+  def yesterday: () -> Date
+  def tomorrow: () -> Date
+  def beginning_of_week: (?Symbol start_day) -> Date
+  def end_of_week: (?Symbol start_day) -> Date
+  def beginning_of_month: () -> Date
+  def end_of_month: () -> Date
+  def beginning_of_year: () -> Date
+  def end_of_year: () -> Date
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def acts_like_date?: () -> true
+
+  # `core_ext/date/calculations` — `Date#midnight` /
+  # `Date#at_midnight` are aliases for `beginning_of_day`.
+  # Rails' `beginning_of_day` on Date returns a Time at
+  # midnight of that day (not a Date). Mastodon's
+  # `Date.current.at_midnight` shape relies on this.
+  def beginning_of_day: () -> Time
+  def midnight: () -> Time
+  def at_midnight: () -> Time
+  def at_beginning_of_day: () -> Time
+  def end_of_day: () -> Time
+  def at_end_of_day: () -> Time
+end
+
+# ---------------------------------------------------------------
+# Array — singleton wrapper + instance extensions
+# ---------------------------------------------------------------
+
+class Array[unchecked out Elem]
+  # `Array.wrap(x)` is the dominant Rails idiom: `nil → []`,
+  # `Array x → x`, `else → [x]`.
+  def self.wrap: (untyped) -> Array[untyped]
+
+  # `core_ext/array/access`
+  def from: (Integer position) -> Array[Elem]
+  def to: (Integer position) -> Array[Elem]
+  def second: () -> Elem?
+  def third: () -> Elem?
+  def fourth: () -> Elem?
+  def fifth: () -> Elem?
+  def forty_two: () -> Elem?
+
+  # `core_ext/array/grouping`
+  def in_groups_of: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+                  | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def in_groups: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+               | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def split: (?untyped value) -> Array[Array[Elem]]
+           | () { (Elem) -> bool } -> Array[Array[Elem]]
+
+  # `core_ext/array/conversions`
+  def to_sentence: (?two_words_connector: String, ?last_word_connector: String, ?words_connector: String, ?locale: Symbol?) -> String
+  def to_formatted_s: (?Symbol format) -> String
+  def to_fs: (?Symbol format) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/array/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::ArrayInquirer
+
+  # `core_ext/array/extract`
+  def extract!: () { (Elem) -> bool } -> Array[Elem]
+
+  # `core_ext/object/blank` / `core_ext/enumerable` — both
+  # ActiveSupport additions, shipped on Array specifically.
+  def compact_blank: () -> Array[Elem]
+  def compact_blank!: () -> self
+  def exclude?: (Elem) -> bool
+end
+
+# ---------------------------------------------------------------
+# Enumerable — `core_ext/enumerable`
+# ---------------------------------------------------------------
+
+module Enumerable[unchecked out Elem]
+  def index_by: () { (Elem) -> untyped } -> Hash[untyped, Elem]
+  def index_with: (?untyped default) { (Elem) -> untyped } -> Hash[Elem, untyped]
+                | (untyped default) -> Hash[Elem, untyped]
+  def exclude?: (Elem) -> bool
+  def including: (*Elem) -> Array[Elem]
+  def excluding: (*Elem) -> Array[Elem]
+  def without: (*Elem) -> Array[Elem]
+  def pluck: (Symbol | String) -> Array[untyped]
+           | (*Symbol | String) -> Array[Array[untyped]]
+  def pick: (Symbol | String) -> untyped
+          | (*Symbol | String) -> Array[untyped]?
+  def maximum: (Symbol | String) -> untyped
+  def minimum: (Symbol | String) -> untyped
+  def sole: () -> Elem
+  def compact_blank: () -> Array[Elem]
+end
+
+# ---------------------------------------------------------------
+# Hash — `core_ext/hash/*`
+# ---------------------------------------------------------------
+
+class Hash[unchecked out K, unchecked out V]
+  # `core_ext/hash/keys`
+  def symbolize_keys: () -> Hash[Symbol, V]
+  def symbolize_keys!: () -> self
+  def deep_symbolize_keys: () -> Hash[untyped, untyped]
+  def deep_symbolize_keys!: () -> self
+  def stringify_keys: () -> Hash[String, V]
+  def stringify_keys!: () -> self
+  def deep_stringify_keys: () -> Hash[untyped, untyped]
+  def deep_stringify_keys!: () -> self
+  def assert_valid_keys: (*K | Array[K]) -> self
+  def deep_transform_keys: () { (K) -> K } -> Hash[K, untyped]
+  def deep_transform_keys!: () { (K) -> K } -> self
+  def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
+  def deep_transform_values!: () { (V) -> untyped } -> self
+
+  # `core_ext/hash/deep_dup`
+  def deep_dup: () -> Hash[K, V]
+
+  # `core_ext/hash/deep_merge`
+  def deep_merge: (Hash[K, V]) -> Hash[K, V]
+                | (Hash[K, V]) { (K, V, V) -> V } -> Hash[K, V]
+  def deep_merge!: (Hash[K, V]) -> self
+                 | (Hash[K, V]) { (K, V, V) -> V } -> self
+
+  # `core_ext/hash/except` — `Hash#except` is in core RBS as of
+  # Ruby 3.0+; `except!` is ActiveSupport-only. ActiveSupport
+  # also aliases `Hash#without` to `Hash#except`, used by
+  # `Mastodon`-shaped `options.without('type').merge(...)` chains.
+  def except!: (*K) -> self
+  def without: (*K) -> Hash[K, V]
+
+  # `core_ext/hash/conversions`
+  def to_query: (?String namespace) -> String
+  def to_param: (?String namespace) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/hash/indifferent_access`
+  def with_indifferent_access: () -> untyped
+
+  # `core_ext/hash/conversions`
+  def self.from_xml: (String, ?Symbol disallowed_types) -> Hash[String, untyped]
+  def self.from_trusted_xml: (String) -> Hash[String, untyped]
+
+  # `core_ext/object/blank` / `core_ext/hash`
+  def compact_blank: () -> Hash[K, V]
+  def compact_blank!: () -> self
+
+  # `core_ext/hash/reverse_merge`
+  def reverse_merge: (Hash[K, V]) -> Hash[K, V]
+  def reverse_merge!: (Hash[K, V]) -> self
+
+  # `core_ext/hash/slice` — `Hash#except` is in core RBS (Ruby 3.0+);
+  # `Hash#slice` is in core RBS (Ruby 2.5+); the bang variants are
+  # ActiveSupport-only.
+  def slice!: (*K) -> Hash[K, V]
+end
+
+# ---------------------------------------------------------------
+# DateTime — `core_ext/date_time/*`
+# ---------------------------------------------------------------
+
+class DateTime
+  def utc: () -> Time
+  def to_time: () -> Time
+  def in_time_zone: (?String | Symbol zone) -> untyped
+  def yesterday: () -> DateTime
+  def tomorrow: () -> DateTime
+  def ago: (Numeric seconds) -> DateTime
+  def since: (Numeric seconds) -> DateTime
+  def beginning_of_day: () -> DateTime
+  def end_of_day: () -> DateTime
+  def beginning_of_hour: () -> DateTime
+  def end_of_hour: () -> DateTime
+  def beginning_of_minute: () -> DateTime
+  def end_of_minute: () -> DateTime
+  def acts_like_time?: () -> true
+end

data/data/vendored_gem_sigs/ast/ast.rbs

@@ -0,0 +1,130 @@
+# Hand-authored by Rigor maintainers. See LICENSE.upstream.
+#
+# Covers AST::Node, AST::Processor::Mixin, AST::Processor, and
+# AST::Sexp from the `ast` gem (whitequark/ast v2.4.3).
+#
+# Design notes (ADR-5 robustness principle):
+#  - `children` is `Array[untyped]` — AST node children are
+#    heterogeneous (other Nodes, Symbols, Integers, Strings, nils).
+#  - `#==` / `#eql?` accept `untyped` — `#==` calls `to_ast` on the
+#    argument and `#eql?` does a class + field equality check.
+#  - `#updated` returns `AST::Node`, not `instance`, because concrete
+#    subclasses (Parser::AST::Node) override `initialize` via
+#    `original_dup` + `send(:initialize, ...)`, so the return type is
+#    always an instance of `self.class` at runtime — widening to
+#    `AST::Node` is the safe upper bound Rigor can check against.
+#  - `AST::Processor::Mixin#process` returns `AST::Node?` — the method
+#    returns `nil` when given `nil`, and handlers may return `nil` to
+#    preserve the original node (then `process` returns the original).
+
+module AST
+  # Immutable AST node. The type and children are set at construction
+  # and the object is frozen. Subclasses add metadata (e.g. source
+  # location) via `#assign_properties`.
+  class Node
+    # Returns the node type (e.g. `:send`, `:begin`, `:int`).
+    attr_reader type: Symbol
+
+    # Returns the (frozen) children array. Elements are heterogeneous:
+    # either other AST::Node instances or plain Ruby values (Symbol,
+    # Integer, String, nil, …).
+    attr_reader children: Array[untyped]
+
+    # Precomputed hash based on type, children, and class.
+    attr_reader hash: Integer
+
+    # Constructs a new Node. `type` is coerced with `to_sym`;
+    # `children` is coerced with `to_a` and then frozen.
+    def initialize: (untyped type, ?untyped children, ?untyped properties) -> void
+
+    # Equality ignores metadata; only type and children are compared.
+    def ==: (untyped other) -> bool
+
+    # Structural equality (type, children, and class must match).
+    def eql?: (untyped other) -> bool
+
+    # Returns a new Node with non-nil arguments replacing the
+    # corresponding fields. If the result would be identical to self,
+    # returns self unchanged.
+    def updated: (?Symbol? type, ?Array[untyped]? children, ?Hash[Symbol, untyped]? properties) -> AST::Node
+
+    # Concatenates `array` with children and returns a new node.
+    def concat: (Array[untyped] array) -> AST::Node
+
+    # Alias for `concat`.
+    def +: (Array[untyped] array) -> AST::Node
+
+    # Appends `element` to children and returns a new node.
+    def append: (untyped element) -> AST::Node
+
+    # Alias for `append`.
+    def <<: (untyped element) -> AST::Node
+
+    # Alias for `children`.
+    def to_a: () -> Array[untyped]
+
+    # Returns self — nodes are already frozen.
+    def dup: () -> AST::Node
+
+    # Alias for `dup`.
+    def clone: () -> AST::Node
+
+    # Returns self — satisfies the `to_ast` protocol.
+    def to_ast: () -> AST::Node
+
+    # Pretty-printed s-expression string.
+    def to_sexp: (?Integer indent) -> String
+
+    # Alias for `to_sexp`.
+    def to_s: (?Integer indent) -> String
+
+    # Ruby-source s-expression string (uses `s(:type, ...)` notation).
+    def inspect: (?Integer indent) -> String
+
+    # Converts to `[type, *children_as_sexp_arrays]` recursively.
+    def to_sexp_array: () -> Array[untyped]
+
+    # Pattern-match support: `[type, *children]`.
+    def deconstruct: () -> Array[untyped]
+
+    # Assigns entries from `properties` as instance variables.
+    # Protected in Ruby; declared here without visibility for RBS
+    # compatibility (RBS does not support `protected` on class members).
+    def assign_properties: (Hash[Symbol, untyped] properties) -> nil
+
+    # Returns the type with underscores replaced by dashes.
+    def fancy_type: () -> String
+
+    # The original unfrozen `dup` kept for use in `#updated`.
+    private def original_dup: () -> AST::Node
+  end
+
+  # The processor mixin provides a node-dispatch framework. Mix into a
+  # class and define `on_<type>` handlers; unhandled nodes fall through
+  # to `#handler_missing`.
+  module Processor::Mixin
+    # Dispatches `node` to the appropriate `on_<type>` handler.
+    # Returns the handler's return value if non-nil, otherwise the
+    # original `node`. Returns `nil` when `node` is `nil`.
+    def process: (AST::Node? node) -> AST::Node?
+
+    # Processes each node in `nodes` and returns the array of results.
+    def process_all: (Array[AST::Node?] nodes) -> Array[AST::Node?]
+
+    # Default handler for unrecognised node types. Does nothing and
+    # returns `nil`, which causes `#process` to return the node unchanged.
+    def handler_missing: (AST::Node node) -> nil
+  end
+
+  # Deprecated superclass. Prefer `include AST::Processor::Mixin`.
+  class Processor
+    include AST::Processor::Mixin
+  end
+
+  # Mixin providing the `s(type, *children)` shorthand for building
+  # nodes in tests or DSLs.
+  module Sexp
+    # Creates an AST::Node with the given type and children.
+    def s: (Symbol type, *untyped children) -> AST::Node
+  end
+end

data/data/vendored_gem_sigs/bcrypt/bcrypt.rbs

@@ -0,0 +1,47 @@
+module BCrypt
+  class Password < String
+    attr_reader checksum: String
+    attr_reader salt: String
+    attr_reader version: String
+    attr_reader cost: Integer
+    def self.create: (_ToS secret, {cost: _ToI} options) -> BCrypt::Password
+    def self.valid_hash?: (String h) -> bool
+    def initialize: (String raw_hash) -> void
+    def ==: (_ToS secret) -> bool
+    alias is_password? ==
+  end
+
+  class Engine
+    DEFAULT_COST: Integer
+    MIN_COST: Integer
+    MAX_COST: Integer
+    MAX_SECRET_BYTESIZE: Integer
+    MAX_SALT_LENGTH: Integer
+
+    def self.cost: () -> Integer
+    def self.cost=: (Integer cost) -> Integer
+    def self.hash_secret: (_ToS secret, String salt, ?untyped _) -> String
+    def self.generate_salt: (?_ToI cost) -> String
+    def self.valid_salt?: (String salt) -> bool
+    def self.valid_secret?: (Object secret) -> bool
+    def self.calibrate: (Numeric upper_time_limit_in_ms) -> Integer
+    def self.autodetect_cost: (String salt) -> Integer
+  end
+
+  class Error < StandardError
+  end
+
+  module Errors
+    class InvalidSalt < Error
+    end
+
+    class InvalidHash < Error
+    end
+
+    class InvalidCost < Error
+    end
+
+    class InvalidSecret < Error
+    end
+  end
+end