rspec-sorbet 1.8.0 → 1.8.1

data/sorbet/rbi/gems/kwalify.rbi

@@ -1,340 +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/kwalify/all/kwalify.rbi
-#
-# kwalify-0.7.2
-
-module Kwalify
-  def self.meta_validator; end
-  def self.msg(key); end
-  def self.word(key); end
-  extend Kwalify::ErrorHelper
-  extend Kwalify::Types
-end
-module Kwalify::Boolean
-end
-class TrueClass
-  include Kwalify::Boolean
-  include Kwalify::Scalar
-end
-class FalseClass
-  include Kwalify::Boolean
-  include Kwalify::Scalar
-end
-module Kwalify::Text
-  include Kwalify::Scalar
-end
-class String
-  include Kwalify::Scalar
-  include Kwalify::Text
-end
-class Numeric
-  include Kwalify::Scalar
-  include Kwalify::Text
-end
-module Kwalify::Scalar
-end
-class Date
-  include Kwalify::Scalar
-end
-class Time
-  include Kwalify::Scalar
-end
-class NilClass
-  include Kwalify::Scalar
-end
-module Kwalify::Types
-  def collection?(val); end
-  def collection_type?(type); end
-  def scalar?(val); end
-  def scalar_type?(type); end
-  def self.collection?(val); end
-  def self.collection_type?(type); end
-  def self.get_type_class(type); end
-  def self.scalar?(val); end
-  def self.scalar_type?(type); end
-  def self.type_class(type); end
-  def self.type_table; end
-end
-class Kwalify::KwalifyError < StandardError
-end
-class Kwalify::AssertionError < Kwalify::KwalifyError
-  def initialize(msg); end
-end
-class Kwalify::BaseError < Kwalify::KwalifyError
-  def <=>(ex); end
-  def _to_s; end
-  def column; end
-  def column=(arg0); end
-  def error_symbol; end
-  def error_symbol=(arg0); end
-  def filename; end
-  def filename=(arg0); end
-  def initialize(message = nil, path = nil, value = nil, rule = nil, error_symbol = nil); end
-  def linenum; end
-  def linenum=(arg0); end
-  def message; end
-  def path; end
-  def path=(arg0); end
-  def rule; end
-  def rule=(arg0); end
-  def to_s; end
-  def value; end
-  def value=(arg0); end
-end
-class Kwalify::SchemaError < Kwalify::BaseError
-  def initialize(message = nil, path = nil, rule = nil, value = nil, error_symbol = nil); end
-end
-class Kwalify::ValidationError < Kwalify::BaseError
-  def initialize(message = nil, path = nil, rule = nil, value = nil, error_symbol = nil); end
-end
-class Kwalify::SyntaxError < Kwalify::BaseError
-  def initialize(msg, linenum = nil, error_symbol = nil); end
-  def message; end
-end
-class Kwalify::YamlSyntaxError < Kwalify::SyntaxError
-end
-module Kwalify::ErrorHelper
-  def _build_message(message_key, val, args); end
-  def assert_error(message = nil); end
-  def schema_error(error_symbol, rule, path, val, args = nil); end
-  def self._build_message(message_key, val, args); end
-  def self.validate_error(error_symbol, rule, path, val, args = nil); end
-  def validate_error(error_symbol, rule, path, val, args = nil); end
-end
-class Kwalify::Rule
-  def _check_confliction(hash, rule, path); end
-  def _init(hash, path = nil, rule_table = nil); end
-  def _init_assert_value(val, rule, path); end
-  def _init_class_value(val, rule, path); end
-  def _init_default_value(val, rule, path); end
-  def _init_desc_value(val, rule, path); end
-  def _init_enum_value(val, rule, path); end
-  def _init_ident_value(val, rule, path); end
-  def _init_length_value(val, rule, path); end
-  def _init_mapping_value(val, rule, path, rule_table); end
-  def _init_name_value(val, rule, path); end
-  def _init_pattern_value(val, rule, path); end
-  def _init_range_value(val, rule, path); end
-  def _init_required_value(val, rule, path); end
-  def _init_sequence_value(val, rule, path, rule_table); end
-  def _init_type_value(val, rule, path); end
-  def _init_unique_value(val, rule, path); end
-  def _inspect(str = nil, level = nil, done = nil); end
-  def _uniqueness_check_table; end
-  def assert; end
-  def assert_proc; end
-  def classname; end
-  def classobj; end
-  def default; end
-  def desc; end
-  def enum; end
-  def get_init_method(sym); end
-  def ident; end
-  def initialize(hash = nil, parent = nil); end
-  def length; end
-  def mapping; end
-  def name; end
-  def parent; end
-  def parent=(arg0); end
-  def pattern; end
-  def range; end
-  def regexp; end
-  def required; end
-  def sequence; end
-  def type; end
-  def type_class; end
-  def unique; end
-  include Kwalify::ErrorHelper
-end
-class Kwalify::Validator
-  def _inspect; end
-  def _validate(value, rule, path, errors, done, uniq_table, recursive = nil); end
-  def _validate_assert(value, rule, path, errors); end
-  def _validate_enum(value, rule, path, errors); end
-  def _validate_length(value, rule, path, errors); end
-  def _validate_mapping(hash, map_rule, path, errors, done, uniq_table, recursive = nil); end
-  def _validate_mapping_required_keys(hash, map_rule, path, errors); end
-  def _validate_pattern(value, rule, path, errors); end
-  def _validate_range(value, rule, path, errors); end
-  def _validate_scalar(value, rule, path, errors, done, uniq_table); end
-  def _validate_sequence(list, seq_rule, path, errors, done, uniq_table, recursive = nil); end
-  def _validate_unique(value, rule, path, errors, uniq_table); end
-  def initialize(hash_or_rule, &block); end
-  def rule; end
-  def validate(value); end
-  def validate_hook(value, rule, path, errors); end
-  include Kwalify::ErrorHelper
-end
-module Kwalify::Util
-  def _traverse_rule(rule, _done = nil, &block); end
-  def _traverse_schema(hash, _done = nil, &block); end
-  def create_hashtable(hashlist, primarykey, flag_duplicate_check = nil); end
-  def get_class(classname); end
-  def get_value(obj, path); end
-  def self._traverse_rule(rule, _done = nil, &block); end
-  def self._traverse_schema(hash, _done = nil, &block); end
-  def self.create_hashtable(hashlist, primarykey, flag_duplicate_check = nil); end
-  def self.get_class(classname); end
-  def self.get_value(obj, path); end
-  def self.traverse_rule(validator, &block); end
-  def self.traverse_schema(schema, &block); end
-  def self.untabify(str, width = nil); end
-  def traverse_rule(validator, &block); end
-  def traverse_schema(schema, &block); end
-  def untabify(str, width = nil); end
-end
-class Kwalify::BaseParser
-  def _getch; end
-  def _set_column_and_linenum(s); end
-  def _syntax_error(message, path = nil, linenum = nil, column = nil); end
-  def column; end
-  def eos?; end
-  def filename; end
-  def group(n); end
-  def linenum; end
-  def match?(regexp); end
-  def peep(n = nil); end
-  def reset(input, filename = nil, untabify = nil); end
-  def scan(regexp); end
-  def scan_string; end
-end
-module Kwalify::Yaml
-  def self.load(yaml_str, opts = nil); end
-  def self.load_file(filename, opts = nil); end
-end
-class Kwalify::Yaml::Parser < Kwalify::BaseParser
-  def _error(klass, message, path, linenum, column); end
-  def _getclass(classname); end
-  def _parse_map_value(map, map_rule, path, level, key, is_merged, uniq_table, _linenum, _column, _linenum2, _column2); end
-  def _set_error_info(linenum = nil, column = nil, &block); end
-  def _validate_map_value(map, map_rule, rule, path, uniq_table, key, val, _linenum, _column); end
-  def add_to_seq(rule, seq, val, linenum, column); end
-  def create_mapping(rule, linenum, column); end
-  def create_scalar(rule, value, linenum, column); end
-  def create_sequence(rule, linenum, column); end
-  def data_binding; end
-  def data_binding=(arg0); end
-  def document_start?; end
-  def errors; end
-  def has_next?; end
-  def initialize(validator = nil, properties = nil); end
-  def location(path); end
-  def mapping_class; end
-  def mapping_class=(arg0); end
-  def parse(input = nil, opts = nil); end
-  def parse_alias(rule, path, uniq_table, container); end
-  def parse_anchor(rule, path, uniq_table, container); end
-  def parse_block_map(map, map_rule, path, uniq_table); end
-  def parse_block_scalar(rule, path, uniq_table); end
-  def parse_block_seq(seq, seq_rule, path, uniq_table); end
-  def parse_block_text(column, rule, path, uniq_table); end
-  def parse_block_value(level, rule, path, uniq_table, container); end
-  def parse_documents(input, opts = nil, &block); end
-  def parse_file(filename, opts = nil); end
-  def parse_flow_map(map, map_rule, path, uniq_table); end
-  def parse_flow_scalar(rule, path, uniq_table); end
-  def parse_flow_seq(seq, seq_rule, path, uniq_table); end
-  def parse_flow_value(rule, path, uniq_table, container); end
-  def parse_next; end
-  def parse_stream(input, opts = nil, &block); end
-  def preceding_alias; end
-  def preceding_alias=(arg0); end
-  def put_to_map(rule, map, key, val, linenum, column); end
-  def reset_parser; end
-  def reset_scanner(input, filename = nil, untabify = nil); end
-  def resolve_preceding_aliases(val); end
-  def sequence_class; end
-  def sequence_class=(arg0); end
-  def set_errors_linenum(errors); end
-  def skip_spaces_and_comments; end
-  def stream_end?; end
-  def to_mapkey(str); end
-  def to_scalar(str); end
-  def validator; end
-  def validator=(arg0); end
-end
-class Kwalify::MetaValidator < Kwalify::Validator
-  def initialize(schema, &block); end
-  def self.instance; end
-  def validate_hook(value, rule, path, errors); end
-end
-class Kwalify::PlainYamlParser
-  def _getchar; end
-  def _getline; end
-  def add_to_map(map, key, value, linenum); end
-  def add_to_seq(seq, value, linenum); end
-  def assert(bool_expr); end
-  def create_mapping(linenum = nil); end
-  def create_scalar(value, linenum = nil); end
-  def create_sequence(linenum = nil); end
-  def current_char; end
-  def current_line; end
-  def current_linenum; end
-  def getchar; end
-  def getchar_or_nl; end
-  def getlabel; end
-  def getline; end
-  def has_next?; end
-  def initialize(yaml_str); end
-  def merge_map(map, map2, linenum); end
-  def parse; end
-  def parse_alias(column, value); end
-  def parse_all; end
-  def parse_anchor(column, value); end
-  def parse_block_text(column, value); end
-  def parse_child(column); end
-  def parse_flow(depth); end
-  def parse_flow_map(depth); end
-  def parse_flow_map_item(depth); end
-  def parse_flow_scalar(depth); end
-  def parse_flow_seq(depth); end
-  def parse_flow_seq_item(depth); end
-  def parse_flowstyle(column, value); end
-  def parse_mapping(column, value); end
-  def parse_scalar(indent, value); end
-  def parse_sequence(column, value); end
-  def parse_tag(column, value); end
-  def parse_value(column, value, value_start_column); end
-  def register_alias(label); end
-  def register_anchor(label, data); end
-  def reset_sbuf(str); end
-  def resolve_aliases(data); end
-  def set_default(map, value, linenum); end
-  def set_map_with(map, key, value, linenum); end
-  def set_seq_at(seq, i, value, linenum); end
-  def syntax_error(error_symbol, arg = nil, linenum = nil); end
-  def to_scalar(str); end
-  def white?(ch); end
-end
-class Kwalify::PlainYamlParser::Alias
-  def initialize(label, linenum); end
-  def label; end
-  def linenum; end
-end
-class Kwalify::YamlParser < Kwalify::PlainYamlParser
-  def add_to_map(map, key, value, linenum); end
-  def add_to_seq(seq, value, linenum); end
-  def create_mapping(linenum = nil); end
-  def create_scalar(value, linenum = nil); end
-  def create_sequence(linenum = nil); end
-  def initialize(*args); end
-  def merge_map(map, collection, linenum); end
-  def parse; end
-  def path_linenum(path); end
-  def set_default(map, value, linenum); end
-  def set_error_linenums(errors); end
-  def set_errors_linenum(errors); end
-  def set_map_with(map, key, value, linenum); end
-  def set_seq_at(seq, i, value, linenum); end
-end
-class Kwalify::Parser < Kwalify::YamlParser
-  def initialize(yaml_str); end
-end
-module Kwalify::Json
-end

