sorbet-rails 0.5.0 → 0.5.1

data/spec/support/v5.0/sorbet/rbi/gems/method_source.rbi

@@ -1,63 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/method_source/all/method_source.rbi
-#
-# method_source-0.9.2
-module MethodSource
-  def self.comment_helper(source_location, name = nil); end
-  def self.extract_code(source_location); end
-  def self.lines_for(file_name, name = nil); end
-  def self.source_helper(source_location, name = nil); end
-  def self.valid_expression?(str); end
-  extend MethodSource::CodeHelpers
-end
-module MethodSource::ReeSourceLocation
-  def source_location; end
-end
-module MethodSource::SourceLocation
-end
-module MethodSource::SourceLocation::MethodExtensions
-  def source_location; end
-  def trace_func(event, file, line, id, binding, classname); end
-end
-module MethodSource::SourceLocation::ProcExtensions
-  def source_location; end
-end
-module MethodSource::SourceLocation::UnboundMethodExtensions
-  def source_location; end
-end
-module MethodSource::CodeHelpers
-  def comment_describing(file, line_number); end
-  def complete_expression?(str); end
-  def expression_at(file, line_number, options = nil); end
-  def extract_first_expression(lines, consume = nil, &block); end
-  def extract_last_comment(lines); end
-end
-module MethodSource::CodeHelpers::IncompleteExpression
-  def self.===(ex); end
-  def self.rbx?; end
-end
-class MethodSource::SourceNotFoundError < StandardError
-end
-module MethodSource::MethodExtensions
-  def comment; end
-  def self.included(klass); end
-  def source; end
-end
-class Method
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::MethodExtensions
-end
-class UnboundMethod
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::UnboundMethodExtensions
-end
-class Proc
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::ProcExtensions
-end

data/spec/support/v5.0/sorbet/rbi/gems/minitest.rbi

