sorbet-struct-comparable 1.1.0 → 1.2.0

data/sorbet/rbi/gems/coderay.rbi

@@ -1,92 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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/coderay/all/coderay.rbi
-#
-# coderay-1.1.3
-
-module CodeRay
-  def self.coderay_path(*path); end
-  def self.encode(code, lang, format, options = nil); end
-  def self.encode_file(filename, format, options = nil); end
-  def self.encode_tokens(tokens, format, options = nil); end
-  def self.encoder(format, options = nil); end
-  def self.get_scanner_options(options); end
-  def self.highlight(code, lang, options = nil, format = nil); end
-  def self.highlight_file(filename, options = nil, format = nil); end
-  def self.scan(code, lang, options = nil, &block); end
-  def self.scan_file(filename, lang = nil, options = nil, &block); end
-  def self.scanner(lang, options = nil, &block); end
-end
-module CodeRay::PluginHost
-  def [](id, *args, &blk); end
-  def all_plugins; end
-  def const_missing(const); end
-  def default(id = nil); end
-  def list; end
-  def load(id, *args, &blk); end
-  def load_all; end
-  def load_plugin_map; end
-  def make_plugin_hash; end
-  def map(hash); end
-  def path_to(plugin_id); end
-  def plugin_hash; end
-  def plugin_path(*args); end
-  def register(plugin, id); end
-  def self.extended(mod); end
-  def validate_id(id); end
-end
-class CodeRay::PluginHost::PluginNotFound < LoadError
-end
-class CodeRay::PluginHost::HostNotFound < LoadError
-end
-module CodeRay::Encoders
-  extend CodeRay::PluginHost
-end
-module CodeRay::Plugin
-  def aliases; end
-  def plugin_host(host = nil); end
-  def plugin_id; end
-  def register_for(id); end
-  def title(title = nil); end
-end
-class CodeRay::Encoders::Encoder
-  def <<(token); end
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def compile(tokens, options = nil); end
-  def encode(code, lang, options = nil); end
-  def encode_tokens(tokens, options = nil); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def file_extension; end
-  def finish(options); end
-  def get_output(options); end
-  def highlight(code, lang, options = nil); end
-  def initialize(options = nil); end
-  def options; end
-  def options=(arg0); end
-  def output(data); end
-  def scanner; end
-  def scanner=(arg0); end
-  def self.const_missing(sym); end
-  def self.file_extension; end
-  def setup(options); end
-  def text_token(text, kind); end
-  def token(content, kind); end
-  def tokens(tokens, options = nil); end
-  extend CodeRay::Plugin
-end
-class CodeRay::Encoders::Terminal < CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def open_token(kind); end
-  def setup(options); end
-  def text_token(text, kind); end
-end

data/sorbet/rbi/gems/docile.rbi

@@ -1,36 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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/docile/all/docile.rbi
-#
-# docile-1.3.5
-
-module Docile
-  def dsl_eval(dsl, *args, &block); end
-  def dsl_eval_immutable(dsl, *args, &block); end
-  def dsl_eval_with_block_return(dsl, *args, &block); end
-  def self.dsl_eval(dsl, *args, &block); end
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-  extend Docile::Execution
-end
-module Docile::Execution
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end
-module Docile::BacktraceFilter
-  def backtrace; end
-  def backtrace_locations; end
-end

data/sorbet/rbi/gems/listen.rbi