data/sorbet/rbi/gems/listen.rbi

@@ -1,324 +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.2.1
-
-module Listen
-  def self.logger; end
-  def self.logger=(logger); end
-  def self.setup_default_logger_if_unset; end
-  def self.stop; end
-  def self.to(*args, &block); end
-end
-class Listen::Logger
-  def self.debug(*args, &block); end
-  def self.error(*args, &block); end
-  def self.fatal(*args, &block); end
-  def self.info(*args, &block); end
-  def self.warn(*args, &block); end
-end
-class Listen::Options
-  def initialize(opts, defaults); end
-  def method_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 tree; 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::Record::SymlinkDetector
-  def _fail(symlinked, real_path); end
-  def initialize; end
-  def verify_unwatched!(entry); end
-end
-class Listen::Record::SymlinkDetector::Error < RuntimeError
-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 config; end
-  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::Adapter
-  def self._log(type, message); end
-  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(*args, &block); end
-  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._log(*args, &block); 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
-module Listen::Internals
-end
-module Listen::Internals::ThreadPool
-  def self.add(&block); end
-  def self.stop; 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 _run_worker(worker); 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 _init_ignores(ignores, overrides); 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 options; 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 _detect_possible_editor_save(changes); end
-  def _logical_action_for(path, actions); end
-  def _reinterpret_related_changes(cookies); end
-  def _squash_changes(changes); end
-  def config; 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 current_state_name; end
-  def default_state; end
-  def initialize; end
-  def self.included(klass); end
-  def state; end
-  def states; end
-  def transition!(state_name); end
-  def transition(state_name); end
-  def transition_with_callbacks!(state_name); end
-  def validate_and_sanitize_new_state(state_name); end
-end
-module Listen::FSM::ClassMethods
-  def default_state(new_default = nil); end
-  def state(*args, &block); end
-  def states; end
-end
-class Listen::FSM::State
-  def call(obj); end
-  def initialize(name, transitions = nil, &block); end
-  def name; end
-  def transitions; end
-  def valid_transition?(new_state); 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; end
-  def _remember_time_of_first_unprocessed_event; end
-  def _reset_no_unprocessed_events; end
-  def _sleep(_local_reason, *args); end
-  def _timestamp; 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 _nice_error(ex); end
-  def _sleep(*args); end
-  def _wait_for_changes(ready_queue, config); end
-  def _wait_until_resumed(ready_queue); end
-  def _wakeup(reason); end
-  def config; end
-  def initialize(config); end
-  def pause; end
-  def paused?; end
-  def processing?; end
-  def resume; end
-  def setup; end
-  def state; end
-  def state=(arg0); end
-  def stopped?; end
-  def teardown; end
-  def wait_thread; end
-  def wakeup_on_event; end
-end
-class Listen::Event::Loop::Error < RuntimeError
-end
-class Listen::Event::Loop::Error::NotStarted < Listen::Event::Loop::Error
-end
-class Listen::Event::Queue
-  def <<(args); end
-  def _safe_relative_from_cwd(dir); end
-  def block; end
-  def config; end
-  def empty?(*args, &block); end
-  def event_queue; end
-  def initialize(config, &block); 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 paused?; end
-  def sleep(*args); end
-  def stopped?; end
-  def timestamp; end
-end
-class Listen::Listener
-  def backend; end
-  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 processor; end
-  def start; end
-  def stop; 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