@@ -1,276 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/minitest/all/minitest.rbi
-#
-# minitest-5.11.3
-module Minitest
-  def self.__run(reporter, options); end
-  def self.after_run(&block); end
-  def self.autorun; end
-  def self.backtrace_filter; end
-  def self.backtrace_filter=(arg0); end
-  def self.clock_time; end
-  def self.extensions; end
-  def self.extensions=(arg0); end
-  def self.filter_backtrace(bt); end
-  def self.info_signal; end
-  def self.info_signal=(arg0); end
-  def self.init_plugins(options); end
-  def self.load_plugins; end
-  def self.parallel_executor; end
-  def self.parallel_executor=(arg0); end
-  def self.process_args(args = nil); end
-  def self.reporter; end
-  def self.reporter=(arg0); end
-  def self.run(args = nil); end
-  def self.run_one_method(klass, method_name); end
-end
-module Minitest::Parallel
-end
-class Minitest::Parallel::Executor
-  def <<(work); end
-  def initialize(size); end
-  def shutdown; end
-  def size; end
-  def start; end
-end
-module Minitest::Parallel::Test
-  def _synchronize; end
-end
-module Minitest::Parallel::Test::ClassMethods
-  def run_one_method(klass, method_name, reporter); end
-  def test_order; end
-end
-module Minitest::Assertions
-  def _synchronize; end
-  def assert(test, msg = nil); end
-  def assert_empty(obj, msg = nil); end
-  def assert_equal(exp, act, msg = nil); end
-  def assert_in_delta(exp, act, delta = nil, msg = nil); end
-  def assert_in_epsilon(exp, act, epsilon = nil, msg = nil); end
-  def assert_includes(collection, obj, msg = nil); end
-  def assert_instance_of(cls, obj, msg = nil); end
-  def assert_kind_of(cls, obj, msg = nil); end
-  def assert_match(matcher, obj, msg = nil); end
-  def assert_nil(obj, msg = nil); end
-  def assert_operator(o1, op, o2 = nil, msg = nil); end
-  def assert_output(stdout = nil, stderr = nil); end
-  def assert_predicate(o1, op, msg = nil); end
-  def assert_raises(*exp); end
-  def assert_respond_to(obj, meth, msg = nil); end
-  def assert_same(exp, act, msg = nil); end
-  def assert_send(send_ary, m = nil); end
-  def assert_silent; end
-  def assert_throws(sym, msg = nil); end
-  def capture_io; end
-  def capture_subprocess_io; end
-  def diff(exp, act); end
-  def exception_details(e, msg); end
-  def flunk(msg = nil); end
-  def message(msg = nil, ending = nil, &default); end
-  def mu_pp(obj); end
-  def mu_pp_for_diff(obj); end
-  def pass(_msg = nil); end
-  def refute(test, msg = nil); end
-  def refute_empty(obj, msg = nil); end
-  def refute_equal(exp, act, msg = nil); end
-  def refute_in_delta(exp, act, delta = nil, msg = nil); end
-  def refute_in_epsilon(a, b, epsilon = nil, msg = nil); end
-  def refute_includes(collection, obj, msg = nil); end
-  def refute_instance_of(cls, obj, msg = nil); end
-  def refute_kind_of(cls, obj, msg = nil); end
-  def refute_match(matcher, obj, msg = nil); end
-  def refute_nil(obj, msg = nil); end
-  def refute_operator(o1, op, o2 = nil, msg = nil); end
-  def refute_predicate(o1, op, msg = nil); end
-  def refute_respond_to(obj, meth, msg = nil); end
-  def refute_same(exp, act, msg = nil); end
-  def self.diff; end
-  def self.diff=(o); end
-  def skip(msg = nil, bt = nil); end
-  def skipped?; end
-end
-class Minitest::Unit
-  def self.after_tests(&b); end
-  def self.autorun; end
-end
-class Minitest::Unit::TestCase < Minitest::Test
-  def self.inherited(klass); end
-end
-class Minitest::Test < Minitest::Runnable
-  def capture_exceptions; end
-  def class_name; end
-  def run; end
-  def self.i_suck_and_my_tests_are_order_dependent!; end
-  def self.io_lock; end
-  def self.io_lock=(arg0); end
-  def self.make_my_diffs_pretty!; end
-  def self.parallelize_me!; end
-  def self.runnable_methods; end
-  def self.test_order; end
-  def with_info_handler(&block); end
-  extend Minitest::Guard
-  include Minitest::Assertions
-  include Minitest::Guard
-  include Minitest::Reportable
-  include Minitest::Test::LifecycleHooks
-end
-module Minitest::Test::LifecycleHooks
-  def after_setup; end
-  def after_teardown; end
-  def before_setup; end
-  def before_teardown; end
-  def setup; end
-  def teardown; end
-end
-class Minitest::Runnable
-  def assertions; end
-  def assertions=(arg0); end
-  def failure; end
-  def failures; end
-  def failures=(arg0); end
-  def initialize(name); end
-  def marshal_dump; end
-  def marshal_load(ary); end
-  def name; end
-  def name=(o); end
-  def passed?; end
-  def result_code; end
-  def run; end
-  def self.inherited(klass); end
-  def self.methods_matching(re); end
-  def self.on_signal(name, action); end
-  def self.reset; end
-  def self.run(reporter, options = nil); end
-  def self.run_one_method(klass, method_name, reporter); end
-  def self.runnable_methods; end
-  def self.runnables; end
-  def self.with_info_handler(reporter, &block); end
-  def skipped?; end
-  def time; end
-  def time=(arg0); end
-  def time_it; end
-end
-module Minitest::Reportable
-  def class_name; end
-  def error?; end
-  def location; end
-  def passed?; end
-  def result_code; end
-  def skipped?; end
-end
-class Minitest::Result < Minitest::Runnable
-  def class_name; end
-  def klass; end
-  def klass=(arg0); end
-  def self.from(runnable); end
-  def source_location; end
-  def source_location=(arg0); end
-  def to_s; end
-  include Minitest::Reportable
-end
-class Minitest::AbstractReporter
-  def lock; end
-  def locked?; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def start; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-  include Mutex_m
-end
-class Minitest::Reporter < Minitest::AbstractReporter
-  def initialize(io = nil, options = nil); end
-  def io; end
-  def io=(arg0); end
-  def options; end
-  def options=(arg0); end
-end
-class Minitest::ProgressReporter < Minitest::Reporter
-  def prerecord(klass, name); end
-  def record(result); end
-end
-class Minitest::StatisticsReporter < Minitest::Reporter
-  def assertions; end
-  def assertions=(arg0); end
-  def count; end
-  def count=(arg0); end
-  def errors; end
-  def errors=(arg0); end
-  def failures; end
-  def failures=(arg0); end
-  def initialize(io = nil, options = nil); end
-  def passed?; end
-  def record(result); end
-  def report; end
-  def results; end
-  def results=(arg0); end
-  def skips; end
-  def skips=(arg0); end
-  def start; end
-  def start_time; end
-  def start_time=(arg0); end
-  def total_time; end
-  def total_time=(arg0); end
-end
-class Minitest::SummaryReporter < Minitest::StatisticsReporter
-  def aggregated_results(io); end
-  def binary_string; end
-  def old_sync; end
-  def old_sync=(arg0); end
-  def report; end
-  def start; end
-  def statistics; end
-  def summary; end
-  def sync; end
-  def sync=(arg0); end
-  def to_s; end
-end
-class Minitest::CompositeReporter < Minitest::AbstractReporter
-  def <<(reporter); end
-  def initialize(*reporters); end
-  def io; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def reporters; end
-  def reporters=(arg0); end
-  def start; end
-end
-class Minitest::Assertion < Exception
-  def error; end
-  def location; end
-  def result_code; end
-  def result_label; end
-end
-class Minitest::Skip < Minitest::Assertion
-  def result_label; end
-end
-class Minitest::UnexpectedError < Minitest::Assertion
-  def backtrace; end
-  def error; end
-  def exception; end
-  def exception=(arg0); end
-  def initialize(exception); end
-  def message; end
-  def result_label; end
-end
-module Minitest::Guard
-  def jruby?(platform = nil); end
-  def maglev?(platform = nil); end
-  def mri?(platform = nil); end
-  def rubinius?(platform = nil); end
-  def windows?(platform = nil); end
-end
-class Minitest::BacktraceFilter
-  def filter(bt); end
-end