@@ -1,301 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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/listen/all/listen.rbi
-#
-# listen-3.5.1
-
-module Listen
-  def self.default_logger; end
-  def self.logger; end
-  def self.logger=(arg0); end
-  def self.stop; end
-  def self.to(*args, &block); end
-end
-class Listen::Options
-  def initialize(opts, defaults); end
-  def method_missing(name, *_); end
-  def respond_to_missing?(name, *_); end
-end
-class Listen::Record
-  def _auto_hash; end
-  def _fast_build_dir(remaining, symlink_detector); end
-  def _fast_try_file(entry); end
-  def _fast_unset_path(dirname, basename); end
-  def _fast_update_file(dirname, basename, data); end
-  def add_dir(rel_path); end
-  def build; end
-  def dir_entries(rel_path); end
-  def file_data(rel_path); end
-  def initialize(directory); end
-  def root; end
-  def unset_path(rel_path); end
-  def update_file(rel_path, data); end
-end
-class Listen::Record::Entry
-  def _entries(dir); end
-  def _join; end
-  def children; end
-  def initialize(root, relative, name = nil); end
-  def meta; end
-  def name; end
-  def real_path; end
-  def record_dir_key; end
-  def relative; end
-  def root; end
-  def sys_path; end
-end
-class Listen::Error < RuntimeError
-end
-class Listen::Error::NotStarted < Listen::Error
-end
-class Listen::Error::SymlinkLoop < Listen::Error
-end
-class Listen::Record::SymlinkDetector
-  def _fail(symlinked, real_path); end
-  def initialize; end
-  def verify_unwatched!(entry); end
-end
-class Listen::File
-  def self.change(record, rel_path); end
-  def self.inaccurate_mac_time?(stat); end
-end
-class Listen::Directory
-  def self._async_changes(snapshot, path, previous, options); end
-  def self._change(snapshot, type, path, options); end
-  def self._children(path); end
-  def self.ascendant_of?(base, other); end
-  def self.scan(snapshot, rel_path, options); end
-end
-class Listen::Change
-  def initialize(config, record); end
-  def invalidate(type, rel_path, options); end
-  def record; end
-end
-class Listen::Change::Config
-  def initialize(queue, silencer); end
-  def queue(*args); end
-  def silenced?(path, type); end
-end
-module Listen::Thread
-  def self._exception_with_causes(exception); end
-  def self._log_exception(exception, thread_name, caller_stack: nil); end
-  def self.new(name, &block); end
-  def self.rescue_and_log(method_name, *args, caller_stack: nil); end
-end
-module Listen::Adapter
-  def self._usable_adapter_class; end
-  def self._warn_polling_fallback(options); end
-  def self.select(options = nil); end
-end
-class Listen::Adapter::Base
-  def _log_exception(msg, caller_stack); end
-  def _queue_change(type, dir, rel_path, options); end
-  def _stop; end
-  def _timed(title); end
-  def config; end
-  def configure; end
-  def initialize(config); end
-  def options; end
-  def self.usable?; end
-  def start; end
-  def started?; end
-  def stop; end
-end
-class Listen::Adapter::BSD < Listen::Adapter::Base
-  def _change(event_flags); end
-  def _configure(directory, &callback); end
-  def _event_path(event); end
-  def _find(*paths, &block); end
-  def _process_event(dir, event); end
-  def _run; end
-  def _watch_file(path, queue); end
-  def _watch_for_new_file(event); end
-  def self.usable?; end
-end
-class Listen::Adapter::Darwin < Listen::Adapter::Base
-  def _configure(dir, &callback); end
-  def _process_changes(dirs); end
-  def _process_event(dir, path); end
-  def _run; end
-  def _stop; end
-  def self.usable?; end
-end
-class Listen::Adapter::Linux < Listen::Adapter::Base
-  def _change(event_flags); end
-  def _configure(directory, &callback); end
-  def _dir_event?(event); end
-  def _process_event(dir, event); end
-  def _run; end
-  def _skip_event?(event); end
-  def _stop; end
-end
-class Listen::Adapter::Polling < Listen::Adapter::Base
-  def _configure(_, &callback); end
-  def _process_event(dir, _); end
-  def _run; end
-end
-class Listen::Adapter::Windows < Listen::Adapter::Base
-  def _change(type); end
-  def _configure(dir); end
-  def _process_event(dir, event); end
-  def _run; end
-  def self.usable?; end
-end
-class Listen::Adapter::Config
-  def adapter_options; end
-  def directories; end
-  def initialize(directories, queue, silencer, adapter_options); end
-  def queue; end
-  def silencer; end
-end
-class Listen::Backend
-  def adapter; end
-  def initialize(directories, queue, silencer, config); end
-  def min_delay_between_events; end
-  def start(*args, &block); end
-  def stop(*args, &block); end
-  extend Forwardable
-end
-class Listen::Silencer
-  def _ignore?(path); end
-  def _init_ignores(ignores, overrides); end
-  def _only?(path); end
-  def configure(options); end
-  def ignore_patterns; end
-  def ignore_patterns=(arg0); end
-  def initialize; end
-  def only_patterns; end
-  def only_patterns=(arg0); end
-  def silenced?(relative_path, type); end
-end
-class Listen::Silencer::Controller
-  def _reconfigure_silencer(extra_options); end
-  def append_ignores(*regexps); end
-  def initialize(silencer, default_options); end
-  def replace_with_bang_ignores(regexps); end
-  def replace_with_only(regexps); end
-end
-class Listen::QueueOptimizer
-  def _calculate_add_remove_difference(actions, path, default_if_exists); end
-  def _logical_action_for(path, actions); end
-  def _reinterpret_related_changes(cookies); end
-  def _squash_changes(changes); end
-  def config; end
-  def editor_modified?(changes); end
-  def initialize(config); end
-  def smoosh_changes(changes); end
-end
-class Listen::QueueOptimizer::Config
-  def debug(*args, &block); end
-  def exist?(path); end
-  def initialize(adapter_class, silencer); end
-  def silenced?(path, type); end
-end
-module Listen::FSM
-  def current_state; end
-  def initialize_fsm; end
-  def self.included(klass); end
-  def state; end
-  def transition!(new_state_name); end
-  def transition(new_state_name); end
-  def transition_with_callbacks!(new_state); end
-  def validate_and_sanitize_new_state(new_state_name); end
-  def wait_for_state(*wait_for_states, timeout: nil); end
-end
-module Listen::FSM::ClassMethods
-  def start_state(new_start_state = nil); end
-  def state(state_name, to: nil, &block); end
-  def states; end
-end
-class Listen::FSM::State
-  def call(obj); end
-  def initialize(name, transitions, &block); end
-  def name; end
-  def transitions; end
-  def valid_transition?(new_state); end
-end
-module Listen::MonotonicTime
-  def self.now; end
-end
-module Listen::Event
-end
-class Listen::Event::Processor
-  def _check_stopped; end
-  def _deadline; end
-  def _flush_wakeup_reasons; end
-  def _process_changes(event); end
-  def _remember_time_of_first_unprocessed_event; end
-  def _reset_no_unprocessed_events; end
-  def _sleep(seconds); end
-  def _wait_until_events; end
-  def _wait_until_events_calm_down; end
-  def _wait_until_no_longer_paused; end
-  def config; end
-  def initialize(config, reasons); end
-  def loop_for(latency); end
-end
-class Listen::Event::Processor::Stopped < RuntimeError
-end
-class Listen::Event::Loop
-  def _process_changes; end
-  def _wakeup(reason); end
-  def initialize(config); end
-  def pause; end
-  def start; end
-  def started?; end
-  def stop; end
-  def stopped?; end
-  def wakeup_on_event; end
-  extend Listen::FSM::ClassMethods
-  include Listen::FSM
-end
-class Listen::Event::Queue
-  def <<(args); end
-  def _safe_relative_from_cwd(dir); end
-  def close(*args, &block); end
-  def empty?(*args, &block); end
-  def initialize(config); end
-  def pop(*args, &block); end
-  extend Forwardable
-end
-class Listen::Event::Queue::Config
-  def initialize(relative); end
-  def relative?; end
-end
-class Listen::Event::Config
-  def call(*args); end
-  def callable?; end
-  def event_queue; end
-  def initialize(listener, event_queue, queue_optimizer, wait_for_delay, &block); end
-  def listener; end
-  def min_delay_between_events; end
-  def optimize_changes(changes); end
-  def sleep(seconds); end
-end
-class Listen::Listener
-  def ignore!(regexps); end
-  def ignore(regexps); end
-  def initialize(*dirs, &block); end
-  def only(regexps); end
-  def pause; end
-  def paused?; end
-  def processing?; end
-  def start; end
-  def stop; end
-  def stopped?; end
-  extend Listen::FSM::ClassMethods
-  include Listen::FSM
-end
-class Listen::Listener::Config
-  def adapter_instance_options(klass); end
-  def adapter_select_options; end
-  def initialize(opts); end
-  def min_delay_between_events; end
-  def relative?; end
-  def silencer_rules; end
-end

