orthoses-rails 0.1.0 → 0.4.0

data/examples/rails/patch/minitest/minitest/benchmark.rbs

@@ -0,0 +1,258 @@
+# <!-- rdoc-file=lib/minitest/benchmark.rb -->
+# Subclass Benchmark to create your own benchmark runs. Methods starting with
+# "bench_" get executed on a per-class.
+#
+# See Minitest::Assertions
+#
+class Minitest::Benchmark < ::Minitest::Test
+  def self.io: () -> untyped
+  def io: () -> untyped
+  def self.run: (untyped reporter, ?::Hash[untyped, untyped] options) -> untyped
+  def self.runnable_methods: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_exp(min, max, base = 10)
+  # -->
+  # Returns a set of ranges stepped exponentially from `min` to `max` by powers of
+  # `base`. Eg:
+  #
+  #     bench_exp(2, 16, 2) # => [2, 4, 8, 16]
+  #
+  def self.bench_exp: (untyped min, untyped max, ?::Integer base) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_linear(min, max, step = 10)
+  # -->
+  # Returns a set of ranges stepped linearly from `min` to `max` by `step`. Eg:
+  #
+  #     bench_linear(20, 40, 10) # => [20, 30, 40]
+  #
+  def self.bench_linear: (untyped min, untyped max, ?::Integer step) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - bench_range()
+  # -->
+  # Specifies the ranges used for benchmarking for that class. Defaults to
+  # exponential growth from 1 to 10k by powers of 10. Override if you need
+  # different ranges for your benchmarks.
+  #
+  # See also: ::bench_exp and ::bench_linear.
+  #
+  def self.bench_range: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance(validation, &work)
+  # -->
+  # Runs the given `work`, gathering the times of each run. Range and times are
+  # then passed to a given `validation` proc. Outputs the benchmark name and times
+  # in tab-separated format, making it easy to paste into a spreadsheet for
+  # graphing or further analysis.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       validation = proc { |x, y| ... }
+  #       assert_performance validation do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def assert_performance: (untyped validation) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance_constant(threshold = 0.99, &work)
+  # -->
+  # Runs the given `work` and asserts that the times gathered fit to match a
+  # constant rate (eg, linear slope == 0) within a given `threshold`. Note:
+  # because we're testing for a slope of 0, R^2 is not a good determining factor
+  # for the fit, so the threshold is applied against the slope itself. As such,
+  # you probably want to tighten it from the default.
+  #
+  # See
+  # https://www.graphpad.com/guides/prism/8/curve-fitting/reg_intepretingnonlinr2.
+  # htm for more details.
+  #
+  # Fit is calculated by #fit_linear.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       assert_performance_constant 0.9999 do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def assert_performance_constant: (?::Float threshold) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance_exponential(threshold = 0.99, &work)
+  # -->
+  # Runs the given `work` and asserts that the times gathered fit to match a
+  # exponential curve within a given error `threshold`.
+  #
+  # Fit is calculated by #fit_exponential.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       assert_performance_exponential 0.9999 do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def assert_performance_exponential: (?::Float threshold) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance_logarithmic(threshold = 0.99, &work)
+  # -->
+  # Runs the given `work` and asserts that the times gathered fit to match a
+  # logarithmic curve within a given error `threshold`.
+  #
+  # Fit is calculated by #fit_logarithmic.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       assert_performance_logarithmic 0.9999 do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def assert_performance_logarithmic: (?::Float threshold) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance_linear(threshold = 0.99, &work)
+  # -->
+  # Runs the given `work` and asserts that the times gathered fit to match a
+  # straight line within a given error `threshold`.
+  #
+  # Fit is calculated by #fit_linear.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       assert_performance_linear 0.9999 do |n|
+  #         @obj.algorithm(n)
+  #       end
+  #     end
+  #
+  def assert_performance_linear: (?::Float threshold) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - assert_performance_power(threshold = 0.99, &work)
+  # -->
+  # Runs the given `work` and asserts that the times gathered curve fit to match a
+  # power curve within a given error `threshold`.
+  #
+  # Fit is calculated by #fit_power.
+  #
+  # Ranges are specified by ::bench_range.
+  #
+  # Eg:
+  #
+  #     def bench_algorithm
+  #       assert_performance_power 0.9999 do |x|
+  #         @obj.algorithm
+  #       end
+  #     end
+  #
+  def assert_performance_power: (?::Float threshold) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - fit_error(xys) { |x| ... }
+  # -->
+  # Takes an array of x/y pairs and calculates the general R^2 value.
+  #
+  # See: http://en.wikipedia.org/wiki/Coefficient_of_determination
+  #
+  def fit_error: (untyped xys) { (untyped) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - fit_exponential(xs, ys)
+  # -->
+  # To fit a functional form: y = ae^(bx).
+  #
+  # Takes x and y values and returns [a, b, r^2].
+  #
+  # See: http://mathworld.wolfram.com/LeastSquaresFittingExponential.html
+  #
+  def fit_exponential: (untyped xs, untyped ys) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - fit_logarithmic(xs, ys)
+  # -->
+  # To fit a functional form: y = a + b*ln(x).
+  #
+  # Takes x and y values and returns [a, b, r^2].
+  #
+  # See: http://mathworld.wolfram.com/LeastSquaresFittingLogarithmic.html
+  #
+  def fit_logarithmic: (untyped xs, untyped ys) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - fit_linear(xs, ys)
+  # -->
+  # Fits the functional form: a + bx.
+  #
+  # Takes x and y values and returns [a, b, r^2].
+  #
+  # See: http://mathworld.wolfram.com/LeastSquaresFitting.html
+  #
+  def fit_linear: (untyped xs, untyped ys) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - fit_power(xs, ys)
+  # -->
+  # To fit a functional form: y = ax^b.
+  #
+  # Takes x and y values and returns [a, b, r^2].
+  #
+  # See: http://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
+  #
+  def fit_power: (untyped xs, untyped ys) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - sigma(enum, &block)
+  # -->
+  # Enumerates over `enum` mapping `block` if given, returning the sum of the
+  # result. Eg:
+  #
+  #     sigma([1, 2, 3])                # => 1 + 2 + 3 => 6
+  #     sigma([1, 2, 3]) { |n| n ** 2 } # => 1 + 4 + 9 => 14
+  #
+  def sigma: (untyped enum) { () -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/benchmark.rb
+  #   - validation_for_fit(msg, threshold)
+  # -->
+  # Returns a proc that calls the specified fit method and asserts that the error
+  # is within a tolerable threshold.
+  #
+  def validation_for_fit: (untyped msg, untyped threshold) -> untyped
+end

data/examples/rails/patch/minitest/minitest/composite_reporter.rbs

@@ -0,0 +1,25 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Dispatch to multiple reporters as one.
+#
+class Minitest::CompositeReporter < ::Minitest::AbstractReporter
+  def initialize: (*untyped reporters) -> void
+  def io: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - <<(reporter)
+  # -->
+  # Add another reporter to the mix.
+  #
+  def <<: (untyped reporter) -> untyped
+  def passed?: () -> untyped
+  def start: () -> untyped
+  def prerecord: (untyped klass, untyped name) -> untyped
+  def record: (untyped result) -> untyped
+  def report: () -> untyped
+
+  # <!-- rdoc-file=lib/minitest.rb -->
+  # The list of reporters to dispatch to.
+  #
+  attr_accessor reporters: untyped
+end

data/examples/rails/patch/minitest/minitest/expectations.rbs

@@ -0,0 +1,21 @@
+# <!-- rdoc-file=lib/minitest/expectations.rb -->
+# It's where you hide your "assertions".
+#
+# Please note, because of the way that expectations are implemented, all
+# expectations (eg must_equal) are dependent upon a thread local variable
+# `:current_spec`. If your specs rely on mixing threads into the specs
+# themselves, you're better off using assertions or the new _(value) wrapper.
+# For example:
+#
+#     it "should still work in threads" do
+#       my_threaded_thingy do
+#         (1+1).must_equal 2                  # bad
+#         assert_equal 2, 1+1                 # good
+#         _(1 + 1).must_equal 2               # good
+#         value(1 + 1).must_equal 2           # good, also #expect
+#         _ { 1 + "1" }.must_raise TypeError  # good
+#       end
+#     end
+#
+module Minitest::Expectations
+end

data/examples/rails/patch/minitest/minitest/guard.rbs

@@ -0,0 +1,64 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# Provides a simple set of guards that you can use in your tests to skip
+# execution if it is not applicable. These methods are mixed into Test as both
+# instance and class methods so you can use them inside or outside of the test
+# methods.
+#
+#     def test_something_for_mri
+#       skip "bug 1234"  if jruby?
+#       # ...
+#     end
+#
+#     if windows? then
+#       # ... lots of test methods ...
+#     end
+#
+module Minitest::Guard
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - jruby?(platform = RUBY_PLATFORM)
+  # -->
+  # Is this running on jruby?
+  #
+  def jruby?: (?untyped platform) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - maglev?(platform = defined?(RUBY_ENGINE) && RUBY_ENGINE)
+  # -->
+  # Is this running on maglev?
+  #
+  def maglev?: (?untyped platform) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - mri?(platform = RUBY_DESCRIPTION)
+  # -->
+  # Is this running on mri?
+  #
+  def mri?: (?untyped platform) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - osx?(platform = RUBY_PLATFORM)
+  # -->
+  # Is this running on macOS?
+  #
+  def osx?: (?untyped platform) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - rubinius?(platform = defined?(RUBY_ENGINE) && RUBY_ENGINE)
+  # -->
+  # Is this running on rubinius?
+  #
+  def rubinius?: (?untyped platform) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest.rb
+  #   - windows?(platform = RUBY_PLATFORM)
+  # -->
+  # Is this running on windows?
+  #
+  def windows?: (?untyped platform) -> untyped
+end

data/examples/rails/patch/minitest/minitest/mock.rbs

@@ -0,0 +1,60 @@
+# <!-- rdoc-file=lib/minitest/mock.rb -->
+# A simple and clean mock object framework.
+#
+# All mock objects are an instance of Mock
+#
+class Minitest::Mock
+  alias __respond_to? respond_to?
+  def initialize: (?untyped? delegator) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest/mock.rb
+  #   - expect(name, retval, args = [], &blk)
+  # -->
+  # Expect that method `name` is called, optionally with `args` or a `blk`, and
+  # returns `retval`.
+  #
+  #     @mock.expect(:meaning_of_life, 42)
+  #     @mock.meaning_of_life # => 42
+  #
+  #     @mock.expect(:do_something_with, true, [some_obj, true])
+  #     @mock.do_something_with(some_obj, true) # => true
+  #
+  #     @mock.expect(:do_something_else, true) do |a1, a2|
+  #       a1 == "buggs" && a2 == :bunny
+  #     end
+  #
+  # `args` is compared to the expected args using case equality (ie, the '==='
+  # operator), allowing for less specific expectations.
+  #
+  #     @mock.expect(:uses_any_string, true, [String])
+  #     @mock.uses_any_string("foo") # => true
+  #     @mock.verify  # => true
+  #
+  #     @mock.expect(:uses_one_string, true, ["foo"])
+  #     @mock.uses_one_string("bar") # => raises MockExpectationError
+  #
+  # If a method will be called multiple times, specify a new expect for each one.
+  # They will be used in the order you define them.
+  #
+  #     @mock.expect(:ordinal_increment, 'first')
+  #     @mock.expect(:ordinal_increment, 'second')
+  #
+  #     @mock.ordinal_increment # => 'first'
+  #     @mock.ordinal_increment # => 'second'
+  #     @mock.ordinal_increment # => raises MockExpectationError "No more expects available for :ordinal_increment"
+  #
+  def expect: (untyped name, untyped retval, ?untyped args) { () -> untyped } -> self
+  def __call: (untyped name, untyped data) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/mock.rb
+  #   - verify()
+  # -->
+  # Verify that all methods were called as expected. Raises `MockExpectationError`
+  # if the mock object was not called as expected.
+  #
+  def verify: () -> true
+  def method_missing: (untyped sym, *untyped args) { () -> untyped } -> untyped
+  def respond_to?: (untyped sym, ?bool include_private) -> (true | untyped)
+end

data/examples/rails/patch/minitest/minitest/parallel/executor.rbs

@@ -0,0 +1,42 @@
+# <!-- rdoc-file=lib/minitest/parallel.rb -->
+# The engine used to run multiple tests in parallel.
+#
+class Minitest::Parallel::Executor
+  # <!--
+  #   rdoc-file=lib/minitest/parallel.rb
+  #   - new(size)
+  # -->
+  # Create a parallel test executor of with `size` workers.
+  #
+  def initialize: (untyped size) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest/parallel.rb
+  #   - start()
+  # -->
+  # Start the executor
+  #
+  def start: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/parallel.rb
+  #   - <<(work;)
+  # -->
+  # Add a job to the queue
+  #
+  def <<: (untyped work) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/parallel.rb
+  #   - shutdown()
+  # -->
+  # Shuts down the pool of workers by signalling them to quit and waiting for them
+  # all to finish what they're currently working on.
+  #
+  def shutdown: () -> untyped
+
+  # <!-- rdoc-file=lib/minitest/parallel.rb -->
+  # The size of the pool of workers.
+  #
+  attr_reader size: untyped
+end

data/examples/rails/patch/minitest/minitest/parallel/test/class_methods.rbs

@@ -0,0 +1,6 @@
+module Minitest::Parallel::Test::ClassMethods
+  # :nodoc:
+  def run_one_method: (untyped klass, untyped method_name, untyped reporter) -> untyped
+
+  def test_order: () -> :parallel
+end

data/examples/rails/patch/minitest/minitest/parallel/test.rbs

@@ -0,0 +1,3 @@
+module Minitest::Parallel::Test
+  def _synchronize: () { () -> untyped } -> untyped
+end

data/examples/rails/patch/minitest/minitest/parallel.rbs

@@ -0,0 +1,2 @@
+module Minitest::Parallel
+end

data/examples/rails/patch/minitest/minitest/pride_io.rbs

@@ -0,0 +1,54 @@
+# <!-- rdoc-file=lib/minitest/pride_plugin.rb -->
+# Show your testing pride!
+#
+class Minitest::PrideIO
+  # <!--
+  #   rdoc-file=lib/minitest/pride_plugin.rb
+  #   - pride!()
+  # -->
+  # Activate the pride plugin. Called from both -p option and minitest/pride
+  #
+  def self.pride!: () -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/pride_plugin.rb
+  #   - pride?()
+  # -->
+  # Are we showing our testing pride?
+  #
+  def self.pride?: () -> untyped
+  def initialize: (untyped io) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest/pride_plugin.rb
+  #   - print(o)
+  # -->
+  # Wrap print to colorize the output.
+  #
+  def print: (untyped o) -> untyped
+  def puts: (*untyped o) -> untyped
+
+  # <!--
+  #   rdoc-file=lib/minitest/pride_plugin.rb
+  #   - pride(string)
+  # -->
+  # Color a string.
+  #
+  def pride: (untyped string) -> ::String
+  def method_missing: (untyped msg, *untyped args) -> untyped
+
+  # <!-- rdoc-file=lib/minitest/pride_plugin.rb -->
+  # The IO we're going to pipe through.
+  #
+  attr_reader io: untyped
+
+  # <!-- rdoc-file=lib/minitest/pride_plugin.rb -->
+  # End the escape sequence
+  #
+  NND: String
+
+  # <!-- rdoc-file=lib/minitest/pride_plugin.rb -->
+  # Start an escape sequence
+  #
+  ESC: String
+end

data/examples/rails/patch/minitest/minitest/pride_lol.rbs

@@ -0,0 +1,17 @@
+# <!-- rdoc-file=lib/minitest/pride_plugin.rb -->
+# If you thought the PrideIO was colorful...
+#
+# (Inspired by lolcat, but with clean math)
+#
+class Minitest::PrideLOL < ::Minitest::PrideIO
+  def initialize: (untyped io) -> void
+
+  # <!--
+  #   rdoc-file=lib/minitest/pride_plugin.rb
+  #   - pride(string)
+  # -->
+  # Make the string even more colorful. Damnit.
+  #
+  def pride: (untyped string) -> ::String
+  PI_3: Float
+end

data/examples/rails/patch/minitest/minitest/progress_reporter.rbs

@@ -0,0 +1,11 @@
+# <!-- rdoc-file=lib/minitest.rb -->
+# A very simple reporter that prints the "dots" during 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::ProgressReporter < ::Minitest::Reporter
+  def prerecord: (untyped klass, untyped name) -> (untyped | nil)
+  def record: (untyped result) -> untyped
+end

data/examples/rails/patch/minitest/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/examples/rails/patch/minitest/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/examples/rails/patch/minitest/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