data/spec/support/v5.0/sorbet/rbi/gems/rails-dom-testing.rbi

@@ -1,67 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rails-dom-testing/all/rails-dom-testing.rbi
-#
-# rails-dom-testing-2.0.3
-module Rails
-end
-module Rails::Dom
-end
-module Rails::Dom::Testing
-end
-module Rails::Dom::Testing::Assertions
-  extend ActiveSupport::Concern
-  include Rails::Dom::Testing::Assertions::DomAssertions
-  include Rails::Dom::Testing::Assertions::SelectorAssertions
-end
-module Rails::Dom::Testing::Assertions::DomAssertions
-  def assert_dom_equal(expected, actual, message = nil); end
-  def assert_dom_not_equal(expected, actual, message = nil); end
-  def compare_doms(expected, actual); end
-  def equal_attribute?(attr, other_attr); end
-  def equal_attribute_nodes?(nodes, other_nodes); end
-  def equal_children?(child, other_child); end
-  def fragment(text); end
-end
-module Rails::Dom::Testing::Assertions::SelectorAssertions
-  def assert_select(*args, &block); end
-  def assert_select_email(&block); end
-  def assert_select_encoded(element = nil, &block); end
-  def assert_size_match!(size, equals, css_selector, message = nil); end
-  def css_select(*args); end
-  def document_root_element; end
-  def nest_selection(selection); end
-  def nodeset(node); end
-  include Rails::Dom::Testing::Assertions::SelectorAssertions::CountDescribable
-end
-module Rails::Dom::Testing::Assertions::SelectorAssertions::CountDescribable
-  def count_description(min, max, count); end
-  def pluralize_element(quantity); end
-  extend ActiveSupport::Concern
-end
-class SubstitutionContext
-  def initialize; end
-  def match(matches, attribute, matcher); end
-  def matcher_for(value, format_for_presentation); end
-  def substitutable?(value); end
-  def substitute!(selector, values, format_for_presentation = nil); end
-end
-class HTMLSelector
-  def context; end
-  def css_selector; end
-  def extract_equality_tests; end
-  def extract_root(previous_selection, root_fallback); end
-  def extract_selectors; end
-  def filter(matches); end
-  def initialize(values, previous_selection = nil, &root_fallback); end
-  def message; end
-  def select; end
-  def selecting_no_body?; end
-  def self.context; end
-  def tests; end
-end

data/spec/support/v5.0/sorbet/rbi/gems/rake.rbi

