rbs 2.5.1 → 2.6.0

data/stdlib/minitest/0/minitest/reportable.rbs

@@ -0,0 +1,51 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Shared code for anything that can get passed to a Reporter. See Minitest::Test
+# & Minitest::Result.
+#
+module Minitest::Reportable
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - passed?()
+  # -->
+  # Did this run pass?
+  #
+  # Note: skipped runs are not considered passing, but they don't cause the
+  # process to exit non-zero.
+  #
+  def passed?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - location()
+  # -->
+  # The location identifier of this test. Depends on a method existing called
+  # class_name.
+  #
+  def location: () -> ::String
+
+  def class_name: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - result_code()
+  # -->
+  # Returns ".", "F", or "E" based on the result of the run.
+  #
+  def result_code: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - skipped?()
+  # -->
+  # Was this run skipped?
+  #
+  def skipped?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - error?()
+  # -->
+  # Did this run error?
+  #
+  def error?: () -> untyped
+end

data/stdlib/minitest/0/minitest/reporter.rbs

@@ -0,0 +1,5 @@
+class Minitest::Reporter < ::Minitest::AbstractReporter
+  def initialize: (?untyped io, ?::Hash[untyped, untyped] options) -> void
+  attr_accessor io: untyped
+  attr_accessor options: untyped
+end

data/stdlib/minitest/0/minitest/result.rbs

@@ -0,0 +1,28 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# This represents a test result in a clean way that can be marshalled over a
+# wire. Tests can do anything they want to the test instance and can create
+# conditions that cause Marshal.dump to blow up. By using Result.from(a_test)
+# you can be reasonably sure that the test result can be marshalled.
+#
+class Minitest::Result < ::Minitest::Runnable
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - from(runnable)
+  # -->
+  # Create a new test result from a Runnable instance.
+  #
+  def self.from: (untyped runnable) -> untyped
+  def class_name: () -> untyped
+  def to_s: () -> untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # The class name of the test result.
+  #
+  attr_accessor klass: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # The location of the test method.
+  #
+  attr_accessor source_location: untyped
+  include Minitest::Reportable
+end

data/stdlib/minitest/0/minitest/runnable.rbs

