sorbet-struct-comparable 1.0.0 → 1.1.0

data/sorbet/rbi/gems/rspec-expectations.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi
 #
-# rspec-expectations-3.9.2
+# rspec-expectations-3.10.1
 
 module RSpec
 end
@@ -337,6 +337,9 @@ class RSpec::Expectations::Configuration
   def on_potential_false_positives; end
   def on_potential_false_positives=(behavior); end
   def reset_syntaxes_to_default; end
+  def strict_predicate_matchers; end
+  def strict_predicate_matchers=(flag); end
+  def strict_predicate_matchers?; end
   def syntax; end
   def syntax=(values); end
   def warn_about_potential_false_positives=(boolean); end
@@ -354,14 +357,14 @@ module RSpec::Expectations::ExpectationHelper
   def self.with_matcher(handler, matcher, message); end
 end
 class RSpec::Expectations::PositiveExpectationHandler
-  def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
+  def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
   def self.opposite_should_method; end
   def self.should_method; end
   def self.verb; end
 end
 class RSpec::Expectations::NegativeExpectationHandler
   def self.does_not_match?(matcher, actual, &block); end
-  def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
+  def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end
   def self.opposite_should_method; end
   def self.should_method; end
   def self.verb; end
@@ -388,12 +391,15 @@ class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations
   def aggregation_block_label; end
   def aggregation_metadata; end
   def all_exceptions; end
+  def backtrace_line(line); end
   def block_description; end
   def enumerated(exceptions, index_offset); end
   def enumerated_errors; end
   def enumerated_failures; end
   def exception_count_description; end
+  def exclusion_patterns; end
   def failures; end
+  def format_backtrace(backtrace); end
   def indentation; end
   def indented(failure_message, index); end
   def index_label(index); end
@@ -545,31 +551,44 @@ class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
 end
 class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
   def description; end
+  def does_not_match?(actual); end
   def failure_message; end
   def failure_message_when_negated; end
   def initialize(operand, operator); end
   def matches?(actual); end
+  def perform_match(actual); end
   include RSpec::Matchers::BuiltIn::BeHelpers
 end
-class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::BaseMatcher
+class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher
   def description; end
   def does_not_match?(actual, &block); end
+  def expectation_of(value); end
   def failure_message; end
   def failure_message_expecting(value); end
   def failure_message_when_negated; end
-  def initialize(*args, &block); end
+  def failure_to_respond_explanation; end
+  def initialize(method_name, *args, &block); end
   def matches?(actual, &block); end
-  def parse_expected(expected); end
-  def predicate; end
+  def method_description; end
   def predicate_accessible?; end
-  def predicate_matches?; end
-  def prefix_and_expected(symbol); end
-  def prefix_to_sentence; end
-  def present_tense_predicate; end
+  def predicate_matches?(value = nil); end
+  def predicate_method_name; end
+  def predicate_result; end
   def private_predicate?; end
+  def root; end
   def validity_message; end
   include RSpec::Matchers::BuiltIn::BeHelpers
 end
+class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate
+  def predicate; end
+end
+class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate
+  def failure_to_respond_explanation; end
+  def predicate; end
+  def predicate_accessible?; end
+  def predicate_method_name; end
+  def present_tense_predicate; end
+end
 class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
   def description; end
   def failure_message; end
@@ -815,23 +834,6 @@ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_2
   def valid_test?; end
   def validity_message; end
 end
-class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::BaseMatcher
-  def args_description; end
-  def description; end
-  def does_not_match?(actual, &block); end
-  def failure_message; end
-  def failure_message_args_description; end
-  def failure_message_when_negated; end
-  def initialize(method_name, *args, &block); end
-  def matches?(actual, &block); end
-  def method_description; end
-  def predicate; end
-  def predicate_accessible?; end
-  def predicate_exists?; end
-  def predicate_matches?; end
-  def private_predicate?; end
-  def validity_message; end
-end
 class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
   def actual; end
   def actual_has_attribute?(attribute_key, attribute_value); end
@@ -850,13 +852,40 @@ class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseM
   def respond_to_failure_message_or; end
   def respond_to_matcher; end
 end