data/sorbet/rbi/gems/method_source.rbi

@@ -1,64 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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-1.0.0
-
-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/sorbet/rbi/gems/pry-byebug.rbi

@@ -1,155 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# 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/pry-byebug/all/pry-byebug.rbi
-#
-# pry-byebug-3.9.0
-
-module PryByebug
-  def check_file_context(target, msg = nil); end
-  def current_remote_server; end
-  def current_remote_server=(arg0); end
-  def file_context?(target); end
-  def self.check_file_context(target, msg = nil); end
-  def self.file_context?(target); end
-end
-module PryByebug::Helpers
-end
-module PryByebug::Helpers::Location
-  def current_file(source = nil); end
-  def self.current_file(source = nil); end
-end
-module Byebug
-end
-class Byebug::PryProcessor < Byebug::CommandProcessor
-  def at_breakpoint(breakpoint); end
-  def at_end; end
-  def at_line; end
-  def at_return(_return_value); end
-  def bold(*args, &block); end
-  def n_hits(breakpoint); end
-  def output(*args, &block); end
-  def perform(action, options = nil); end
-  def perform_backtrace(_options); end
-  def perform_down(options); end
-  def perform_finish(*arg0); end
-  def perform_frame(options); end
-  def perform_next(options); end
-  def perform_step(options); end
-  def perform_up(options); end
-  def pry; end
-  def pry=(arg0); end
-  def resume_pry; end
-  def run(&_block); end
-  def self.start; end
-  extend Forwardable
-end
-class Pry
-  def self.start_with_pry_byebug(target = nil, options = nil); end
-  def self.start_without_pry_byebug(target = nil, options = nil); end
-end
-module PryByebug::Helpers::Navigation
-  def breakout_navigation(action, options = nil); end
-end
-class PryByebug::BacktraceCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-module PryByebug::Helpers::Multiline
-  def check_multiline_context; end
-end
-class PryByebug::NextCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Multiline
-  include PryByebug::Helpers::Navigation
-end
-class PryByebug::StepCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-module PryByebug::Helpers::Breakpoints
-  def bold_puts(msg); end
-  def breakpoints; end
-  def max_width; end
-  def print_breakpoints_header; end
-  def print_full_breakpoint(breakpoint); end
-  def print_short_breakpoint(breakpoint); end
-end
-class PryByebug::ContinueCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Breakpoints
-  include PryByebug::Helpers::Location
-  include PryByebug::Helpers::Navigation
-end
-class PryByebug::FinishCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-class PryByebug::UpCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-class PryByebug::DownCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-class PryByebug::FrameCommand < Pry::ClassCommand
-  def process; end
-  include PryByebug::Helpers::Navigation
-end
-module Pry::Byebug
-end
-module Pry::Byebug::Breakpoints
-  def add_file(file, line, expression = nil); end
-  def add_method(method, expression = nil); end
-  def breakpoints; end
-  def change(id, expression = nil); end
-  def change_status(id, enabled = nil); end
-  def delete(id); end
-  def delete_all; end
-  def disable(id); end
-  def disable_all; end
-  def each(&block); end
-  def enable(id); end
-  def find_by_id(id); end
-  def last; end
-  def size; end
-  def to_a; end
-  def validate_expression(exp); end
-  extend Enumerable
-  extend Pry::Byebug::Breakpoints
-end
-class Pry::Byebug::Breakpoints::FileBreakpoint < SimpleDelegator
-  def source_code; end
-  def to_s; end
-end
-class Pry::Byebug::Breakpoints::MethodBreakpoint < SimpleDelegator
-  def initialize(byebug_bp, method); end
-  def source_code; end
-  def to_s; end
-end
-class PryByebug::BreakCommand < Pry::ClassCommand
-  def add_breakpoint(place, condition); end
-  def new_breakpoint; end
-  def option_to_method(option); end
-  def options(opt); end
-  def print_all; end
-  def process; end
-  def process_condition; end
-  def process_delete; end
-  def process_delete_all; end
-  def process_disable; end
-  def process_disable_all; end
-  def process_enable; end
-  def process_show; end
-  include PryByebug::Helpers::Breakpoints
-  include PryByebug::Helpers::Location
-  include PryByebug::Helpers::Multiline
-end
-class PryByebug::ExitAllCommand < Pry::Command::ExitAll
-  def process; end
-end