@@ -0,0 +1,131 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Represents anything "runnable", like Test, Spec, Benchmark, or whatever you
+# can dream up.
+#
+# Subclasses of this are automatically registered and available in
+# Runnable.runnables.
+#
+class Minitest::Runnable
+  def time_it: () { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - name()
+  # -->
+  # Name of the run.
+  #
+  def name: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - name=(o)
+  # -->
+  # Set the name of the run.
+  #
+  def name=: (untyped o) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - methods_matching(re)
+  # -->
+  # Returns all instance methods matching the pattern `re`.
+  #
+  def self.methods_matching: (untyped re) -> untyped
+  def self.reset: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - run(reporter, options = {})
+  # -->
+  # Responsible for running all runnable methods in a given class, each in its own
+  # instance. Each instance is passed to the reporter to record.
+  #
+  def self.run: (untyped reporter, ?::Hash[untyped, untyped] options) -> (nil | untyped)
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - run_one_method(klass, method_name, reporter)
+  # -->
+  # Runs a single method and has the reporter record the result. This was
+  # considered internal API but is factored out of run so that subclasses can
+  # specialize the running of an individual test. See
+  # Minitest::ParallelTest::ClassMethods for an example.
+  #
+  def self.run_one_method: (untyped klass, untyped method_name, untyped reporter) -> untyped
+  def self.with_info_handler: (untyped reporter) ?{ () -> untyped } -> untyped
+  def self.on_signal: (untyped name, untyped action) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - runnable_methods()
+  # -->
+  # Each subclass of Runnable is responsible for overriding this method to return
+  # all runnable methods. See #methods_matching.
+  #
+  def self.runnable_methods: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - runnables()
+  # -->
+  # Returns all subclasses of Runnable.
+  #
+  def self.runnables: () -> untyped
+  def marshal_dump: () -> ::Array[untyped]
+  def marshal_load: (untyped ary) -> untyped
+  def failure: () -> untyped
+  def initialize: (untyped name) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - run()
+  # -->
+  # Runs a single method. Needs to return self.
+  #
+  def run: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - passed?()
+  # -->
+  # Did this run pass?
+  #
+  # Note: skipped runs are not considered passing, but they don't cause the
+  # process to exit non-zero.
+  #
+  def passed?: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - result_code()
+  # -->
+  # Returns a single character string to print based on the result of the run. One
+  # of `"."`, `"F"`, `"E"` or `"S"`.
+  #
+  def result_code: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - skipped?()
+  # -->
+  # Was this run skipped? See #passed? for more information.
+  #
+  def skipped?: () -> untyped
+  def self.inherited: (untyped klass) -> untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Number of assertions executed in this run.
+  #
+  attr_accessor assertions: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # An assertion raised during the run, if any.
+  #
+  attr_accessor failures: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # The time it took to run.
+  #
+  attr_accessor time: untyped
+  SIGNALS: Hash[String, Integer]
+end

data/stdlib/minitest/0/minitest/skip.rbs

@@ -0,0 +1,6 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Assertion raised when skipping a run.
+#
+class Minitest::Skip < ::Minitest::Assertion
+  def result_label: () -> "Skipped"
+end

data/stdlib/minitest/0/minitest/spec/dsl/instance_methods.rbs

@@ -0,0 +1,48 @@
+# <!-- rdoc-file=lib/minitest/spec.rb -->
+# Rdoc... why are you so dumb?
+#
+module Minitest::Spec::DSL::InstanceMethods
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - _(value = nil, &block)
+  # -->
+  # Takes a value or a block and returns a value monad that has all of
+  # Expectations methods available to it.
+  #
+  #     _(1 + 1).must_equal 2
+  #
+  # And for blocks:
+  #
+  #     _ { 1 + "1" }.must_raise TypeError
+  #
+  # This method of expectation-based testing is preferable to straight-expectation
+  # methods (on Object) because it stores its test context, bypassing our hacky
+  # use of thread-local variables.
+  #
+  # NOTE: At some point, the methods on Object will be deprecated and then
+  # removed.
+  #
+  # It is also aliased to #value and #expect for your aesthetic pleasure:
+  #
+  #          _(1 + 1).must_equal 2
+  #      value(1 + 1).must_equal 2
+  #     expect(1 + 1).must_equal 2
+  #
+  def _: (?untyped? value) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - value(value = nil, &block)
+  # -->
+  #
+  alias value _
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - expect(value = nil, &block)
+  # -->
+  #
+  alias expect _
+
+  def before_setup: () -> untyped
+end

data/stdlib/minitest/0/minitest/spec/dsl.rbs

@@ -0,0 +1,125 @@
+# <!-- rdoc-file=lib/minitest/spec.rb -->
+# Oh look! A Minitest::Spec::DSL module! Eat your heart out DHH.
+#
+module Minitest::Spec::DSL
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - register_spec_type(*args, &block)
+  # -->
+  # Register a new type of spec that matches the spec's description. This method
+  # can take either a Regexp and a spec class or a spec class and a block that
+  # takes the description and returns true if it matches.
+  #
+  # Eg:
+  #
+  #     register_spec_type(/Controller$/, Minitest::Spec::Rails)
+  #
+  # or:
+  #
+  #     register_spec_type(Minitest::Spec::RailsModel) do |desc|
+  #       desc.superclass == ActiveRecord::Base
+  #     end
+  #
+  def register_spec_type: (*untyped args) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - spec_type(desc, *additional)
+  # -->
+  # Figure out the spec class to use based on a spec's description. Eg:
+  #
+  #     spec_type("BlahController") # => Minitest::Spec::Rails
+  #
+  def spec_type: (untyped desc, *untyped additional) -> untyped
+
+  def describe_stack: () -> untyped
+
+  def children: () -> untyped
+
+  def nuke_test_methods!: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - before(_type = nil, &block)
+  # -->
+  # Define a 'before' action. Inherits the way normal methods should.
+  #
+  # NOTE: `type` is ignored and is only there to make porting easier.
+  #
+  # Equivalent to Minitest::Test#setup.
+  #
+  def before: (?untyped? _type) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - after(_type = nil, &block)
+  # -->
+  # Define an 'after' action. Inherits the way normal methods should.
+  #
+  # NOTE: `type` is ignored and is only there to make porting easier.
+  #
+  # Equivalent to Minitest::Test#teardown.
+  #
+  def after: (?untyped? _type) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - it(desc = "anonymous", &block)
+  # -->
+  # Define an expectation with name `desc`. Name gets morphed to a proper test
+  # method name. For some freakish reason, people who write specs don't like class
+  # inheritance, so this goes way out of its way to make sure that expectations
+  # aren't inherited.
+  #
+  # This is also aliased to #specify and doesn't require a `desc` arg.
+  #
+  # Hint: If you *do* want inheritance, use minitest/test. You can mix and match
+  # between assertions and expectations as much as you want.
+  #
+  def it: (?::String desc) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - let(name, &block)
+  # -->
+  # Essentially, define an accessor for `name` with `block`.
+  #
+  # Why use let instead of def? I honestly don't know.
+  #
+  def let: (untyped name) ?{ () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - subject(&block)
+  # -->
+  # Another lazy man's accessor generator. Made even more lazy by setting the name
+  # for you to `subject`.
+  #
+  def subject: () ?{ () -> untyped } -> untyped
+
+  def create: (untyped name, untyped desc) -> untyped
+
+  def name: () -> untyped
+
+  def to_s: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/spec.rb
+  #   - specify(desc = "anonymous", &block)
+  # -->
+  #
+  alias specify it
+
+  def self.extended: (untyped obj) -> untyped
+
+  attr_reader desc: untyped
+
+  # <!-- rdoc-file=lib/minitest/spec.rb -->
+  # Contains pairs of matchers and Spec classes to be used to calculate the
+  # superclass of a top-level describe. This allows for automatically customizable
+  # spec types.
+  #
+  # See: register_spec_type and spec_type
+  #
+  TYPES: Array[Array[Regexp | singleton(Minitest::BenchSpec)] | Array[Regexp | singleton(Minitest::Spec)]]
+end

data/stdlib/minitest/0/minitest/spec.rbs

@@ -0,0 +1,11 @@
+# <!-- rdoc-file=lib/minitest/spec.rb -->
+# Minitest::Spec -- The faster, better, less-magical spec framework!
+#
+# For a list of expectations, see Minitest::Expectations.
+#
+class Minitest::Spec < ::Minitest::Test
+  def self.current: () -> untyped
+  def initialize: (untyped name) -> void
+  include Minitest::Spec::DSL::InstanceMethods
+  extend Minitest::Spec::DSL
+end

data/stdlib/minitest/0/minitest/statistics_reporter.rbs

@@ -0,0 +1,76 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# A reporter that gathers statistics about a test run. Does not do any IO
+# because meant to be used as a parent class for a reporter that does.
+#
+# If you want to create an entirely different type of output (eg, CI, HTML,
+# etc), this is the place to start.
+#
+# Example:
+#
+#     class JenkinsCIReporter < StatisticsReporter
+#       def report
+#         super  # Needed to calculate some statistics
+#
+#         print "<testsuite "
+#         print "tests='#{count}' "
+#         print "failures='#{failures}' "
+#         # Remaining XML...
+#       end
+#     end
+#
+class Minitest::StatisticsReporter < ::Minitest::Reporter
+  def initialize: (?untyped io, ?::Hash[untyped, untyped] options) -> void
+  def passed?: () -> untyped
+  def start: () -> untyped
+  def record: (untyped result) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - report()
+  # -->
+  # Report on the tracked statistics.
+  #
+  def report: () -> untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Total number of assertions.
+  #
+  attr_accessor assertions: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Total number of test cases.
+  #
+  attr_accessor count: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # An `Array` of test cases that failed or were skipped.
+  #
+  attr_accessor results: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Time the test run started. If available, the monotonic clock is used and this
+  # is a `Float`, otherwise it's an instance of `Time`.
+  #
+  attr_accessor start_time: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Test run time. If available, the monotonic clock is used and this is a
+  # `Float`, otherwise it's an instance of `Time`.
+  #
+  attr_accessor total_time: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Total number of tests that failed.
+  #
+  attr_accessor failures: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Total number of tests that erred.
+  #
+  attr_accessor errors: untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # Total number of tests that where skipped.
+  #
+  attr_accessor skips: untyped
+end

data/stdlib/minitest/0/minitest/summary_reporter.rbs

@@ -0,0 +1,25 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# A reporter that prints the header, summary, and failure details at the end of
+# the run.
+#
+# This is added to the top-level CompositeReporter at the start of the run. If
+# you want to change the output of minitest via a plugin, pull this out of the
+# composite and replace it with your own.
+#
+class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
+  def start: () -> untyped
+  def report: () -> untyped
+  def statistics: () -> untyped
+  def aggregated_results: (untyped io) -> untyped
+  def to_s: () -> untyped
+  def summary: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - binary_string()
+  # -->
+  #
+  private def binary_string: () -> untyped
+  attr_accessor sync: untyped
+  attr_accessor old_sync: untyped
+end

data/stdlib/minitest/0/minitest/test/lifecycle_hooks.rbs

@@ -0,0 +1,92 @@
+# <!-- rdoc-file=lib/minitest/test.rb -->
+# Provides before/after hooks for setup and teardown. These are meant for
+# library writers, NOT for regular test authors. See #before_setup for an
+# example.
+#
+module Minitest::Test::LifecycleHooks
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - before_setup()
+  # -->
+  # Runs before every test, before setup. This hook is meant for libraries to
+  # extend minitest. It is not meant to be used by test developers.
+  #
+  # As a simplistic example:
+  #
+  #     module MyMinitestPlugin
+  #       def before_setup
+  #         super
+  #         # ... stuff to do before setup is run
+  #       end
+  #
+  #       def after_setup
+  #         # ... stuff to do after setup is run
+  #         super
+  #       end
+  #
+  #       def before_teardown
+  #         super
+  #         # ... stuff to do before teardown is run
+  #       end
+  #
+  #       def after_teardown
+  #         # ... stuff to do after teardown is run
+  #         super
+  #       end
+  #     end
+  #
+  #     class MiniTest::Test
+  #       include MyMinitestPlugin
+  #     end
+  #
+  def before_setup: () -> nil
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - setup()
+  # -->
+  # Runs before every test. Use this to set up before each test run.
+  #
+  def setup: () -> nil
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - after_setup()
+  # -->
+  # Runs before every test, after setup. This hook is meant for libraries to
+  # extend minitest. It is not meant to be used by test developers.
+  #
+  # See #before_setup for an example.
+  #
+  def after_setup: () -> nil
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - before_teardown()
+  # -->
+  # Runs after every test, before teardown. This hook is meant for libraries to
+  # extend minitest. It is not meant to be used by test developers.
+  #
+  # See #before_setup for an example.
+  #
+  def before_teardown: () -> nil
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - teardown()
+  # -->
+  # Runs after every test. Use this to clean up after each test run.
+  #
+  def teardown: () -> nil
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - after_teardown()
+  # -->
+  # Runs after every test, after teardown. This hook is meant for libraries to
+  # extend minitest. It is not meant to be used by test developers.
+  #
+  # See #before_setup for an example.
+  #
+  def after_teardown: () -> nil
+end

data/stdlib/minitest/0/minitest/test.rbs

@@ -0,0 +1,76 @@
+# <!-- rdoc-file=lib/minitest/test.rb -->
+# Subclass Test to create your own tests. Typically you'll want a Test subclass
+# per implementation class.
+#
+# See Minitest::Assertions
+#
+class Minitest::Test < ::Minitest::Runnable
+  def class_name: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - i_suck_and_my_tests_are_order_dependent!()
+  # -->
+  # Call this at the top of your tests when you absolutely positively need to have
+  # ordered tests. In doing so, you're admitting that you suck and your tests are
+  # weak.
+  #
+  def self.i_suck_and_my_tests_are_order_dependent!: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - make_my_diffs_pretty!()
+  # -->
+  # Make diffs for this Test use #pretty_inspect so that diff in assert_equal can
+  # have more details. NOTE: this is much slower than the regular inspect but much
+  # more usable for complex objects.
+  #
+  def self.make_my_diffs_pretty!: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - parallelize_me!()
+  # -->
+  # Call this at the top of your tests when you want to run your tests in
+  # parallel. In doing so, you're admitting that you rule and your tests are
+  # awesome.
+  #
+  def self.parallelize_me!: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - runnable_methods()
+  # -->
+  # Returns all instance methods starting with "test_". Based on #test_order, the
+  # methods are either sorted, randomized (default), or run in parallel.
+  #
+  def self.runnable_methods: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - test_order()
+  # -->
+  # Defines the order to run tests (:random by default). Override this or use a
+  # convenience method to change it for your tests.
+  #
+  def self.test_order: () -> :random
+
+  # <!--
+  #   rdoc-file=lib/minitest/test.rb
+  #   - run()
+  # -->
+  # Runs a single test with setup/teardown hooks.
+  #
+  def run: () -> untyped
+  def capture_exceptions: () { () -> untyped } -> untyped
+  def sanitize_exception: (untyped e) -> untyped
+  def with_info_handler: () ?{ () -> untyped } -> untyped
+  attr_accessor self.io_lock: untyped
+  include Minitest::Assertions
+  include Minitest::Reportable
+  include Minitest::Test::LifecycleHooks
+  include Minitest::Guard
+  extend Minitest::Guard
+  TEARDOWN_METHODS: Array[String]
+  PASSTHROUGH_EXCEPTIONS: Array[singleton(NoMemoryError) | singleton(SignalException) | singleton(SystemExit)]
+end

data/stdlib/minitest/0/minitest/unexpected_error.rbs

@@ -0,0 +1,10 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Assertion wrapping an unexpected error that was raised during a run.
+#
+class Minitest::UnexpectedError < ::Minitest::Assertion
+  def initialize: (untyped error) -> void
+  def backtrace: () -> untyped
+  def message: () -> ::String
+  def result_label: () -> "Error"
+  attr_accessor error: untyped
+end

data/stdlib/minitest/0/minitest/unit/test_case.rbs

@@ -0,0 +1,3 @@
+class Minitest::Unit::TestCase < ::Minitest::Test
+  def self.inherited: (untyped klass) -> untyped
+end