+module RSpec::Matchers::BuiltIn::CountExpectation
+  def at_least(number); end
+  def at_most(number); end
+  def count_constraint_to_number(n); end
+  def count_expectation_description; end
+  def count_expectation_type; end
+  def count_failure_reason(action); end
+  def cover?(count, number); end
+  def exactly(number); end
+  def expected_count; end
+  def expected_count_matches?(actual_count); end
+  def has_expected_count?; end
+  def human_readable_count(count); end
+  def human_readable_expectation_type; end
+  def once; end
+  def raise_impossible_count_expectation(count); end
+  def raise_unsupported_count_expectation; end
+  def set_expected_count(relativity, n); end
+  def thrice; end
+  def times; end
+  def twice; end
+  def unsupported_count_expectation?(relativity); end
+end
 class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
   def actual_collection_includes?(expected_item); end
   def actual_hash_has_key?(expected_key); end
   def actual_hash_includes?(expected_key, expected_value); end
+  def check_actual?(actual); end
+  def check_expected_count?; end
   def comparing_hash_keys?(expected_item); end
   def comparing_hash_to_a_subset?(expected_item); end
   def convert_to_hash?(obj); end
+  def count_enumerable(expected_item); end
+  def count_inclusions; end
   def description; end
   def diff_would_wrongly_highlight_matched_item?; end
   def diffable?; end
@@ -869,8 +898,9 @@ class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
   def format_failure_message(preposition); end
   def initialize(*expecteds); end
   def matches?(actual); end
-  def perform_match(actual, &block); end
+  def perform_match(&block); end
   def readable_list_of(items); end
+  include RSpec::Matchers::BuiltIn::CountExpectation
 end
 class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
   def add_new_line_if_needed(message); end
@@ -987,17 +1017,19 @@ class RSpec::Matchers::BuiltIn::RaiseError
   def format_backtrace(backtrace); end
   def given_error; end
   def handle_warning(message); end
-  def initialize(expected_error_or_message = nil, expected_message = nil, &block); end
+  def initialize(expected_error_or_message, expected_message, &block); end
   def matches?(given_proc, negative_expectation = nil, &block); end
   def raise_message_already_set; end
   def ready_to_eval_block?; end
   def supports_block_expectations?; end
   def verify_message; end
-  def warn_about_bare_error; end
-  def warn_about_negative_false_positive(expression); end
-  def warn_for_false_positives; end
+  def warn_about_bare_error!; end
+  def warn_about_bare_error?; end
+  def warn_about_negative_false_positive!(expression); end
+  def warn_about_nil_error!; end
+  def warn_about_nil_error?; end
+  def warn_for_negative_false_positives!; end
   def warning; end
-  def warning_about_bare_error; end
   def with_message(expected_message); end
   include RSpec::Matchers::Composable
 end
@@ -1016,9 +1048,7 @@ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatche
   def initialize(*names); end
   def matches?(actual); end
   def matches_arity?(actual, name); end
-  def method_signature_for(actual, name); end
   def pp_names; end
-  def setup_method_signature_expectation; end
   def with(n); end
   def with_any_keywords; end
   def with_arity; end
@@ -1027,6 +1057,12 @@ class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatche
   def with_keywords_string; end
   def with_unlimited_arguments; end
 end
+class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
+  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
+  def matches?(actual, name); end
+  def method_signature_for(actual, name); end
+  def verifier_for(actual, name); end
+end
 class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
   def block_representation; end
   def description; end
@@ -1067,24 +1103,13 @@ class RSpec::Matchers::BuiltIn::YieldProbe
   def yielded_once?(matcher_name); end
 end
 class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
-  def at_least(number); end
-  def at_most(number); end
-  def count_constraint_to_number(n); end
   def does_not_match?(block); end
-  def exactly(number); end
   def failure_message; end
   def failure_message_when_negated; end
   def failure_reason; end
-  def human_readable_count(count); end
-  def human_readable_expectation_type; end
-  def initialize; end
   def matches?(block); end
-  def once; end
-  def set_expected_yields_count(relativity, n); end
   def supports_block_expectations?; end
-  def thrice; end
-  def times; end
-  def twice; end
+  include RSpec::Matchers::BuiltIn::CountExpectation
 end
 class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
   def does_not_match?(block); end

data/sorbet/rbi/gems/rspec-mocks.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi
 #
-# rspec-mocks-3.9.1
+# rspec-mocks-3.10.2
 
 module RSpec
 end
@@ -200,6 +200,7 @@ class RSpec::Mocks::Proxy
   def as_null_object; end
   def build_expectation(method_name); end
   def check_for_unexpected_arguments(expectation); end
+  def ensure_can_be_proxied!(object); end
   def ensure_implemented(*_args); end
   def find_almost_matching_expectation(method_name, *args); end
   def find_almost_matching_stub(method_name, *args); end

