toy_adt 0.1.0

data/sorbet/rbi/gems/guard.rbi

@@ -0,0 +1,397 @@
+# 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/guard/all/guard.rbi
+#
+# guard-2.18.0
+
+module Guard
+  def self._evaluate(options); end
+  def self._guardfile_deprecated_check(modified); end
+  def self._listener_callback; end
+  def self._pluginless_guardfile?; end
+  def self._relative_pathnames(paths); end
+  def self._relevant_changes?(changes); end
+  def self.async_queue_add(changes); end
+  def self.init(cmdline_options); end
+  def self.interactor; end
+  def self.listener; end
+  def self.queue; end
+  def self.setup(cmdline_options = nil); end
+  def self.state; end
+  extend Guard::Deprecated::Guard::ClassMethods
+end
+class Anonymous_Nenv_Environment_1 < Nenv::Environment
+  def gem_silence_deprecations?; end
+  def strict?; end
+end
+class Guard::Config < Anonymous_Nenv_Environment_1
+  def initialize; end
+  def silence_deprecations?; end
+end
+module Guard::UI
+  def self._calling_plugin_name; end
+  def self._filter(plugin); end
+  def self._filtered_logger_message(message, method, color_name, options = nil); end
+  def self.action_with_scopes(action, scope); end
+  def self.clear(opts = nil); end
+  def self.clearable; end
+  def self.color(text, *color_options); end
+  def self.color_enabled?; end
+  def self.debug(message, options = nil); end
+  def self.deprecation(message, options = nil); end
+  def self.error(message, options = nil); end
+  def self.info(message, options = nil); end
+  def self.level=(new_level); end
+  def self.logger; end
+  def self.options; end
+  def self.options=(options); end
+  def self.reset_and_clear; end
+  def self.reset_line; end
+  def self.reset_logger; end
+  def self.warning(message, options = nil); end
+  include Guard::UI::Colors
+end
+module Guard::UI::Colors
+end
+class Guard::Options < Thor::CoreExt::HashWithIndifferentAccess
+  def fetch(name); end
+  def initialize(opts = nil, default_opts = nil); end
+end
+class Guard::UI::Logger
+end
+class Guard::UI::Logger::Config < Guard::Options
+  def initialize(options = nil); end
+  def level=(value); end
+end
+class Guard::UI::Config < Guard::Options
+  def [](name); end
+  def device; end
+  def except; end
+  def initialize(options = nil); end
+  def logger_config; end
+  def only; end
+  def with_progname(name); end
+end
+class Guard::Terminal
+  def self.clear; end
+end
+class Guard::PluginUtil
+  def _constant_name; end
+  def _full_gem_path(name); end
+  def _plugin_constant; end
+  def add_to_guardfile; end
+  def initialize(name); end
+  def initialize_plugin(options); end
+  def name; end
+  def name=(arg0); end
+  def plugin_class(options = nil); end
+  def plugin_location; end
+  def self._gem_valid?(gem); end
+  def self.plugin_names; end
+end
+class Guard::Group
+  def initialize(name, options = nil); end
+  def name; end
+  def name=(arg0); end
+  def options; end
+  def options=(arg0); end
+  def title; end
+  def to_s; end
+end
+module Guard::Internals
+end
+class Guard::Internals::Groups
+  def add(name, options = nil); end
+  def all(filter = nil); end
+  def initialize; end
+  def matcher_for(filter); end
+end
+class Guard::Plugin
+  def _register_callbacks; end
+  def callbacks; end
+  def callbacks=(arg0); end
+  def group; end
+  def group=(arg0); end
+  def hook(event, *args); end
+  def initialize(options = nil); end
+  def name; end
+  def options; end
+  def options=(arg0); end
+  def self.add_callback(listener, guard_plugin, events); end
+  def self.callbacks; end
+  def self.non_namespaced_classname; end
+  def self.non_namespaced_name; end
+  def self.notify(guard_plugin, event, *args); end
+  def self.reset_callbacks!; end
+  def self.template(plugin_location); end
+  def title; end
+  def to_s; end
+  def watchers; end
+  def watchers=(arg0); end
+end
+class Guard::Internals::Plugins
+  def add(name, options); end
+  def all(filter = nil); end
+  def initialize; end
+  def matcher_for(filter); end
+  def remove(plugin); end
+end
+class Guard::Internals::Session
+  def clear?; end
+  def clearing(on); end
+  def clearing?; end
+  def cmdline_groups; end
+  def cmdline_plugins; end
+  def convert_scope(entries); end
+  def debug?; end
+  def evaluator_options; end
+  def groups; end
+  def guardfile_group_scope; end
+  def guardfile_ignore; end
+  def guardfile_ignore=(ignores); end
+  def guardfile_ignore_bang; end
+  def guardfile_ignore_bang=(arg0); end
+  def guardfile_notification=(config); end
+  def guardfile_plugin_scope; end
+  def guardfile_scope(scope); end
+  def initialize(new_options); end
+  def interactor_name; end
+  def listener_args; end
+  def notify_options; end
+  def plugins; end
+  def watchdirs; end
+  def watchdirs=(dirs); end
+end
+class Guard::Internals::Scope
+  def _find_non_empty_scope(type, local_scope); end
+  def _groups; end
+  def _hashify_scope(type); end
+  def _instantiate(meth, obj); end
+  def _plugins; end
+  def _scope_names(new_scope, name); end
+  def from_interactor(scope); end
+  def grouped_plugins(scope = nil); end
+  def initialize; end
+  def titles(scope = nil); end
+  def to_hash; end
+end
+module Guard::Deprecated
+end
+module Guard::Deprecated::Watcher
+  def self.add_deprecated(klass); end
+end
+module Guard::Deprecated::Watcher::ClassMethods
+  def match_guardfile?(files); end
+end
+class Guard::Watcher
+  def ==(other); end
+  def action; end
+  def action=(arg0); end
+  def call_action(matches); end
+  def initialize(pattern, action = nil); end
+  def match(string_or_pathname); end
+  def pattern; end
+  def pattern=(arg0); end
+  def self.match_files(guard, files); end
+  extend Guard::Deprecated::Watcher::ClassMethods
+end
+class Guard::Watcher::Pattern
+  def self.create(pattern); end
+end
+class Guard::Watcher::Pattern::MatchResult
+  def [](index); end
+  def initialize(match_result, original_value); end
+end
+class Guard::Watcher::Pattern::Matcher
+  def ==(other); end
+  def initialize(obj); end
+  def match(string_or_pathname); end
+  def matcher; end
+  def normalized(string_or_pathname); end
+end
+class Guard::Watcher::Pattern::DeprecatedRegexp
+  def deprecated?; end
+  def initialize(pattern); end
+  def self.convert(pattern); end
+  def self.show_deprecation(pattern); end
+end
+class Guard::Watcher::Pattern::SimplePath
+  def initialize(string_or_pathname); end
+  def match(string_or_pathname); end
+  def normalize(string_or_pathname); end
+end
+class Guard::Watcher::Pattern::PathnamePath < Guard::Watcher::Pattern::SimplePath
+  def normalize(string_or_pathname); end
+end
+class Guard::Runner
+  def _run_group_plugins(plugins); end
+  def _supervise(plugin, task, *args); end
+  def run(task, scope_hash = nil); end
+  def run_on_changes(modified, added, removed); end
+  def self.stopping_symbol_for(guard); end
+end
+class Guard::Internals::State
+  def initialize(cmdline_opts); end
+  def scope; end
+  def session; end
+end
+module Guard::Deprecated::Evaluator
+  def evaluate_guardfile; end
+  def reevaluate_guardfile; end
+  def self.add_deprecated(klass); end
+end
+class Guard::Interactor
+  def background(*args, **, &block); end
+  def foreground(*args, **, &block); end
+  def handle_interrupt(*args, **, &block); end
+  def idle_job; end
+  def initialize(no_interaction = nil); end
+  def interactive?; end
+  def self.enabled; end
+  def self.enabled=(arg0); end
+  def self.enabled?; end
+  def self.options; end
+  def self.options=(arg0); end
+  extend Forwardable
+end
+class Guard::Notifier
+  def self.connect(options = nil); end
+  def self.detected; end
+  def self.disconnect; end
+  def self.notify(message, options = nil); end
+  def self.supported; end
+  def self.toggle; end
+  def self.turn_on; end
+end
+module Guard::Deprecated::Dsl
+  def self.add_deprecated(dsl_klass); end
+end
+module Guard::Deprecated::Dsl::ClassMethods
+  def evaluate_guardfile(options = nil); end
+end
+class Guard::Dsl
+  def _cleanup_backtrace(backtrace); end
+  def callback(*args, &block); end
+  def clearing(on); end
+  def directories(directories); end
+  def evaluate(contents, filename, lineno); end
+  def filter!(*regexps); end
+  def filter(*regexps); end
+  def group(*args); end
+  def guard(name, options = nil); end
+  def ignore!(*regexps); end
+  def ignore(*regexps); end
+  def interactor(options); end
+  def logger(options); end
+  def notification(notifier, opts = nil); end
+  def scope(scope = nil); end
+  def watch(pattern, &action); end
+  extend Guard::Deprecated::Dsl::ClassMethods
+end
+class Guard::Dsl::Error < RuntimeError
+end
+class Guard::DslReader < Guard::Dsl
+  def callback(*_args, &_block); end
+  def clearing(_on); end
+  def directories(_directories); end
+  def group(*_args); end
+  def guard(name, _options = nil); end
+  def ignore!(*_regexps); end
+  def ignore(*_regexps); end
+  def initialize; end
+  def interactor(_options); end
+  def logger(_options); end
+  def notification(_notifier, _opts = nil); end
+  def plugin_names; end
+  def scope(_scope = nil); end
+  def watch(_pattern, &_action); end
+end
+module Guard::Guardfile
+end
+class Guard::Guardfile::Evaluator
+  def _fetch_guardfile_contents; end
+  def _from_deprecated(opts); end
+  def _guardfile_contents; end
+  def _guardfile_contents_usable?; end
+  def _guardfile_contents_without_user_config; end
+  def _instance_eval_guardfile(contents); end
+  def _read(path); end
+  def _use_default!; end
+  def _use_inline; end
+  def _use_provided; end
+  def custom?; end
+  def evaluate; end
+  def guardfile_contents; end
+  def guardfile_include?(plugin_name); end
+  def guardfile_path; end
+  def guardfile_source; end
+  def initialize(opts = nil); end
+  def inline?; end
+  def options; end
+  def path; end
+  include Guard::Deprecated::Evaluator
+end
+class Guard::Guardfile::Evaluator::Error < RuntimeError
+end
+class Guard::Guardfile::Evaluator::NoGuardfileError < Guard::Guardfile::Evaluator::Error
+end
+class Guard::Guardfile::Evaluator::NoCustomGuardfile < Guard::Guardfile::Evaluator::Error
+end
+class Guard::Guardfile::Evaluator::NoPluginsError < Guard::Guardfile::Evaluator::Error
+end
+module Guard::Deprecated::Guard
+  def self.add_deprecated(klass); end
+end
+module Guard::Deprecated::Guard::ClassMethods
+  def add_group(name, options = nil); end
+  def add_guard(*args); end
+  def add_plugin(name, options = nil); end
+  def evaluate_guardfile; end
+  def evaluator; end
+  def get_guard_class(name, fail_gracefully = nil); end
+  def group(filter); end
+  def groups(filter); end
+  def guard_gem_names; end
+  def guards(filter = nil); end
+  def listener=(_); end
+  def locate_guard(name); end
+  def lock; end
+  def options; end
+  def plugin(filter); end
+  def plugins(filter); end
+  def reset_evaluator(_options); end
+  def runner; end
+  def running; end
+  def scope; end
+  def scope=(scope); end
+end
+module Guard::Internals::Helpers
+  def _relative_pathname(path); end
+end
+module Guard::Internals::Tracing
+  def self.trace(mod, meth); end
+  def self.untrace(mod, meth); end
+end
+class Guard::Internals::Debugging
+  def self._notify(*args); end
+  def self._reset; end
+  def self._trace(mod, meth, &block); end
+  def self._untrace(mod, meth); end
+  def self.start; end
+  def self.stop; end
+end
+module Guard::Internals::Traps
+  def self.handle(signal, &block); end
+end
+class Guard::Internals::Queue
+  def <<(changes); end
+  def _run_actions(actions); end
+  def initialize(commander); end
+  def pending?; end
+  def process; end
+end

data/sorbet/rbi/gems/listen.rbi

@@ -0,0 +1,304 @@
+# 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.7.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 _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 empty_dirname?(dirname); end
+  def file_data(rel_path); end
+  def initialize(directory, silencer); end
+  def reset_tree; 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::Error::INotifyMaxWatchesExceeded < 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(**options); 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