@@ -1,255 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
-#
-# rake-12.3.2
-module Rake
-  def self.each_dir_parent(dir); end
-  def self.from_pathname(path); end
-end
-module Rake::Cloneable
-  def initialize_copy(source); end
-end
-module FileUtils
-  def create_shell_runner(cmd); end
-  def ruby(*args, &block); end
-  def safe_ln(*args); end
-  def set_verbose_option(options); end
-  def sh(*cmd, &block); end
-  def sh_show_command(cmd); end
-  def split_all(path); end
-end
-module Rake::FileUtilsExt
-  def cd(*args, &block); end
-  def chdir(*args, &block); end
-  def chmod(*args, &block); end
-  def chmod_R(*args, &block); end
-  def chown(*args, &block); end
-  def chown_R(*args, &block); end
-  def copy(*args, &block); end
-  def cp(*args, &block); end
-  def cp_r(*args, &block); end
-  def install(*args, &block); end
-  def link(*args, &block); end
-  def ln(*args, &block); end
-  def ln_s(*args, &block); end
-  def ln_sf(*args, &block); end
-  def makedirs(*args, &block); end
-  def mkdir(*args, &block); end
-  def mkdir_p(*args, &block); end
-  def mkpath(*args, &block); end
-  def move(*args, &block); end
-  def mv(*args, &block); end
-  def nowrite(value = nil); end
-  def rake_check_options(options, *optdecl); end
-  def rake_merge_option(args, defaults); end
-  def rake_output_message(message); end
-  def remove(*args, &block); end
-  def rm(*args, &block); end
-  def rm_f(*args, &block); end
-  def rm_r(*args, &block); end
-  def rm_rf(*args, &block); end
-  def rmdir(*args, &block); end
-  def rmtree(*args, &block); end
-  def safe_unlink(*args, &block); end
-  def self.nowrite_flag; end
-  def self.nowrite_flag=(arg0); end
-  def self.verbose_flag; end
-  def self.verbose_flag=(arg0); end
-  def symlink(*args, &block); end
-  def touch(*args, &block); end
-  def verbose(value = nil); end
-  def when_writing(msg = nil); end
-  extend Rake::FileUtilsExt
-  include FileUtils
-end
-class Module
-  def rake_extension(method); end
-end
-class String
-  def ext(newext = nil); end
-  def pathmap(spec = nil, &block); end
-  def pathmap_explode; end
-  def pathmap_partial(n); end
-  def pathmap_replace(patterns, &block); end
-end
-class Rake::FileList
-  def &(*args, &block); end
-  def *(other); end
-  def +(*args, &block); end
-  def -(*args, &block); end
-  def <<(obj); end
-  def <=>(*args, &block); end
-  def ==(array); end
-  def [](*args, &block); end
-  def []=(*args, &block); end
-  def add(*filenames); end
-  def add_matching(pattern); end
-  def all?(*args, &block); end
-  def any?(*args, &block); end
-  def append(*args, &block); end
-  def assoc(*args, &block); end
-  def at(*args, &block); end
-  def bsearch(*args, &block); end
-  def bsearch_index(*args, &block); end
-  def chunk(*args, &block); end
-  def chunk_while(*args, &block); end
-  def clear(*args, &block); end
-  def clear_exclude; end
-  def collect!(*args, &block); end
-  def collect(*args, &block); end
-  def collect_concat(*args, &block); end
-  def combination(*args, &block); end
-  def compact!(*args, &block); end
-  def compact(*args, &block); end
-  def concat(*args, &block); end
-  def count(*args, &block); end
-  def cycle(*args, &block); end
-  def delete(*args, &block); end
-  def delete_at(*args, &block); end
-  def delete_if(*args, &block); end
-  def detect(*args, &block); end
-  def dig(*args, &block); end
-  def drop(*args, &block); end
-  def drop_while(*args, &block); end
-  def each(*args, &block); end
-  def each_cons(*args, &block); end
-  def each_entry(*args, &block); end
-  def each_index(*args, &block); end
-  def each_slice(*args, &block); end
-  def each_with_index(*args, &block); end
-  def each_with_object(*args, &block); end
-  def egrep(pattern, *options); end
-  def empty?(*args, &block); end
-  def entries(*args, &block); end
-  def exclude(*patterns, &block); end
-  def exclude?(*args, &block); end
-  def excluded_from_list?(fn); end
-  def existing!; end
-  def existing; end
-  def ext(newext = nil); end
-  def extract_options!(*args, &block); end
-  def fetch(*args, &block); end
-  def fifth(*args, &block); end
-  def fill(*args, &block); end
-  def find(*args, &block); end
-  def find_all(*args, &block); end
-  def find_index(*args, &block); end
-  def first(*args, &block); end
-  def flat_map(*args, &block); end
-  def flatten!(*args, &block); end
-  def flatten(*args, &block); end
-  def forty_two(*args, &block); end
-  def fourth(*args, &block); end
-  def from(*args, &block); end
-  def grep(*args, &block); end
-  def grep_v(*args, &block); end
-  def group_by(*args, &block); end
-  def gsub!(pat, rep); end
-  def gsub(pat, rep); end
-  def import(array); end
-  def include(*filenames); end
-  def include?(*args, &block); end
-  def index(*args, &block); end
-  def index_by(*args, &block); end
-  def initialize(*patterns); end
-  def inject(*args, &block); end
-  def insert(*args, &block); end
-  def inspect(*args, &block); end
-  def is_a?(klass); end
-  def join(*args, &block); end
-  def keep_if(*args, &block); end
-  def kind_of?(klass); end
-  def last(*args, &block); end
-  def lazy(*args, &block); end
-  def length(*args, &block); end
-  def many?(*args, &block); end
-  def map!(*args, &block); end
-  def map(*args, &block); end
-  def max(*args, &block); end
-  def max_by(*args, &block); end
-  def member?(*args, &block); end
-  def min(*args, &block); end
-  def min_by(*args, &block); end
-  def minmax(*args, &block); end
-  def minmax_by(*args, &block); end
-  def none?(*args, &block); end
-  def one?(*args, &block); end
-  def pack(*args, &block); end
-  def partition(&block); end
-  def pathmap(spec = nil, &block); end
-  def permutation(*args, &block); end
-  def pluck(*args, &block); end
-  def pop(*args, &block); end
-  def prepend(*args, &block); end
-  def product(*args, &block); end
-  def push(*args, &block); end
-  def rassoc(*args, &block); end
-  def reduce(*args, &block); end
-  def reject!(*args, &block); end
-  def reject(*args, &block); end
-  def repeated_combination(*args, &block); end
-  def repeated_permutation(*args, &block); end
-  def replace(*args, &block); end
-  def resolve; end
-  def resolve_add(fn); end
-  def resolve_exclude; end
-  def reverse!(*args, &block); end
-  def reverse(*args, &block); end
-  def reverse_each(*args, &block); end
-  def rindex(*args, &block); end
-  def rotate!(*args, &block); end
-  def rotate(*args, &block); end
-  def sample(*args, &block); end
-  def second(*args, &block); end
-  def second_to_last(*args, &block); end
-  def select!(*args, &block); end
-  def select(*args, &block); end
-  def self.[](*args); end
-  def self.glob(pattern, *args); end
-  def shelljoin(*args, &block); end
-  def shift(*args, &block); end
-  def shuffle!(*args, &block); end
-  def shuffle(*args, &block); end
-  def size(*args, &block); end
-  def slice!(*args, &block); end
-  def slice(*args, &block); end
-  def slice_after(*args, &block); end
-  def slice_before(*args, &block); end
-  def slice_when(*args, &block); end
-  def sort!(*args, &block); end
-  def sort(*args, &block); end
-  def sort_by!(*args, &block); end
-  def sort_by(*args, &block); end
-  def sub!(pat, rep); end
-  def sub(pat, rep); end
-  def sum(*args, &block); end
-  def take(*args, &block); end
-  def take_while(*args, &block); end
-  def third(*args, &block); end
-  def third_to_last(*args, &block); end
-  def to(*args, &block); end
-  def to_a; end
-  def to_ary; end
-  def to_default_s(*args, &block); end
-  def to_formatted_s(*args, &block); end
-  def to_h(*args, &block); end
-  def to_s; end
-  def to_sentence(*args, &block); end
-  def to_set(*args, &block); end
-  def to_xml(*args, &block); end
-  def transpose(*args, &block); end
-  def uniq!(*args, &block); end
-  def uniq(*args, &block); end
-  def unshift(*args, &block); end
-  def values_at(*args, &block); end
-  def without(*args, &block); end
-  def zip(*args, &block); end
-  def |(*args, &block); end
-  include Rake::Cloneable
-end