data/sorbet/rbi/gems/rspec-support.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi
 #
-# rspec-support-3.9.3
+# rspec-support-3.10.2
 
 module RSpec
   extend RSpec::Support::Warnings

data/sorbet/rbi/gems/rspec.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi
 #
-# rspec-3.9.0
+# rspec-3.10.0
 
 module RSpec
 end

data/sorbet/rbi/gems/simplecov-html.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov-html/all/simplecov-html.rbi
 #
-# simplecov-html-0.12.2
+# simplecov-html-0.12.3
 
 module SimpleCov
 end

data/sorbet/rbi/gems/simplecov.rbi

@@ -7,15 +7,15 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov/all/simplecov.rbi
 #
-# simplecov-0.18.5
+# simplecov-0.21.2
 
 module SimpleCov
   def self.adapt_coverage_result; end
   def self.add_not_loaded_files(result); end
   def self.at_exit_behavior; end
   def self.clear_result; end
-  def self.collate(result_filenames, profile = nil, &block); end
-  def self.exit_exception; end
+  def self.collate(result_filenames, profile = nil, ignore_timeout: nil, &block); end
+  def self.exit_and_report_previous_error(exit_status); end
   def self.exit_status_from_exception; end
   def self.external_at_exit; end
   def self.external_at_exit=(arg0); end
@@ -27,29 +27,33 @@ module SimpleCov
   def self.load_adapter(name); end
   def self.load_profile(name); end
   def self.lookup_corresponding_ruby_coverage_name(criterion); end
-  def self.minimum_coverage_violated(result); end
+  def self.make_parallel_tests_available; end
   def self.pid; end
   def self.pid=(arg0); end
+  def self.previous_error?(error_exit_status); end
+  def self.probably_running_parallel_tests?; end
   def self.process_coverage_result; end
-  def self.process_result(result, exit_status); end
+  def self.process_result(result); end
+  def self.process_results_and_report_error; end
+  def self.ready_to_process_results?; end
   def self.remove_useless_results; end
-  def self.report_minimum_violated(violations); end
   def self.result; end
   def self.result?; end
-  def self.result_exit_status(result, covered_percent); end
+  def self.result_exit_status(result); end
   def self.result_with_not_loaded_files; end
+  def self.round_coverage(coverage); end
   def self.run_exit_tasks!; end
   def self.running; end
   def self.running=(arg0); end
-  def self.set_exit_exception; end
   def self.start(profile = nil, &block); end
   def self.start_coverage_measurement; end
   def self.start_coverage_with_criteria; end
   def self.wait_for_other_processes; end
-  def self.write_last_run(covered_percent); end
+  def self.write_last_run(result); end
   extend SimpleCov::Configuration
 end
 module SimpleCov::Formatter
+  def self.from_env(env); end
 end
 class SimpleCov::Formatter::MultiFormatter
   def self.[](*args); end
@@ -63,6 +67,7 @@ module SimpleCov::Configuration
   def add_filter(filter_argument = nil, &filter_proc); end
   def add_group(group_name, filter_argument = nil, &filter_proc); end
   def at_exit(&block); end
+  def at_fork(&block); end
   def branch_coverage?; end
   def branch_coverage_supported?; end
   def clear_coverage_criteria; end
@@ -75,6 +80,8 @@ module SimpleCov::Configuration
   def coverage_path; end
   def coverage_start_arguments_supported?; end
   def enable_coverage(criterion); end
+  def enable_for_subprocesses(value = nil); end
+  def enabled_for_subprocesses?; end
   def filters; end
   def filters=(arg0); end
   def formatter(formatter = nil); end
@@ -90,13 +97,15 @@ module SimpleCov::Configuration
   def minimum_possible_coverage_exceeded(coverage_option); end
   def nocov_token(nocov_token = nil); end
   def parse_filter(filter_argument = nil, &filter_proc); end
+  def primary_coverage(criterion = nil); end
   def print_error_status; end
   def print_error_status=(arg0); end
   def profiles; end
   def project_name(new_name = nil); end
   def raise_if_criterion_disabled(criterion); end
   def raise_if_criterion_unsupported(criterion); end
-  def refuse_coverage_drop; end
+  def raise_on_invalid_coverage(coverage, coverage_setting); end
+  def refuse_coverage_drop(*criteria); end
   def root(root = nil); end
   def skip_token(nocov_token = nil); end
   def track_files(glob); end
@@ -116,6 +125,45 @@ class SimpleCov::CoverageStatistics
 end
 module SimpleCov::ExitCodes
 end
+module SimpleCov::ExitCodes::ExitCodeHandling
+  def call(result, coverage_limits:); end
+  def coverage_checks(result, coverage_limits); end
+  def self.call(result, coverage_limits:); end
+  def self.coverage_checks(result, coverage_limits); end
+end
+class SimpleCov::ExitCodes::MaximumCoverageDropCheck
+  def compute_coverage_drop_data; end
+  def coverage_drop_violations; end
+  def drop_percent(criterion); end
+  def exit_code; end
+  def failing?; end
+  def initialize(result, maximum_coverage_drop); end
+  def last_coverage(criterion); end
+  def last_run; end
+  def maximum_coverage_drop; end
+  def report; end
+  def result; end
+end
+class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
+  def compute_minimum_coverage_data; end
+  def exit_code; end
+  def failing?; end
+  def initialize(result, minimum_coverage_by_file); end
+  def minimum_coverage_by_file; end
+  def minimum_violations; end
+  def report; end
+  def result; end
+end
+class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
+  def calculate_minimum_violations; end
+  def exit_code; end
+  def failing?; end
+  def initialize(result, minimum_coverage); end
+  def minimum_coverage; end
+  def minimum_violations; end
+  def report; end
+  def result; end
+end
 class SimpleCov::Profiles < Hash
   def define(name, &blk); end
   def load(name); end
@@ -203,8 +251,10 @@ end
 class SimpleCov::FileList
   def branch_covered_percent; end
   def compute_coverage_statistics; end
+  def compute_coverage_statistics_by_file; end
   def count(*args, &block); end
   def coverage_statistics; end
+  def coverage_statistics_by_file; end
   def covered_branches; end
   def covered_lines; end
   def covered_percent; end
@@ -229,12 +279,11 @@ class SimpleCov::FileList
   include Enumerable
 end
 class SimpleCov::Result
-  def adapt_pre_simplecov_0_18_result(result); end
-  def adapt_result(result); end
   def command_name; end
   def command_name=(arg0); end
   def coverage; end
   def coverage_statistics(*args, &block); end
+  def coverage_statistics_by_file(*args, &block); end
   def covered_branches(*args, &block); end
   def covered_lines(*args, &block); end
   def covered_percent(*args, &block); end
@@ -247,12 +296,11 @@ class SimpleCov::Result
   def filter!; end
   def format!; end
   def groups; end
-  def initialize(original_result); end
+  def initialize(original_result, command_name: nil, created_at: nil); end
   def least_covered_file(*args, &block); end
   def missed_branches(*args, &block); end
   def missed_lines(*args, &block); end
   def original_result; end
-  def pre_simplecov_0_18_result?(result); end
   def self.from_hash(hash); end
   def source_files; end
   def to_hash; end
@@ -296,17 +344,26 @@ class SimpleCov::LinesClassifier
   def self.whitespace_line?(line); end
 end
 module SimpleCov::ResultMerger
-  def self.clear_resultset; end
-  def self.merge_and_store(*results); end
-  def self.merge_results(*results); end
+  def self.adapt_pre_simplecov_0_18_result(result); end
+  def self.adapt_result(result); end
+  def self.create_result(command_names, coverage); end
+  def self.merge_and_store(*file_paths, ignore_timeout: nil); end
+  def self.merge_coverage(*results); end
+  def self.merge_results(*file_paths, ignore_timeout: nil); end
+  def self.merge_valid_results(results, ignore_timeout: nil); end
   def self.merged_result; end
-  def self.results; end
-  def self.resultset; end
+  def self.parse_file(path); end
+  def self.parse_json(content); end
+  def self.pre_simplecov_0_18_result?(result); end
+  def self.read_file(path); end
+  def self.read_resultset; end
   def self.resultset_path; end
   def self.resultset_writelock; end
   def self.store_result(result); end
-  def self.stored_data; end
   def self.synchronize_resultset; end
+  def self.time_since_result_creation(data); end
+  def self.valid_results(file_path, ignore_timeout: nil); end
+  def self.within_merge_timeout?(data); end
 end
 module SimpleCov::CommandGuesser
   def self.from_command_line_options; end
@@ -354,6 +411,7 @@ module SimpleCov::Combine::ResultsCombiner
 end
 module SimpleCov::UselessResultsRemover
   def self.call(coverage_result); end
+  def self.root_regx; end
 end
 module SimpleCov::SimulateCoverage
   def call(absolute_path); end