From e22f628a2b7f8a213ea2554afaf5593cfea73e3a Mon Sep 17 00:00:00 2001 From: vidusheeamoli Date: Sun, 14 Jun 2020 11:40:07 +0530 Subject: [PATCH] tapioca: init and sync. 145 errors => 28 errors --- .../sorbet/rbi/gems/activesupport@6.0.3.1.rbi | 6 + .../Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi | 53 + .../sorbet/rbi/gems/byebug@11.1.3.rbi | 15 + .../sorbet/rbi/gems/coderay@1.1.3.rbi | 6 + .../sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi | 1881 + .../sorbet/rbi/gems/connection_pool@2.2.3.rbi | 65 + .../sorbet/rbi/gems/coveralls@0.8.23.rbi | 6 + .../Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi | 6 + .../Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi | 6 + .../rbi/gems/domain_name@0.5.20190701.rbi | 88 + .../sorbet/rbi/gems/hpricot@0.8.6.rbi | 6 + .../sorbet/rbi/gems/http-cookie@1.0.3.rbi | 216 + .../Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi | 6 + .../Homebrew/sorbet/rbi/gems/json@2.3.0.rbi | 87 + .../sorbet/rbi/gems/mechanize@2.7.6.rbi | 1122 + .../sorbet/rbi/gems/method_source@1.0.0.rbi | 6 + .../rbi/gems/mime-types-data@3.2020.0512.rbi | 64 + .../sorbet/rbi/gems/mime-types@3.3.1.rbi | 253 + .../sorbet/rbi/gems/mini_portile2@2.4.0.rbi | 6 + .../sorbet/rbi/gems/minitest@5.14.1.rbi | 6 + .../sorbet/rbi/gems/mustache@1.1.1.rbi | 6 + .../rbi/gems/net-http-digest_auth@1.4.1.rbi | 6 + .../rbi/gems/net-http-persistent@4.0.0.rbi | 6 + .../sorbet/rbi/gems/nokogiri@1.10.9.rbi | 1551 + .../sorbet/rbi/gems/ntlm-http@0.1.1.rbi | 232 + .../sorbet/rbi/gems/parallel@1.19.1.rbi | 90 + .../sorbet/rbi/gems/parallel_tests@3.0.0.rbi | 80 + .../sorbet/rbi/gems/parser@2.7.1.3.rbi | 1131 + .../Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi | 125 + .../Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi | 6 + .../sorbet/rbi/gems/rainbow@3.0.0.rbi | 142 + .../sorbet/rbi/gems/rdiscount@2.2.0.1.rbi | 6 + .../sorbet/rbi/gems/regexp_parser@1.7.1.rbi | 1507 + .../Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi | 678 + .../Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi | 6 + .../sorbet/rbi/gems/rspec-core@3.9.2.rbi | 2347 ++ .../rbi/gems/rspec-expectations@3.9.2.rbi | 1482 + .../sorbet/rbi/gems/rspec-its@1.3.0.rbi | 6 + .../sorbet/rbi/gems/rspec-mocks@3.9.1.rbi | 1434 + .../sorbet/rbi/gems/rspec-retry@0.6.2.rbi | 6 + .../sorbet/rbi/gems/rspec-support@3.9.3.rbi | 470 + .../sorbet/rbi/gems/rspec-wait@0.0.9.rbi | 6 + .../Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi | 39 + .../sorbet/rbi/gems/rubocop-ast@0.0.3.rbi | 1142 + .../rbi/gems/rubocop-performance@1.6.1.rbi | 525 + .../sorbet/rbi/gems/rubocop-rspec@1.40.0.rbi | 1669 + .../sorbet/rbi/gems/rubocop@0.85.1.rbi | 10471 +++++ .../sorbet/rbi/gems/ruby-macho@2.2.0.rbi | 6 + .../rbi/gems/ruby-progressbar@1.10.1.rbi | 421 + .../sorbet/rbi/gems/simplecov-html@0.10.2.rbi | 6 + .../sorbet/rbi/gems/simplecov@0.16.1.rbi | 6 + .../Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi | 6 + .../sorbet/rbi/gems/term-ansicolor@1.7.1.rbi | 6 + .../Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi | 825 + .../sorbet/rbi/gems/thread_safe@0.3.6.rbi | 6 + .../Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi | 6 + .../Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi | 6 + .../Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi | 21 + .../sorbet/rbi/gems/unf_ext@0.0.7.7.rbi | 6 + .../rbi/gems/unicode-display_width@1.7.0.rbi | 26 + .../sorbet/rbi/gems/webrobots@0.1.2.rbi | 172 + .../sorbet/rbi/gems/zeitwerk@2.3.0.rbi | 6 + .../sorbet/rbi/hidden-definitions/errors.txt | 18899 +-------- .../sorbet/rbi/hidden-definitions/hidden.rbi | 31914 ---------------- Library/Homebrew/sorbet/rbi/todo.rbi | 73 +- Library/Homebrew/sorbet/tapioca/require.rb | 4 + 66 files changed, 30609 insertions(+), 50879 deletions(-) create mode 100644 Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/coveralls@0.8.23.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/json@2.3.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.9.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/parallel@1.19.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.0.3.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.6.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.40.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/rubocop@0.85.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.10.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/simplecov@0.16.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/term-ansicolor@1.7.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi create mode 100644 Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.3.0.rbi create mode 100644 Library/Homebrew/sorbet/tapioca/require.rb diff --git a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.1.rbi new file mode 100644 index 0000000000..5e3ec3f757 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: false + + diff --git a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi new file mode 100644 index 0000000000..bdfeff7155 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi @@ -0,0 +1,53 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module AST +end + +class AST::Node + def initialize(type, children = _, properties = _); end + + def +(array); end + def <<(element); end + def ==(other); end + def append(element); end + def children; end + def clone; end + def concat(array); end + def dup; end + def eql?(other); end + def hash; end + def inspect(indent = _); end + def to_a; end + def to_ast; end + def to_s(indent = _); end + def to_sexp(indent = _); end + def to_sexp_array; end + def type; end + def updated(type = _, children = _, properties = _); end + + protected + + def assign_properties(properties); end + def fancy_type; end + + private + + def original_dup; end +end + +class AST::Processor + include(::AST::Processor::Mixin) +end + +module AST::Processor::Mixin + def handler_missing(node); end + def process(node); end + def process_all(nodes); end +end + +module AST::Sexp + def s(type, *children); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi new file mode 100644 index 0000000000..f0a3c279f3 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi @@ -0,0 +1,15 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Byebug + def self.attach; end + def self.spawn(host = _, port = _); end +end + +module Kernel + def byebug; end + def debugger; end + def remote_byebug(host = _, port = _); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi new file mode 100644 index 0000000000..abba436190 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.6.rbi @@ -0,0 +1,1881 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Concurrent + extend(::Concurrent::Utility::EngineDetector) + extend(::Concurrent::Utility::NativeExtensionLoader) + extend(::Logger::Severity) + extend(::Concurrent::Concern::Logging) + extend(::Concurrent::Concern::Deprecation) + + + private + + def abort_transaction; end + def atomically; end + def call_dataflow(method, executor, *inputs, &block); end + def dataflow(*inputs, &block); end + def dataflow!(*inputs, &block); end + def dataflow_with(executor, *inputs, &block); end + def dataflow_with!(executor, *inputs, &block); end + def leave_transaction; end + def monotonic_time; end + + def self.abort_transaction; end + def self.atomically; end + def self.call_dataflow(method, executor, *inputs, &block); end + def self.create_simple_logger(level = _, output = _); end + def self.create_stdlib_logger(level = _, output = _); end + def self.dataflow(*inputs, &block); end + def self.dataflow!(*inputs, &block); end + def self.dataflow_with(executor, *inputs, &block); end + def self.dataflow_with!(executor, *inputs, &block); end + def self.disable_at_exit_handlers!; end + def self.executor(executor_identifier); end + def self.global_fast_executor; end + def self.global_immediate_executor; end + def self.global_io_executor; end + def self.global_logger; end + def self.global_logger=(value); end + def self.global_timer_set; end + def self.leave_transaction; end + def self.monotonic_time; end + def self.new_fast_executor(opts = _); end + def self.new_io_executor(opts = _); end + def self.physical_processor_count; end + def self.processor_count; end + def self.processor_counter; end + def self.use_simple_logger(level = _, output = _); end + def self.use_stdlib_logger(level = _, output = _); end +end + +class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object + def initialize; end + + def exchange(value, timeout = _); end + def exchange!(value, timeout = _); end + def try_exchange(value, timeout = _); end + + private + + def do_exchange(value, timeout); end +end + +class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + include(::Concurrent::ExecutorService) + include(::Concurrent::Concern::Deprecation) + + def initialize(opts = _, &block); end + + def auto_terminate=(value); end + def auto_terminate?; end + def fallback_policy; end + def kill; end + def name; end + def running?; end + def shutdown; end + def shutdown?; end + def shuttingdown?; end + def to_s; end + def wait_for_termination(timeout = _); end + + private + + def handle_fallback(*args); end + def ns_auto_terminate?; end + def ns_execute(*args, &task); end + def ns_kill_execution; end + def ns_shutdown_execution; end +end + +Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array) + +class Concurrent::AbstractThreadLocalVar + def initialize(default = _, &default_block); end + + def bind(value, &block); end + def value; end + def value=(value); end + + protected + + def allocate_storage; end + def default; end +end + +class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject + include(::Concurrent::Concern::Observable) + + def initialize(initial, opts = _); end + + def <<(action); end + def await; end + def await_for(timeout); end + def await_for!(timeout); end + def deref; end + def error; end + def error_mode; end + def failed?; end + def post(*args, &action); end + def reason; end + def restart(new_value, opts = _); end + def send(*args, &action); end + def send!(*args, &action); end + def send_off(*args, &action); end + def send_off!(*args, &action); end + def send_via(executor, *args, &action); end + def send_via!(executor, *args, &action); end + def stopped?; end + def value; end + def wait(timeout = _); end + + private + + def enqueue_action_job(action, args, executor); end + def enqueue_await_job(latch); end + def execute_next_job; end + def handle_error(error); end + def ns_enqueue_job(job, index = _); end + def ns_find_last_job_for_thread; end + def ns_initialize(initial, opts); end + def ns_post_next_job; end + def ns_validate(value); end + + def self.await(*agents); end + def self.await_for(timeout, *agents); end + def self.await_for!(timeout, *agents); end +end + +class Concurrent::Agent::Error < ::StandardError + def initialize(message = _); end +end + +class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error + def initialize(message = _); end +end + +class Concurrent::Array < ::Array +end + +module Concurrent::Async + def async; end + def await; end + def call; end + def cast; end + def init_synchronization; end + + def self.included(base); end + def self.validate_argc(obj, method, *args); end +end + +class Concurrent::Atom < ::Concurrent::Synchronization::Object + include(::Concurrent::Concern::Observable) + + def initialize(value, opts = _); end + + def __initialize_atomic_fields__; end + def compare_and_set(old_value, new_value); end + def deref; end + def reset(new_value); end + def swap(*args); end + def value; end + + private + + def compare_and_set_value(expected, value); end + def swap_value(value); end + def update_value(&block); end + def valid?(new_value); end + def value=(value); end + + def self.new(*args, &block); end +end + +class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean + def inspect; end + def to_s; end +end + +module Concurrent::AtomicDirectUpdate + def try_update; end + def try_update!; end + def update; end +end + +class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum + def inspect; end + def to_s; end +end + +class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object + def initialize(value = _, mark = _); end + + def __initialize_atomic_fields__; end + def compare_and_set(expected_val, new_val, expected_mark, new_mark); end + def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end + def get; end + def mark; end + def marked?; end + def set(new_val, new_mark); end + def try_update; end + def try_update!; end + def update; end + def value; end + + private + + def compare_and_set_reference(expected, value); end + def immutable_array(*args); end + def reference; end + def reference=(value); end + def swap_reference(value); end + def update_reference(&block); end + + def self.new(*args, &block); end +end + +module Concurrent::AtomicNumericCompareAndSetWrapper + def compare_and_set(old_value, new_value); end +end + +class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference + def inspect; end + def to_s; end +end + +class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor + def initialize(opts = _); end + + + private + + def ns_initialize(opts); end +end + +class Concurrent::CancelledOperationError < ::Concurrent::Error +end + +module Concurrent::Collection +end + +class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject + def initialize; end + + def add_observer(observer = _, func = _, &block); end + def count_observers; end + def delete_observer(observer); end + def delete_observers; end + def notify_and_delete_observers(*args, &block); end + def notify_observers(*args, &block); end + + protected + + def ns_initialize; end + + private + + def duplicate_and_clear_observers; end + def duplicate_observers; end + def notify_to(observers, *args); end +end + +class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject + def initialize; end + + def add_observer(observer = _, func = _, &block); end + def count_observers; end + def delete_observer(observer); end + def delete_observers; end + def notify_and_delete_observers(*args, &block); end + def notify_observers(*args, &block); end + + protected + + def ns_initialize; end + + private + + def clear_observers_and_return_old; end + def notify_to(observers, *args); end + def observers; end + def observers=(new_set); end +end + +Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend + +class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend + def initialize(options = _); end + + def []=(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def get_and_set(key, value); end + def merge_pair(key, value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end +end + +class Concurrent::Collection::NonConcurrentMapBackend + def initialize(options = _); end + + def [](key); end + def []=(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def each_pair; end + def get_and_set(key, value); end + def get_or_default(key, default_value); end + def key?(key); end + def merge_pair(key, value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end + def size; end + + private + + def _get(key); end + def _set(key, value); end + def dupped_backend; end + def initialize_copy(other); end + def pair?(key, expected_value); end + def store_computed_value(key, new_value); end +end + +class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue + def <<(item); end + def deq; end + def enq(item); end + def has_priority?(item); end + def shift; end + def size; end +end + +class Concurrent::Collection::RubyNonConcurrentPriorityQueue + def initialize(opts = _); end + + def <<(item); end + def clear; end + def delete(item); end + def deq; end + def empty?; end + def enq(item); end + def has_priority?(item); end + def include?(item); end + def length; end + def peek; end + def pop; end + def push(item); end + def shift; end + def size; end + + private + + def ordered?(x, y); end + def sink(k); end + def swap(x, y); end + def swim(k); end + + def self.from_list(list, opts = _); end +end + +module Concurrent::Concern +end + +module Concurrent::Concern::Deprecation + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + extend(::Logger::Severity) + extend(::Concurrent::Concern::Logging) + extend(::Concurrent::Concern::Deprecation) + + def deprecated(message, strip = _); end + def deprecated_method(old_name, new_name); end +end + +module Concurrent::Concern::Dereferenceable + def deref; end + def value; end + + protected + + def apply_deref_options(value); end + def ns_set_deref_options(opts); end + def set_deref_options(opts = _); end + def value=(value); end +end + +module Concurrent::Concern::Logging + include(::Logger::Severity) + + def log(level, progname, message = _, &block); end +end + +module Concurrent::Concern::Obligation + include(::Concurrent::Concern::Dereferenceable) + + def complete?; end + def exception(*args); end + def fulfilled?; end + def incomplete?; end + def no_error!(timeout = _); end + def pending?; end + def realized?; end + def reason; end + def rejected?; end + def state; end + def unscheduled?; end + def value(timeout = _); end + def value!(timeout = _); end + def wait(timeout = _); end + def wait!(timeout = _); end + + protected + + def compare_and_set_state(next_state, *expected_current); end + def event; end + def get_arguments_from(opts = _); end + def if_state(*expected_states); end + def init_obligation; end + def ns_check_state?(expected); end + def ns_set_state(value); end + def set_state(success, value, reason); end + def state=(value); end +end + +module Concurrent::Concern::Observable + def add_observer(observer = _, func = _, &block); end + def count_observers; end + def delete_observer(observer); end + def delete_observers; end + def with_observer(observer = _, func = _, &block); end + + protected + + def observers; end + def observers=(_); end +end + +class Concurrent::ConcurrentUpdateError < ::ThreadError +end + +Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array) + +class Concurrent::ConfigurationError < ::Concurrent::Error +end + +class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch +end + +class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject + def initialize(parties, &block); end + + def broken?; end + def number_waiting; end + def parties; end + def reset; end + def wait(timeout = _); end + + protected + + def ns_generation_done(generation, status, continue = _); end + def ns_initialize(parties, &block); end + def ns_next_generation; end +end + +class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject + include(::Concurrent::Concern::Dereferenceable) + include(::Concurrent::Concern::Obligation) + + def initialize(opts = _, &block); end + + def reconfigure(&block); end + def value(timeout = _); end + def value!(timeout = _); end + def wait(timeout = _); end + + protected + + def ns_initialize(opts, &block); end + + private + + def execute_task_once; end +end + +class Concurrent::DependencyCounter + def initialize(count, &block); end + + def update(time, value, reason); end +end + +class Concurrent::Error < ::StandardError +end + +class Concurrent::Event < ::Concurrent::Synchronization::LockableObject + def initialize; end + + def reset; end + def set; end + def set?; end + def try?; end + def wait(timeout = _); end + + protected + + def ns_initialize; end + def ns_set; end +end + +class Concurrent::Exchanger < ::Concurrent::RubyExchanger +end + +module Concurrent::ExecutorService + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + + def <<(task); end + def can_overflow?; end + def post(*args, &task); end + def serialized?; end +end + +class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor + def initialize(num_threads, opts = _); end +end + +class Concurrent::Future < ::Concurrent::IVar + def initialize(opts = _, &block); end + + def cancel; end + def cancelled?; end + def execute; end + def set(value = _, &block); end + def wait_or_cancel(timeout); end + + protected + + def ns_initialize(value, opts); end + + def self.execute(opts = _, &block); end +end + +class Concurrent::Hash < ::Hash +end + +class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject + include(::Concurrent::Concern::Dereferenceable) + include(::Concurrent::Concern::Obligation) + include(::Concurrent::Concern::Observable) + + def initialize(value = _, opts = _, &block); end + + def add_observer(observer = _, func = _, &block); end + def fail(reason = _); end + def set(value = _); end + def try_set(value = _, &block); end + + protected + + def check_for_block_or_value!(block_given, value); end + def complete(success, value, reason); end + def complete_without_notification(success, value, reason); end + def notify_observers(value, reason); end + def ns_complete_without_notification(success, value, reason); end + def ns_initialize(value, opts); end + def safe_execute(task, args = _); end +end + +class Concurrent::IllegalOperationError < ::Concurrent::Error +end + +class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService + include(::Concurrent::SerialExecutorService) + + def initialize; end + + def <<(task); end + def kill; end + def post(*args, &task); end + def running?; end + def shutdown; end + def shutdown?; end + def shuttingdown?; end + def wait_for_termination(timeout = _); end +end + +class Concurrent::ImmutabilityError < ::Concurrent::Error +end + +module Concurrent::ImmutableStruct + include(::Concurrent::Synchronization::AbstractStruct) + + def ==(other); end + def [](member); end + def each(&block); end + def each_pair(&block); end + def inspect; end + def merge(other, &block); end + def select(&block); end + def to_a; end + def to_h; end + def to_s; end + def values; end + def values_at(*indexes); end + + private + + def initialize_copy(original); end + + def self.included(base); end + def self.new(*args, &block); end +end + +class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor + def initialize; end + + def post(*args, &task); end +end + +class Concurrent::InitializationError < ::Concurrent::Error +end + +class Concurrent::LifecycleError < ::Concurrent::Error +end + +class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object + include(::Enumerable) + + def initialize(head = _); end + + def __initialize_atomic_fields__; end + def clear; end + def clear_each(&block); end + def clear_if(head); end + def compare_and_clear(head); end + def compare_and_pop(head); end + def compare_and_push(head, value); end + def each(head = _); end + def empty?(head = _); end + def inspect; end + def peek; end + def pop; end + def push(value); end + def replace_if(head, new_head); end + def to_s; end + + private + + def compare_and_set_head(expected, value); end + def head; end + def head=(value); end + def swap_head(value); end + def update_head(&block); end + + def self.new(*args, &block); end + def self.of1(value); end + def self.of2(value1, value2); end +end + +Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node) + +class Concurrent::LockFreeStack::Node + def initialize(value, next_node); end + + def next_node; end + def value; end + def value=(_); end + + def self.[](*_); end +end + +class Concurrent::MVar < ::Concurrent::Synchronization::Object + include(::Concurrent::Concern::Dereferenceable) + + def initialize(value = _, opts = _); end + + def borrow(timeout = _); end + def empty?; end + def full?; end + def modify(timeout = _); end + def modify!; end + def put(value, timeout = _); end + def set!(value); end + def take(timeout = _); end + def try_put!(value); end + def try_take!; end + + protected + + def synchronize(&block); end + + private + + def unlocked_empty?; end + def unlocked_full?; end + def wait_for_empty(timeout); end + def wait_for_full(timeout); end + def wait_while(condition, timeout); end + + def self.new(*args, &block); end +end + +Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object) + +Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object) + +class Concurrent::Map < ::Concurrent::Collection::MriMapBackend + def initialize(options = _, &block); end + + def [](key); end + def each; end + def each_key; end + def each_pair; end + def each_value; end + def empty?; end + def fetch(key, default_value = _); end + def fetch_or_store(key, default_value = _); end + def get(key); end + def inspect; end + def key(value); end + def keys; end + def marshal_dump; end + def marshal_load(hash); end + def put(key, value); end + def put_if_absent(key, value); end + def value?(value); end + def values; end + + private + + def initialize_copy(other); end + def populate_from(hash); end + def raise_fetch_no_key; end + def validate_options_hash!(options); end +end + +class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error +end + +class Concurrent::Maybe < ::Concurrent::Synchronization::Object + include(::Comparable) + + def initialize(just, nothing); end + + def <=>(other); end + def fulfilled?; end + def just; end + def just?; end + def nothing; end + def nothing?; end + def or(other); end + def reason; end + def rejected?; end + def value; end + + def self.from(*args); end + def self.just(value); end + def self.nothing(error = _); end +end + +Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object) + +class Concurrent::MultipleAssignmentError < ::Concurrent::Error + def initialize(message = _, inspection_data = _); end + + def inspect; end + def inspection_data; end +end + +class Concurrent::MultipleErrors < ::Concurrent::Error + def initialize(errors, message = _); end + + def errors; end +end + +module Concurrent::MutableStruct + include(::Concurrent::Synchronization::AbstractStruct) + + def ==(other); end + def [](member); end + def []=(member, value); end + def each(&block); end + def each_pair(&block); end + def inspect; end + def merge(other, &block); end + def select(&block); end + def to_a; end + def to_h; end + def to_s; end + def values; end + def values_at(*indexes); end + + private + + def initialize_copy(original); end + + def self.new(*args, &block); end +end + +class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject + def initialize(initial = _); end + + def false?; end + def make_false; end + def make_true; end + def true?; end + def value; end + def value=(value); end + + protected + + def ns_initialize(initial); end + + private + + def ns_make_value(value); end +end + +class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject + def initialize(initial = _); end + + def compare_and_set(expect, update); end + def decrement(delta = _); end + def down(delta = _); end + def increment(delta = _); end + def up(delta = _); end + def update; end + def value; end + def value=(value); end + + protected + + def ns_initialize(initial); end + + private + + def ns_set(value); end +end + +class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::LockableObject + include(::Concurrent::AtomicDirectUpdate) + include(::Concurrent::AtomicNumericCompareAndSetWrapper) + + def initialize(value = _); end + + def _compare_and_set(old_value, new_value); end + def compare_and_swap(old_value, new_value); end + def get; end + def get_and_set(new_value); end + def set(new_value); end + def swap(new_value); end + def value; end + def value=(new_value); end + + protected + + def ns_initialize(value); end +end + +class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject + def initialize(count = _); end + + def count; end + def count_down; end + def wait(timeout = _); end + + protected + + def ns_initialize(count); end +end + +class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject + def initialize(count); end + + def acquire(permits = _); end + def available_permits; end + def drain_permits; end + def reduce_permits(reduction); end + def release(permits = _); end + def try_acquire(permits = _, timeout = _); end + + protected + + def ns_initialize(count); end + + private + + def try_acquire_now(permits); end + def try_acquire_timed(permits, timeout); end +end + +Concurrent::NULL = T.let(T.unsafe(nil), Object) + +Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc) + +module Concurrent::Options + def self.executor(executor_identifier); end + def self.executor_from_options(opts = _); end +end + +class Concurrent::Promise < ::Concurrent::IVar + def initialize(opts = _, &block); end + + def catch(&block); end + def execute; end + def fail(reason = _); end + def flat_map(&block); end + def on_error(&block); end + def on_success(&block); end + def rescue(&block); end + def set(value = _, &block); end + def then(*args, &block); end + def zip(*others); end + + protected + + def complete(success, value, reason); end + def notify_child(child); end + def ns_initialize(value, opts); end + def on_fulfill(result); end + def on_reject(reason); end + def realize(task); end + def root?; end + def set_pending; end + def set_state!(success, value, reason); end + def synchronized_set_state!(success, value, reason); end + + def self.aggregate(method, *promises); end + def self.all?(*promises); end + def self.any?(*promises); end + def self.execute(opts = _, &block); end + def self.fulfill(value, opts = _); end + def self.reject(reason, opts = _); end + def self.zip(*promises); end +end + +class Concurrent::PromiseExecutionError < ::StandardError +end + +module Concurrent::Promises + extend(::Concurrent::Promises::FactoryMethods::Configuration) + extend(::Concurrent::Promises::FactoryMethods) +end + +class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object + def initialize(promise, default_executor); end + + def __initialize_atomic_fields__; end + def add_callback_clear_delayed_node(node); end + def add_callback_notify_blocked(promise, index); end + def blocks; end + def callbacks; end + def chain(*args, &task); end + def chain_on(executor, *args, &task); end + def chain_resolvable(resolvable); end + def default_executor; end + def inspect; end + def internal_state; end + def on_resolution(*args, &callback); end + def on_resolution!(*args, &callback); end + def on_resolution_using(executor, *args, &callback); end + def pending?; end + def promise; end + def resolve_with(state, raise_on_reassign = _, reserved = _); end + def resolved?; end + def state; end + def tangle(resolvable); end + def to_s; end + def touch; end + def touched?; end + def wait(timeout = _); end + def waiting_threads; end + def with_default_executor(executor); end + def with_hidden_resolvable; end + + private + + def add_callback(method, *args); end + def async_callback_on_resolution(state, executor, args, callback); end + def call_callback(method, state, args); end + def call_callbacks(state); end + def callback_clear_delayed_node(state, node); end + def callback_notify_blocked(state, promise, index); end + def compare_and_set_internal_state(expected, value); end + def internal_state=(value); end + def swap_internal_state(value); end + def update_internal_state(&block); end + def wait_until_resolved(timeout); end + def with_async(executor, *args, &block); end + + def self.new(*args, &block); end +end + +class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture + def &(other); end + def any(event_or_future); end + def delay; end + def schedule(intended_time); end + def then(*args, &task); end + def to_event; end + def to_future; end + def with_default_executor(executor); end + def zip(other); end + def |(event_or_future); end + + private + + def callback_on_resolution(state, args, callback); end + def rejected_resolution(raise_on_reassign, state); end +end + +module Concurrent::Promises::FactoryMethods + include(::Concurrent::Promises::FactoryMethods::Configuration) + extend(::Concurrent::ReInclude) + extend(::Concurrent::Promises::FactoryMethods) + extend(::Concurrent::Promises::FactoryMethods::Configuration) + + def any(*futures_and_or_events); end + def any_event(*futures_and_or_events); end + def any_event_on(default_executor, *futures_and_or_events); end + def any_fulfilled_future(*futures_and_or_events); end + def any_fulfilled_future_on(default_executor, *futures_and_or_events); end + def any_resolved_future(*futures_and_or_events); end + def any_resolved_future_on(default_executor, *futures_and_or_events); end + def delay(*args, &task); end + def delay_on(default_executor, *args, &task); end + def fulfilled_future(value, default_executor = _); end + def future(*args, &task); end + def future_on(default_executor, *args, &task); end + def make_future(argument = _, default_executor = _); end + def rejected_future(reason, default_executor = _); end + def resolvable_event; end + def resolvable_event_on(default_executor = _); end + def resolvable_future; end + def resolvable_future_on(default_executor = _); end + def resolved_event(default_executor = _); end + def resolved_future(fulfilled, value, reason, default_executor = _); end + def schedule(intended_time, *args, &task); end + def schedule_on(default_executor, intended_time, *args, &task); end + def zip(*futures_and_or_events); end + def zip_events(*futures_and_or_events); end + def zip_events_on(default_executor, *futures_and_or_events); end + def zip_futures(*futures_and_or_events); end + def zip_futures_on(default_executor, *futures_and_or_events); end +end + +module Concurrent::Promises::FactoryMethods::Configuration + def default_executor; end +end + +class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture + def &(other); end + def any(event_or_future); end + def apply(args, block); end + def delay; end + def exception(*args); end + def flat(level = _); end + def flat_event; end + def flat_future(level = _); end + def fulfilled?; end + def inspect; end + def on_fulfillment(*args, &callback); end + def on_fulfillment!(*args, &callback); end + def on_fulfillment_using(executor, *args, &callback); end + def on_rejection(*args, &callback); end + def on_rejection!(*args, &callback); end + def on_rejection_using(executor, *args, &callback); end + def reason(timeout = _, timeout_value = _); end + def rejected?; end + def rescue(*args, &task); end + def rescue_on(executor, *args, &task); end + def result(timeout = _); end + def run(run_test = _); end + def schedule(intended_time); end + def then(*args, &task); end + def then_on(executor, *args, &task); end + def to_event; end + def to_future; end + def to_s; end + def value(timeout = _, timeout_value = _); end + def value!(timeout = _, timeout_value = _); end + def wait!(timeout = _); end + def with_default_executor(executor); end + def zip(other); end + def |(event_or_future); end + + private + + def async_callback_on_fulfillment(state, executor, args, callback); end + def async_callback_on_rejection(state, executor, args, callback); end + def callback_on_fulfillment(state, args, callback); end + def callback_on_rejection(state, args, callback); end + def callback_on_resolution(state, args, callback); end + def rejected_resolution(raise_on_reassign, state); end + def run_test(v); end + def wait_until_resolved!(timeout = _); end +end + +module Concurrent::Promises::Resolvable +end + +class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event + include(::Concurrent::Promises::Resolvable) + + def resolve(raise_on_reassign = _, reserved = _); end + def wait(timeout = _, resolve_on_timeout = _); end + def with_hidden_resolvable; end +end + +class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future + include(::Concurrent::Promises::Resolvable) + + def evaluate_to(*args, &block); end + def evaluate_to!(*args, &block); end + def fulfill(value, raise_on_reassign = _, reserved = _); end + def reason(timeout = _, timeout_value = _, resolve_on_timeout = _); end + def reject(reason, raise_on_reassign = _, reserved = _); end + def resolve(fulfilled = _, value = _, reason = _, raise_on_reassign = _, reserved = _); end + def result(timeout = _, resolve_on_timeout = _); end + def value(timeout = _, timeout_value = _, resolve_on_timeout = _); end + def value!(timeout = _, timeout_value = _, resolve_on_timeout = _); end + def wait(timeout = _, resolve_on_timeout = _); end + def wait!(timeout = _, resolve_on_timeout = _); end + def with_hidden_resolvable; end +end + +module Concurrent::ReInclude + def extended(base); end + def include(*modules); end + def included(base); end +end + +class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object + def initialize; end + + def acquire_read_lock; end + def acquire_write_lock; end + def has_waiters?; end + def release_read_lock; end + def release_write_lock; end + def with_read_lock; end + def with_write_lock; end + def write_locked?; end + + private + + def max_readers?(c = _); end + def max_writers?(c = _); end + def running_readers(c = _); end + def running_readers?(c = _); end + def running_writer?(c = _); end + def waiting_writer?(c = _); end + def waiting_writers(c = _); end + + def self.new(*args, &block); end +end + +Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer) + +Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer) + +class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object + def initialize; end + + def acquire_read_lock; end + def acquire_write_lock; end + def release_read_lock; end + def release_write_lock; end + def try_read_lock; end + def try_write_lock; end + def with_read_lock; end + def with_write_lock; end + + private + + def max_readers?(c = _); end + def max_writers?(c = _); end + def running_readers(c = _); end + def running_readers?(c = _); end + def running_writer?(c = _); end + def waiting_or_running_writer?(c = _); end + def waiting_writers(c = _); end + + def self.new(*args, &block); end +end + +Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer) + +Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer) + +class Concurrent::RejectedExecutionError < ::Concurrent::Error +end + +class Concurrent::ResourceLimitError < ::Concurrent::Error +end + +class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger + def initialize; end + + def __initialize_atomic_fields__; end + def compare_and_set_slot(expected, value); end + def slot; end + def slot=(value); end + def swap_slot(value); end + def update_slot(&block); end + + private + + def do_exchange(value, timeout); end + + def self.new(*args, &block); end +end + +class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService + def initialize(*args, &block); end + + def kill; end + def post(*args, &task); end + def shutdown; end + def wait_for_termination(timeout = _); end + + private + + def ns_running?; end + def ns_shutdown?; end + def ns_shutdown_execution; end + def ns_shuttingdown?; end + def stop_event; end + def stopped_event; end +end + +class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor + def initialize(opts = _); end +end + +class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar + def value; end + def value=(value); end + + protected + + def allocate_storage; end + + private + + def get_default; end + def get_threadlocal_array(thread = _); end + def set_threadlocal_array(array, thread = _); end + def value_for(thread); end + + def self.thread_finalizer(id); end + def self.thread_local_finalizer(index); end +end + +class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService + def initialize(opts = _); end + + def can_overflow?; end + def completed_task_count; end + def idletime; end + def largest_length; end + def length; end + def max_length; end + def max_queue; end + def min_length; end + def queue_length; end + def ready_worker(worker); end + def remaining_capacity; end + def remove_busy_worker(worker); end + def scheduled_task_count; end + def worker_died(worker); end + def worker_not_old_enough(worker); end + def worker_task_completed; end + + private + + def ns_add_busy_worker; end + def ns_assign_worker(*args, &task); end + def ns_enqueue(*args, &task); end + def ns_execute(*args, &task); end + def ns_initialize(opts); end + def ns_kill_execution; end + def ns_limited_queue?; end + def ns_prune_pool; end + def ns_ready_worker(worker, success = _); end + def ns_remove_busy_worker(worker); end + def ns_reset_if_forked; end + def ns_shutdown_execution; end + def ns_worker_died(worker); end + def ns_worker_not_old_enough(worker); end +end + +Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer) + +Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer) + +Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer) + +Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer) + +class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject + def initialize(task, opts = _); end + + def execute(*args); end +end + +class Concurrent::ScheduledTask < ::Concurrent::IVar + include(::Comparable) + + def initialize(delay, opts = _, &task); end + + def <=>(other); end + def cancel; end + def cancelled?; end + def execute; end + def executor; end + def initial_delay; end + def process_task; end + def processing?; end + def reschedule(delay); end + def reset; end + def schedule_time; end + + protected + + def ns_reschedule(delay); end + def ns_schedule(delay); end + + def self.execute(delay, opts = _, &task); end +end + +class Concurrent::Semaphore < ::Concurrent::MutexSemaphore +end + +module Concurrent::SerialExecutorService + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + include(::Concurrent::ExecutorService) + + def serialized?; end +end + +class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + + def initialize; end + + def post(executor, *args, &task); end + def posts(posts); end + + private + + def call_job(job); end + def ns_initialize; end + def work(job); end +end + +class Concurrent::SerializedExecution::Job < ::Struct + def args; end + def args=(_); end + def block; end + def block=(_); end + def call; end + def executor; end + def executor=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator + include(::Logger::Severity) + include(::Concurrent::Concern::Logging) + include(::Concurrent::ExecutorService) + include(::Concurrent::SerialExecutorService) + + def initialize(executor); end + + def post(*args, &task); end +end + +class Concurrent::Set < ::Set +end + +module Concurrent::SettableStruct + include(::Concurrent::Synchronization::AbstractStruct) + + def ==(other); end + def [](member); end + def []=(member, value); end + def each(&block); end + def each_pair(&block); end + def inspect; end + def merge(other, &block); end + def select(&block); end + def to_a; end + def to_h; end + def to_s; end + def values; end + def values_at(*indexes); end + + private + + def initialize_copy(original); end + + def self.new(*args, &block); end +end + +class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService + def <<(task); end + def kill; end + def post(*args, &task); end + def running?; end + def shutdown; end + def shutdown?; end + def shuttingdown?; end + def wait_for_termination(timeout = _); end + + private + + def ns_initialize(*args); end + + def self.<<(task); end + def self.post(*args); end +end + +class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor +end + +module Concurrent::Synchronization +end + +class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object + + protected + + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = _); end + def ns_wait_until(timeout = _, &condition); end + def synchronize; end +end + +class Concurrent::Synchronization::AbstractObject + def initialize; end + + def full_memory_barrier; end + + def self.attr_volatile(*names); end +end + +module Concurrent::Synchronization::AbstractStruct + def initialize(*values); end + + def length; end + def members; end + def size; end + + protected + + def ns_each; end + def ns_each_pair; end + def ns_equality(other); end + def ns_get(member); end + def ns_initialize_copy; end + def ns_inspect; end + def ns_merge(other, &block); end + def ns_select; end + def ns_to_h; end + def ns_values; end + def ns_values_at(indexes); end + def pr_underscore(clazz); end + + def self.define_struct_class(parent, base, name, members, &block); end +end + +class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject + def initialize(lock); end + + def broadcast; end + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = _); end + def ns_wait_until(timeout = _, &condition); end + def signal; end + def wait(timeout = _); end + def wait_until(timeout = _, &condition); end + + def self.private_new(*args, &block); end +end + +module Concurrent::Synchronization::ConditionSignalling + + protected + + def ns_broadcast; end + def ns_signal; end +end + +class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject + def broadcast; end + def signal; end + def wait(timeout = _); end + def wait_until(timeout = _, &condition); end +end + +class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject + def new_condition; end +end + +class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject + include(::Concurrent::Synchronization::ConditionSignalling) + + def initialize(*defaults); end + + + protected + + def ns_wait(timeout = _); end + def synchronize; end + + def self.new(*args, &block); end +end + +module Concurrent::Synchronization::MriAttrVolatile + mixes_in_class_methods(::Concurrent::Synchronization::MriAttrVolatile::ClassMethods) + + def full_memory_barrier; end + + def self.included(base); end +end + +module Concurrent::Synchronization::MriAttrVolatile::ClassMethods + def attr_volatile(*names); end +end + +class Concurrent::Synchronization::MriObject < ::Concurrent::Synchronization::AbstractObject + include(::Concurrent::Synchronization::MriAttrVolatile) + extend(::Concurrent::Synchronization::MriAttrVolatile::ClassMethods) + + def initialize; end +end + +class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject + include(::Concurrent::Synchronization::ConditionSignalling) + + def initialize(*defaults); end + + + protected + + def ns_wait(timeout = _); end + def synchronize; end + + def self.new(*args, &block); end +end + +class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject + def initialize; end + + + private + + def __initialize_atomic_fields__; end + + def self.atomic_attribute?(name); end + def self.atomic_attributes(inherited = _); end + def self.attr_atomic(*names); end + def self.ensure_safe_initialization_when_final_fields_are_present; end + def self.safe_initialization!; end + def self.safe_initialization?; end +end + +module Concurrent::Synchronization::RbxAttrVolatile + mixes_in_class_methods(::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods) + + def full_memory_barrier; end + + def self.included(base); end +end + +module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods + def attr_volatile(*names); end +end + +class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchronization::AbstractLockableObject + def initialize(*defaults); end + + + protected + + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = _); end + def synchronize(&block); end + + def self.new(*args, &block); end +end + +class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject + include(::Concurrent::Synchronization::RbxAttrVolatile) + extend(::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods) + + def initialize; end +end + +module Concurrent::Synchronization::TruffleRubyAttrVolatile + mixes_in_class_methods(::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods) + + def full_memory_barrier; end + + def self.included(base); end +end + +module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods + def attr_volatile(*names); end +end + +class Concurrent::Synchronization::TruffleRubyObject < ::Concurrent::Synchronization::AbstractObject + include(::Concurrent::Synchronization::TruffleRubyAttrVolatile) + extend(::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods) + + def initialize; end +end + +Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile + +class Concurrent::SynchronizedDelegator < ::SimpleDelegator + def initialize(obj); end + + def method_missing(method, *args, &block); end + def setup; end + def teardown; end +end + +class Concurrent::TVar < ::Concurrent::Synchronization::Object + def initialize(value); end + + def unsafe_increment_version; end + def unsafe_lock; end + def unsafe_value; end + def unsafe_value=(value); end + def unsafe_version; end + def value; end + def value=(value); end + + def self.new(*args, &block); end +end + +class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar +end + +class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor +end + +module Concurrent::ThreadSafe +end + +module Concurrent::ThreadSafe::Util +end + +Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer) + +Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer) + +Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer) + +class Concurrent::TimeoutError < ::Concurrent::Error +end + +class Concurrent::TimerSet < ::Concurrent::RubyExecutorService + def initialize(opts = _); end + + def kill; end + def post(delay, *args, &task); end + + private + + def ns_initialize(opts); end + def ns_post_task(task); end + def ns_reset_if_forked; end + def ns_shutdown_execution; end + def post_task(task); end + def process_tasks; end + def remove_task(task); end +end + +class Concurrent::TimerTask < ::Concurrent::RubyExecutorService + include(::Concurrent::Concern::Dereferenceable) + include(::Concurrent::Concern::Observable) + + def initialize(opts = _, &task); end + + def execute; end + def execution_interval; end + def execution_interval=(value); end + def running?; end + def timeout_interval; end + def timeout_interval=(value); end + + private + + def execute_task(completion); end + def ns_initialize(opts, &task); end + def ns_kill_execution; end + def ns_shutdown_execution; end + def schedule_next_task(interval = _); end + def timeout_task(completion); end + + def self.execute(opts = _, &task); end +end + +Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer) + +Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer) + +class Concurrent::Transaction + def initialize; end + + def abort; end + def commit; end + def read(tvar); end + def unlock; end + def valid?; end + def write(tvar, value); end + + def self.current; end + def self.current=(transaction); end +end + +Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object) + +class Concurrent::Transaction::AbortError < ::StandardError +end + +class Concurrent::Transaction::LeaveError < ::StandardError +end + +class Concurrent::Transaction::ReadLogEntry < ::Struct + def tvar; end + def tvar=(_); end + def version; end + def version=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class Concurrent::Tuple + include(::Enumerable) + + def initialize(size); end + + def cas(i, old_value, new_value); end + def compare_and_set(i, old_value, new_value); end + def each; end + def get(i); end + def set(i, value); end + def size; end + def volatile_get(i); end + def volatile_set(i, value); end +end + +module Concurrent::Utility +end + +module Concurrent::Utility::EngineDetector + def on_cruby?; end + def on_jruby?; end + def on_jruby_9000?; end + def on_linux?; end + def on_osx?; end + def on_rbx?; end + def on_truffleruby?; end + def on_windows?; end + def ruby_engine; end + def ruby_version(version = _, comparison, major, minor, patch); end +end + +module Concurrent::Utility::NativeExtensionLoader + def allow_c_extensions?; end + def c_extensions_loaded?; end + def java_extensions_loaded?; end + def load_native_extensions; end + + private + + def load_error_path(error); end + def set_c_extensions_loaded; end + def set_java_extensions_loaded; end + def try_load_c_extension(path); end +end + +module Concurrent::Utility::NativeInteger + extend(::Concurrent::Utility::NativeInteger) + + def ensure_integer(value); end + def ensure_integer_and_bounds(value); end + def ensure_lower_bound(value); end + def ensure_positive(value); end + def ensure_positive_and_no_zero(value); end + def ensure_upper_bound(value); end +end + +Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer) + +Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer) + +class Concurrent::Utility::ProcessorCounter + def initialize; end + + def physical_processor_count; end + def processor_count; end + + private + + def compute_physical_processor_count; end + def compute_processor_count; end +end + +Concurrent::VERSION = T.let(T.unsafe(nil), String) + +Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), T.untyped) + +Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), T.untyped) + +Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), T.untyped) diff --git a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi new file mode 100644 index 0000000000..8403f393d9 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi @@ -0,0 +1,65 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class ConnectionPool + def initialize(options = _, &block); end + + def available; end + def checkin; end + def checkout(options = _); end + def shutdown(&block); end + def size; end + def with(options = _); end + + def self.wrap(options, &block); end +end + +ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash) + +class ConnectionPool::Error < ::RuntimeError +end + +class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error +end + +class ConnectionPool::TimedStack + def initialize(size = _, &block); end + + def <<(obj, options = _); end + def empty?; end + def length; end + def max; end + def pop(timeout = _, options = _); end + def push(obj, options = _); end + def shutdown(&block); end + + private + + def connection_stored?(options = _); end + def current_time; end + def fetch_connection(options = _); end + def shutdown_connections(options = _); end + def store_connection(obj, options = _); end + def try_create(options = _); end +end + +class ConnectionPool::TimeoutError < ::Timeout::Error +end + +ConnectionPool::VERSION = T.let(T.unsafe(nil), String) + +class ConnectionPool::Wrapper < ::BasicObject + def initialize(options = _, &block); end + + def method_missing(name, *args, &block); end + def pool_available; end + def pool_shutdown(&block); end + def pool_size; end + def respond_to?(id, *args); end + def with(&block); end + def wrapped_pool; end +end + +ConnectionPool::Wrapper::METHODS = T.let(T.unsafe(nil), Array) diff --git a/Library/Homebrew/sorbet/rbi/gems/coveralls@0.8.23.rbi b/Library/Homebrew/sorbet/rbi/gems/coveralls@0.8.23.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/coveralls@0.8.23.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi b/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi new file mode 100644 index 0000000000..038b65157b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi @@ -0,0 +1,88 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class DomainName + def initialize(hostname); end + + def <(other); end + def <=(other); end + def <=>(other); end + def ==(other); end + def >(other); end + def >=(other); end + def canonical?; end + def canonical_tld?; end + def cookie_domain?(domain, host_only = _); end + def domain; end + def domain_idn; end + def hostname; end + def hostname_idn; end + def idn; end + def inspect; end + def ipaddr; end + def ipaddr?; end + def superdomain; end + def tld; end + def tld_idn; end + def to_s; end + def to_str; end + def uri_host; end + + def self.etld_data; end + def self.normalize(domain); end +end + +DomainName::DOT = T.let(T.unsafe(nil), String) + +DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash) + +DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String) + +module DomainName::Punycode + def self.decode(string); end + def self.decode_hostname(hostname); end + def self.encode(string); end + def self.encode_hostname(hostname); end +end + +class DomainName::Punycode::ArgumentError < ::ArgumentError +end + +DomainName::Punycode::BASE = T.let(T.unsafe(nil), Integer) + +class DomainName::Punycode::BufferOverflowError < ::DomainName::Punycode::ArgumentError +end + +DomainName::Punycode::CUTOFF = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::DAMP = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::DECODE_DIGIT = T.let(T.unsafe(nil), Hash) + +DomainName::Punycode::DELIMITER = T.let(T.unsafe(nil), String) + +DomainName::Punycode::DOT = T.let(T.unsafe(nil), String) + +DomainName::Punycode::ENCODE_DIGIT = T.let(T.unsafe(nil), Proc) + +DomainName::Punycode::INITIAL_BIAS = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::INITIAL_N = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::LOBASE = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::MAXINT = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::PREFIX = T.let(T.unsafe(nil), String) + +DomainName::Punycode::RE_NONBASIC = T.let(T.unsafe(nil), Regexp) + +DomainName::Punycode::SKEW = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::TMAX = T.let(T.unsafe(nil), Integer) + +DomainName::Punycode::TMIN = T.let(T.unsafe(nil), Integer) + +DomainName::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi new file mode 100644 index 0000000000..8f325c0eae --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi @@ -0,0 +1,216 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module HTTP +end + +class HTTP::Cookie + include(::Mechanize::CookieDeprecated) + include(::Mechanize::CookieIMethods) + include(::Comparable) + extend(::Mechanize::CookieDeprecated) + extend(::Mechanize::CookieCMethods) + + def initialize(*args); end + + def <=>(other); end + def acceptable?; end + def acceptable_from_uri?(uri); end + def accessed_at; end + def accessed_at=(_); end + def cookie_value; end + def created_at; end + def created_at=(_); end + def domain; end + def domain=(domain); end + def domain_name; end + def dot_domain; end + def encode_with(coder); end + def expire!; end + def expired?(time = _); end + def expires; end + def expires=(t); end + def expires_at; end + def expires_at=(t); end + def for_domain; end + def for_domain=(_); end + def for_domain?; end + def httponly; end + def httponly=(_); end + def httponly?; end + def init_with(coder); end + def inspect; end + def max_age; end + def max_age=(sec); end + def name; end + def name=(name); end + def origin; end + def origin=(origin); end + def path; end + def path=(path); end + def secure; end + def secure=(_); end + def secure?; end + def session; end + def session?; end + def set_cookie_value; end + def to_s; end + def to_yaml_properties; end + def valid_for_uri?(uri); end + def value; end + def value=(value); end + def yaml_initialize(tag, map); end + + def self.cookie_value(cookies); end + def self.cookie_value_to_hash(cookie_value); end + def self.path_match?(base_path, target_path); end +end + +HTTP::Cookie::MAX_COOKIES_PER_DOMAIN = T.let(T.unsafe(nil), Integer) + +HTTP::Cookie::MAX_COOKIES_TOTAL = T.let(T.unsafe(nil), Integer) + +HTTP::Cookie::MAX_LENGTH = T.let(T.unsafe(nil), Integer) + +HTTP::Cookie::PERSISTENT_PROPERTIES = T.let(T.unsafe(nil), Array) + +class HTTP::Cookie::Scanner < ::StringScanner + def initialize(string, logger = _); end + + def parse_cookie_date(s); end + def scan_cookie; end + def scan_dquoted; end + def scan_name; end + def scan_name_value(comma_as_separator = _); end + def scan_set_cookie; end + def scan_value(comma_as_separator = _); end + def skip_wsp; end + + private + + def tuple_to_time(day_of_month, month, year, time); end + + def self.quote(s); end +end + +HTTP::Cookie::Scanner::RE_BAD_CHAR = T.let(T.unsafe(nil), Regexp) + +HTTP::Cookie::Scanner::RE_COOKIE_COMMA = T.let(T.unsafe(nil), Regexp) + +HTTP::Cookie::Scanner::RE_NAME = T.let(T.unsafe(nil), Regexp) + +HTTP::Cookie::Scanner::RE_WSP = T.let(T.unsafe(nil), Regexp) + +HTTP::Cookie::UNIX_EPOCH = T.let(T.unsafe(nil), Time) + +HTTP::Cookie::VERSION = T.let(T.unsafe(nil), String) + +class HTTP::CookieJar + include(::Mechanize::CookieDeprecated) + include(::Mechanize::CookieJarIMethods) + include(::Enumerable) + + def initialize(options = _); end + + def <<(cookie); end + def cleanup(session = _); end + def clear; end + def cookies(url = _); end + def delete(cookie); end + def each(uri = _, &block); end + def empty?(url = _); end + def load(readable, *options); end + def parse(set_cookie, origin, options = _); end + def save(writable, *options); end + def store; end + + private + + def get_impl(base, value, *args); end + def initialize_copy(other); end + + def self.const_missing(name); end +end + +class HTTP::CookieJar::AbstractSaver + def initialize(options = _); end + + def load(io, jar); end + def save(io, jar); end + + private + + def default_options; end + + def self.class_to_symbol(klass); end + def self.implementation(symbol); end + def self.inherited(subclass); end +end + +class HTTP::CookieJar::YAMLSaver < ::HTTP::CookieJar::AbstractSaver + def load(io, jar); end + def save(io, jar); end + + private + + def default_options; end +end + +class HTTP::CookieJar::AbstractStore + include(::MonitorMixin) + include(::Enumerable) + + def initialize(options = _); end + + def add(cookie); end + def cleanup(session = _); end + def clear; end + def delete(cookie); end + def each(uri = _, &block); end + def empty?; end + + private + + def default_options; end + def initialize_copy(other); end + + def self.class_to_symbol(klass); end + def self.implementation(symbol); end + def self.inherited(subclass); end +end + +class HTTP::CookieJar::CookiestxtSaver < ::HTTP::CookieJar::AbstractSaver + def load(io, jar); end + def save(io, jar); end + + private + + def cookie_to_record(cookie); end + def default_options; end + def parse_record(line); end +end + +HTTP::CookieJar::CookiestxtSaver::False = T.let(T.unsafe(nil), String) + +HTTP::CookieJar::CookiestxtSaver::HTTPONLY_PREFIX = T.let(T.unsafe(nil), String) + +HTTP::CookieJar::CookiestxtSaver::RE_HTTPONLY_PREFIX = T.let(T.unsafe(nil), Regexp) + +HTTP::CookieJar::CookiestxtSaver::True = T.let(T.unsafe(nil), String) + +class HTTP::CookieJar::HashStore < ::HTTP::CookieJar::AbstractStore + def initialize(options = _); end + + def add(cookie); end + def cleanup(session = _); end + def clear; end + def default_options; end + def delete(cookie); end + def each(uri = _); end + + private + + def initialize_copy(other); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/json@2.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/json@2.3.0.rbi new file mode 100644 index 0000000000..c230680172 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/json@2.3.0.rbi @@ -0,0 +1,87 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class Class < ::Module + def json_creatable?; end +end + +module JSON + + private + + def dump(obj, anIO = _, limit = _); end + def fast_generate(obj, opts = _); end + def fast_unparse(obj, opts = _); end + def generate(obj, opts = _); end + def load(source, proc = _, options = _); end + def parse(source, opts = _); end + def parse!(source, opts = _); end + def pretty_generate(obj, opts = _); end + def pretty_unparse(obj, opts = _); end + def recurse_proc(result, &proc); end + def restore(source, proc = _, options = _); end + def unparse(obj, opts = _); end + + def self.[](object, opts = _); end + def self.create_id; end + def self.create_id=(_); end + def self.deep_const_get(path); end + def self.dump(obj, anIO = _, limit = _); end + def self.dump_default_options; end + def self.dump_default_options=(_); end + def self.fast_generate(obj, opts = _); end + def self.fast_unparse(obj, opts = _); end + def self.generate(obj, opts = _); end + def self.generator; end + def self.generator=(generator); end + def self.iconv(to, from, string); end + def self.load(source, proc = _, options = _); end + def self.load_default_options; end + def self.load_default_options=(_); end + def self.parse(source, opts = _); end + def self.parse!(source, opts = _); end + def self.parser; end + def self.parser=(parser); end + def self.pretty_generate(obj, opts = _); end + def self.pretty_unparse(obj, opts = _); end + def self.recurse_proc(result, &proc); end + def self.restore(source, proc = _, options = _); end + def self.state; end + def self.state=(_); end + def self.unparse(obj, opts = _); end +end + +class JSON::GenericObject < ::OpenStruct + def as_json(*_); end + def to_hash; end + def to_json(*a); end + def |(other); end + + def self.dump(obj, *args); end + def self.from_hash(object); end + def self.json_creatable=(_); end + def self.json_creatable?; end + def self.json_create(data); end + def self.load(source, proc = _, opts = _); end +end + +class JSON::JSONError < ::StandardError + def self.wrap(exception); end +end + +JSON::Parser = JSON::Ext::Parser + +JSON::State = JSON::Ext::Generator::State + +JSON::UnparserError = JSON::GeneratorError + +module Kernel + + private + + def JSON(object, *args); end + def j(*objs); end + def jj(*objs); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi new file mode 100644 index 0000000000..cec901fc1d --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.7.6.rbi @@ -0,0 +1,1122 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class HTTP::CookieJar + include(::Mechanize::CookieDeprecated) + include(::Mechanize::CookieJarIMethods) + include(::Enumerable) + + def initialize(options = _); end + + def <<(cookie); end + def cleanup(session = _); end + def clear; end + def cookies(url = _); end + def delete(cookie); end + def each(uri = _, &block); end + def empty?(url = _); end + def load(readable, *options); end + def parse(set_cookie, origin, options = _); end + def save(writable, *options); end + def store; end + + private + + def get_impl(base, value, *args); end + def initialize_copy(other); end + + def self.const_missing(name); end +end + +class Mechanize + def initialize(connection_name = _); end + + def add_auth(uri, user, password, realm = _, domain = _); end + def agent; end + def auth(user, password, domain = _); end + def back; end + def basic_auth(user, password, domain = _); end + def ca_file; end + def ca_file=(ca_file); end + def cert; end + def cert=(cert); end + def cert_store; end + def cert_store=(cert_store); end + def certificate; end + def click(link); end + def conditional_requests; end + def conditional_requests=(enabled); end + def content_encoding_hooks; end + def cookie_jar; end + def cookie_jar=(cookie_jar); end + def cookies; end + def current_page; end + def default_encoding; end + def default_encoding=(_); end + def delete(uri, query_params = _, headers = _); end + def download(uri, io_or_filename, parameters = _, referer = _, headers = _); end + def follow_meta_refresh; end + def follow_meta_refresh=(follow); end + def follow_meta_refresh_self; end + def follow_meta_refresh_self=(follow); end + def follow_redirect=(follow); end + def follow_redirect?; end + def force_default_encoding; end + def force_default_encoding=(_); end + def get(uri, parameters = _, referer = _, headers = _); end + def get_file(url); end + def gzip_enabled; end + def gzip_enabled=(enabled); end + def head(uri, query_params = _, headers = _); end + def history; end + def history_added; end + def history_added=(_); end + def html_parser; end + def html_parser=(_); end + def idle_timeout; end + def idle_timeout=(idle_timeout); end + def ignore_bad_chunking; end + def ignore_bad_chunking=(ignore_bad_chunking); end + def keep_alive; end + def keep_alive=(enable); end + def keep_alive_time; end + def keep_alive_time=(_); end + def key; end + def key=(key); end + def log; end + def log=(logger); end + def max_file_buffer; end + def max_file_buffer=(bytes); end + def max_history; end + def max_history=(length); end + def open_timeout; end + def open_timeout=(open_timeout); end + def page; end + def parse(uri, response, body); end + def pass; end + def pass=(pass); end + def pluggable_parser; end + def post(uri, query = _, headers = _); end + def post_connect_hooks; end + def pre_connect_hooks; end + def pretty_print(q); end + def proxy_addr; end + def proxy_pass; end + def proxy_port; end + def proxy_user; end + def put(uri, entity, headers = _); end + def read_timeout; end + def read_timeout=(read_timeout); end + def redirect_ok; end + def redirect_ok=(follow); end + def redirection_limit; end + def redirection_limit=(limit); end + def request_headers; end + def request_headers=(request_headers); end + def request_with_entity(verb, uri, entity, headers = _); end + def reset; end + def resolve(link); end + def retry_change_requests; end + def retry_change_requests=(retry_change_requests); end + def robots; end + def robots=(enabled); end + def scheme_handlers; end + def scheme_handlers=(scheme_handlers); end + def set_proxy(address, port, user = _, password = _); end + def shutdown; end + def ssl_version; end + def ssl_version=(ssl_version); end + def submit(form, button = _, headers = _); end + def transact; end + def user_agent; end + def user_agent=(user_agent); end + def user_agent_alias=(name); end + def verify_callback; end + def verify_callback=(verify_callback); end + def verify_mode; end + def verify_mode=(verify_mode); end + def visited?(url); end + def visited_page(url); end + def watch_for_set; end + def watch_for_set=(_); end + + private + + def add_to_history(page); end + def post_form(uri, form, headers = _); end + + def self.html_parser; end + def self.html_parser=(_); end + def self.inherited(child); end + def self.log; end + def self.log=(_); end + def self.start; end +end + +Mechanize::AGENT_ALIASES = T.let(T.unsafe(nil), Hash) + +class Mechanize::ChunkedTerminationError < ::Mechanize::ResponseReadError +end + +class Mechanize::ContentTypeError < ::Mechanize::Error + def initialize(content_type); end + + def content_type; end +end + +Mechanize::Cookie = HTTP::Cookie + +module Mechanize::CookieCMethods + include(::Mechanize::CookieDeprecated) + + def parse(arg1, arg2, arg3 = _, &block); end +end + +module Mechanize::CookieDeprecated + + private + + def __deprecated__(to = _); end +end + +module Mechanize::CookieIMethods + include(::Mechanize::CookieDeprecated) + + def set_domain(domain); end +end + +class Mechanize::CookieJar < ::HTTP::CookieJar + def load(input, *options); end + def save(output, *options); end +end + +module Mechanize::CookieJarIMethods + include(::Mechanize::CookieDeprecated) + + def add(arg1, arg2 = _); end + def add!(cookie); end + def clear!; end + def dump_cookiestxt(io); end + def jar; end + def load_cookiestxt(io); end + def save_as(filename, *options); end +end + +class Mechanize::DirectorySaver < ::Mechanize::Download + def initialize(uri = _, response = _, body_io = _, code = _); end + + def self.decode_filename?; end + def self.directory; end + def self.overwrite?; end + def self.save_to(directory, options = _); end +end + +class Mechanize::Download + include(::Mechanize::Parser) + + def initialize(uri = _, response = _, body_io = _, code = _); end + + def body; end + def body_io; end + def content; end + def filename; end + def filename=(_); end + def save(filename = _); end + def save!(filename = _); end + def save_as(filename = _); end +end + +module Mechanize::ElementMatcher + def elements_with(singular, plural = _); end +end + +class Mechanize::ElementNotFoundError < ::Mechanize::Error + def initialize(source, element, conditions); end + + def conditions; end + def element; end + def source; end +end + +class Mechanize::Error < ::RuntimeError +end + +class Mechanize::File + include(::Mechanize::Parser) + + def initialize(uri = _, response = _, body = _, code = _); end + + def body; end + def body=(_); end + def content; end + def filename; end + def filename=(_); end + def save(filename = _); end + def save!(filename = _); end + def save_as(filename = _); end +end + +class Mechanize::FileConnection + def request(uri, request); end + + def self.new(*a); end +end + +class Mechanize::FileRequest + def initialize(uri); end + + def []=(*a); end + def add_field(*a); end + def each_header; end + def path; end + def response_body_permitted?; end + def uri; end + def uri=(_); end +end + +class Mechanize::FileResponse + def initialize(file_path); end + + def [](key); end + def code; end + def content_length; end + def each; end + def each_header; end + def get_fields(key); end + def http_version; end + def message; end + def read_body; end + def uri; end + + private + + def dir_body; end + def directory?; end +end + +class Mechanize::FileSaver < ::Mechanize::Download + def initialize(uri = _, response = _, body_io = _, code = _); end + + def filename; end + def save_as(filename = _); end +end + +class Mechanize::Form + extend(::Forwardable) + extend(::Mechanize::ElementMatcher) + + def initialize(node, mech = _, page = _); end + + def [](field_name); end + def []=(field_name, value); end + def action; end + def action=(_); end + def add_button_to_query(button); end + def add_field!(field_name, value = _); end + def at(*args, &block); end + def at_css(*args, &block); end + def at_xpath(*args, &block); end + def build_query(buttons = _); end + def button(criteria = _); end + def button_with(criteria = _); end + def button_with!(criteria = _); end + def buttons; end + def buttons_with(criteria = _); end + def checkbox(criteria = _); end + def checkbox_with(criteria = _); end + def checkbox_with!(criteria = _); end + def checkboxes; end + def checkboxes_with(criteria = _); end + def click_button(button = _); end + def css(*args, &block); end + def delete_field!(field_name); end + def dom_class; end + def dom_id; end + def elements; end + def encoding; end + def encoding=(_); end + def enctype; end + def enctype=(_); end + def field(criteria = _); end + def field_with(criteria = _); end + def field_with!(criteria = _); end + def fields; end + def fields_with(criteria = _); end + def file_upload(criteria = _); end + def file_upload_with(criteria = _); end + def file_upload_with!(criteria = _); end + def file_uploads; end + def file_uploads_with(criteria = _); end + def form_node; end + def has_field?(field_name); end + def has_key?(field_name); end + def has_value?(value); end + def hidden_field?(field_name); end + def hiddens; end + def ignore_encoding_error; end + def ignore_encoding_error=(_); end + def inspect; end + def keygens; end + def keys; end + def method; end + def method=(_); end + def method_missing(meth, *args); end + def name; end + def name=(_); end + def node; end + def page; end + def pretty_print(q); end + def radiobutton(criteria = _); end + def radiobutton_with(criteria = _); end + def radiobutton_with!(criteria = _); end + def radiobuttons; end + def radiobuttons_with(criteria = _); end + def request_data; end + def reset; end + def reset_button?(button_name); end + def resets; end + def save_hash_field_order; end + def search(*args, &block); end + def select_buttons(selector, method = _); end + def select_checkboxes(selector, method = _); end + def select_fields(selector, method = _); end + def select_file_uploads(selector, method = _); end + def select_radiobuttons(selector, method = _); end + def set_fields(fields = _); end + def submit(button = _, headers = _); end + def submit_button?(button_name); end + def submits; end + def text_field?(field_name); end + def textarea_field?(field_name); end + def textareas; end + def texts; end + def values; end + def xpath(*args, &block); end + + private + + def file_to_multipart(file, buf = _); end + def from_native_charset(str); end + def mime_value_quote(str); end + def param_to_multipart(name, value, buf = _); end + def parse; end + def proc_query(field); end + def rand_string(len = _); end +end + +class Mechanize::Form::Button < ::Mechanize::Form::Field +end + +Mechanize::Form::CRLF = T.let(T.unsafe(nil), String) + +class Mechanize::Form::CheckBox < ::Mechanize::Form::RadioButton + def inspect; end + def query_value; end +end + +class Mechanize::Form::Field + extend(::Forwardable) + + def initialize(node, value = _); end + + def <=>(other); end + def at(*args, &block); end + def at_css(*args, &block); end + def at_xpath(*args, &block); end + def css(*args, &block); end + def dom_class; end + def dom_id; end + def index; end + def index=(_); end + def inspect; end + def name; end + def name=(_); end + def node; end + def node=(_); end + def query_value; end + def raw_value; end + def search(*args, &block); end + def type; end + def type=(_); end + def value; end + def value=(_); end + def xpath(*args, &block); end +end + +class Mechanize::Form::FileUpload < ::Mechanize::Form::Field + def initialize(node, file_name); end + + def file_data; end + def file_data=(_); end + def file_name; end + def file_name=(_); end + def mime_type; end + def mime_type=(_); end +end + +class Mechanize::Form::Hidden < ::Mechanize::Form::Field +end + +class Mechanize::Form::ImageButton < ::Mechanize::Form::Button + def initialize(*args); end + + def query_value; end + def x; end + def x=(_); end + def y; end + def y=(_); end +end + +class Mechanize::Form::Keygen < ::Mechanize::Form::Field + def initialize(node, value = _); end + + def challenge; end + def generate_key(key_size = _); end + def key; end +end + +class Mechanize::Form::MultiSelectList < ::Mechanize::Form::Field + extend(::Mechanize::ElementMatcher) + + def initialize(node); end + + def option(criteria = _); end + def option_with(criteria = _); end + def option_with!(criteria = _); end + def options; end + def options=(_); end + def options_with(criteria = _); end + def query_value; end + def select_all; end + def select_none; end + def select_options(selector, method = _); end + def selected_options; end + def value; end + def value=(values); end +end + +class Mechanize::Form::Option + def initialize(node, select_list); end + + def click; end + def node; end + def select; end + def select_list; end + def selected; end + def selected?; end + def text; end + def tick; end + def to_s; end + def unselect; end + def untick; end + def value; end + + private + + def unselect_peers; end +end + +class Mechanize::Form::RadioButton < ::Mechanize::Form::Field + def initialize(node, form); end + + def ==(other); end + def [](key); end + def check; end + def checked; end + def checked=(_); end + def checked?; end + def click; end + def eql?(other); end + def form; end + def hash; end + def label; end + def pretty_print_instance_variables; end + def text; end + def uncheck; end + + private + + def uncheck_peers; end +end + +class Mechanize::Form::Reset < ::Mechanize::Form::Button +end + +class Mechanize::Form::SelectList < ::Mechanize::Form::MultiSelectList + def initialize(node); end + + def query_value; end + def value; end + def value=(new_value); end +end + +class Mechanize::Form::Submit < ::Mechanize::Form::Button +end + +class Mechanize::Form::Text < ::Mechanize::Form::Field +end + +class Mechanize::Form::Textarea < ::Mechanize::Form::Field +end + +class Mechanize::HTTP +end + +class Mechanize::HTTP::Agent + def initialize(connection_name = _); end + + def add_auth(uri, user, password, realm = _, domain = _); end + def add_default_auth(user, password, domain = _); end + def allowed_error_codes; end + def allowed_error_codes=(_); end + def auth_store; end + def authenticate_methods; end + def auto_io(name, read_size, input_io); end + def back; end + def ca_file; end + def ca_file=(ca_file); end + def cert_store; end + def cert_store=(cert_store); end + def certificate; end + def certificate=(certificate); end + def conditional_requests; end + def conditional_requests=(_); end + def connection_for(uri); end + def content_encoding_gunzip(body_io); end + def content_encoding_hooks; end + def content_encoding_inflate(body_io); end + def context; end + def context=(_); end + def cookie_jar; end + def cookie_jar=(_); end + def current_page; end + def digest_challenges; end + def disable_keep_alive(request); end + def enable_gzip(request); end + def fetch(uri, method = _, headers = _, params = _, referer = _, redirects = _); end + def follow_meta_refresh; end + def follow_meta_refresh=(_); end + def follow_meta_refresh_self; end + def follow_meta_refresh_self=(_); end + def get_meta_refresh(response, uri, page); end + def get_robots(uri); end + def gzip_enabled; end + def gzip_enabled=(_); end + def history; end + def history=(_); end + def hook_content_encoding(response, uri, response_body_io); end + def http; end + def http_request(uri, method, params = _); end + def idle_timeout; end + def idle_timeout=(timeout); end + def ignore_bad_chunking; end + def ignore_bad_chunking=(_); end + def inflate(compressed, window_bits = _); end + def keep_alive; end + def keep_alive=(_); end + def log; end + def make_tempfile(name); end + def max_file_buffer; end + def max_file_buffer=(_); end + def max_history; end + def max_history=(length); end + def open_timeout; end + def open_timeout=(_); end + def pass; end + def pass=(_); end + def post_connect(uri, response, body_io); end + def post_connect_hooks; end + def pre_connect(request); end + def pre_connect_hooks; end + def private_key; end + def private_key=(private_key); end + def proxy_uri; end + def read_timeout; end + def read_timeout=(_); end + def redirect_ok; end + def redirect_ok=(_); end + def redirection_limit; end + def redirection_limit=(_); end + def request_add_headers(request, headers = _); end + def request_auth(request, uri); end + def request_auth_digest(request, uri, realm, base_uri, iis); end + def request_cookies(request, uri); end + def request_headers; end + def request_headers=(_); end + def request_host(request, uri); end + def request_language_charset(request); end + def request_log(request); end + def request_referer(request, uri, referer); end + def request_user_agent(request); end + def reset; end + def resolve(uri, referer = _); end + def resolve_parameters(uri, method, parameters); end + def response_authenticate(response, page, uri, request, headers, params, referer); end + def response_content_encoding(response, body_io); end + def response_cookies(response, uri, page); end + def response_follow_meta_refresh(response, uri, page, redirects); end + def response_log(response); end + def response_parse(response, body_io, uri); end + def response_read(response, request, uri); end + def response_redirect(response, method, page, redirects, headers, referer = _); end + def retry_change_requests; end + def retry_change_requests=(retri); end + def robots; end + def robots=(value); end + def robots_allowed?(uri); end + def robots_disallowed?(url); end + def robots_error(url); end + def robots_error!(url); end + def robots_mutex; end + def robots_reset(url); end + def save_cookies(uri, set_cookie); end + def scheme_handlers; end + def scheme_handlers=(_); end + def secure_resolve!(uri, referer = _); end + def set_proxy(addr, port = _, user = _, pass = _); end + def shutdown; end + def ssl_version; end + def ssl_version=(ssl_version); end + def use_tempfile?(size); end + def user_agent; end + def user_agent=(user_agent); end + def verify_callback; end + def verify_callback=(verify_callback); end + def verify_mode; end + def verify_mode=(verify_mode); end + def visited_page(url); end + def webrobots; end +end + +Mechanize::HTTP::Agent::RobotsKey = T.let(T.unsafe(nil), Symbol) + +class Mechanize::HTTP::AuthChallenge < ::Struct + def [](param); end + def params; end + def params=(_); end + def raw; end + def raw=(_); end + def realm(uri); end + def realm_name; end + def scheme; end + def scheme=(_); end + def to_s; end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class Mechanize::HTTP::AuthRealm + def initialize(scheme, uri, realm); end + + def ==(other); end + def eql?(other); end + def hash; end + def inspect; end + def realm; end + def scheme; end + def uri; end +end + +class Mechanize::HTTP::AuthStore + def initialize; end + + def add_auth(uri, user, pass, realm = _, domain = _); end + def add_default_auth(user, pass, domain = _); end + def auth_accounts; end + def credentials?(uri, challenges); end + def credentials_for(uri, realm); end + def default_auth; end + def remove_auth(uri, realm = _); end +end + +class Mechanize::HTTP::ContentDisposition < ::Struct + def creation_date; end + def creation_date=(_); end + def filename; end + def filename=(_); end + def modification_date; end + def modification_date=(_); end + def parameters; end + def parameters=(_); end + def read_date; end + def read_date=(_); end + def size; end + def size=(_); end + def type; end + def type=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class Mechanize::HTTP::ContentDispositionParser + def initialize; end + + def parse(content_disposition, header = _); end + def parse_parameters; end + def rfc_2045_quoted_string; end + def rfc_2045_token; end + def rfc_2045_value; end + def scanner; end + def scanner=(_); end + def spaces; end + + def self.parse(content_disposition); end +end + +class Mechanize::HTTP::WWWAuthenticateParser + def initialize; end + + def auth_param; end + def auth_scheme; end + def parse(www_authenticate); end + def quoted_string; end + def scan_comma_spaces; end + def scanner; end + def scanner=(_); end + def spaces; end + def token; end +end + +class Mechanize::Headers < ::Hash + def [](key); end + def []=(key, value); end + def canonical_each; end + def key?(key); end +end + +class Mechanize::History < ::Array + def initialize(max_size = _); end + + def <<(page, uri = _); end + def clear; end + def inspect; end + def max_size; end + def max_size=(_); end + def pop; end + def push(page, uri = _); end + def shift; end + def visited?(uri); end + def visited_page(uri); end + + private + + def initialize_copy(orig); end + def remove_from_index(page); end +end + +class Mechanize::Image < ::Mechanize::Download +end + +class Mechanize::Page < ::Mechanize::File + extend(::Forwardable) + extend(::Mechanize::ElementMatcher) + + def initialize(uri = _, response = _, body = _, code = _, mech = _); end + + def %(*args, &block); end + def /(*args, &block); end + def at(*args, &block); end + def at_css(*args, &block); end + def at_xpath(*args, &block); end + def base(criteria = _); end + def base_with(criteria = _); end + def base_with!(criteria = _); end + def bases; end + def bases_with(criteria = _); end + def canonical_uri; end + def content_type; end + def css(*args, &block); end + def detected_encoding; end + def encoding; end + def encoding=(encoding); end + def encoding_error?(parser = _); end + def encodings; end + def form(criteria = _); end + def form_with(criteria = _); end + def form_with!(criteria = _); end + def forms; end + def forms_with(criteria = _); end + def frame(criteria = _); end + def frame_with(criteria = _); end + def frame_with!(criteria = _); end + def frames; end + def frames_with(criteria = _); end + def iframe(criteria = _); end + def iframe_with(criteria = _); end + def iframe_with!(criteria = _); end + def iframes; end + def iframes_with(criteria = _); end + def image(criteria = _); end + def image_urls; end + def image_with(criteria = _); end + def image_with!(criteria = _); end + def images; end + def images_with(criteria = _); end + def inspect; end + def labels; end + def labels_hash; end + def link(criteria = _); end + def link_with(criteria = _); end + def link_with!(criteria = _); end + def links; end + def links_with(criteria = _); end + def mech; end + def mech=(_); end + def meta_charset; end + def meta_refresh; end + def parser; end + def pretty_print(q); end + def reset; end + def response_header_charset; end + def root; end + def search(*args, &block); end + def select_bases(selector, method = _); end + def select_forms(selector, method = _); end + def select_frames(selector, method = _); end + def select_iframes(selector, method = _); end + def select_images(selector, method = _); end + def select_links(selector, method = _); end + def title; end + def xpath(*args, &block); end + + private + + def html_body; end + + def self.charset(content_type); end + def self.charset_from_content_type(content_type); end + def self.meta_charset(body); end + def self.meta_content_type(body); end + def self.response_header_charset(response); end +end + +class Mechanize::Page::Base < ::Mechanize::Page::Link +end + +Mechanize::Page::DEFAULT_RESPONSE = T.let(T.unsafe(nil), Hash) + +class Mechanize::Page::Frame < ::Mechanize::Page::Link + def initialize(node, mech, referer); end + + def content; end + def name; end + def node; end + def src; end + def text; end +end + +class Mechanize::Page::Image + def initialize(node, page); end + + def alt; end + def caption; end + def dom_class; end + def dom_id; end + def extname; end + def fetch(parameters = _, referer = _, headers = _); end + def height; end + def image_referer; end + def inspect; end + def mech; end + def mech=(_); end + def mime_type; end + def node; end + def page; end + def page=(_); end + def pretty_print(q); end + def relative?; end + def src; end + def text; end + def title; end + def to_s; end + def uri; end + def url; end + def width; end +end + +class Mechanize::Page::Label + def initialize(node, page); end + + def for; end + def node; end + def page; end + def text; end + def to_s; end +end + +class Mechanize::Page::Link + def initialize(node, mech, page); end + + def attributes; end + def click; end + def dom_class; end + def dom_id; end + def href; end + def inspect; end + def node; end + def noreferrer?; end + def page; end + def pretty_print(q); end + def referer; end + def rel; end + def rel?(kind); end + def resolved_uri; end + def text; end + def to_s; end + def uri; end +end + +class Mechanize::Page::MetaRefresh < ::Mechanize::Page::Link + def initialize(node, page, delay, href, link_self = _); end + + def delay; end + def link_self; end + def noreferrer?; end + + def self.from_node(node, page, uri = _); end + def self.parse(content, base_uri = _); end +end + +Mechanize::Page::MetaRefresh::CONTENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +Mechanize::Page::MetaRefresh::UNSAFE = T.let(T.unsafe(nil), Regexp) + +module Mechanize::Parser + extend(::Forwardable) + + def [](*args, &block); end + def []=(*args, &block); end + def canonical_each(*args, &block); end + def code; end + def code=(_); end + def each(*args, &block); end + def extract_filename(full_path = _); end + def fill_header(response); end + def find_free_name(filename); end + def header; end + def key?(*args, &block); end + def response; end + def response=(_); end + def uri; end + def uri=(_); end +end + +Mechanize::Parser::SPECIAL_FILENAMES = T.let(T.unsafe(nil), Regexp) + +class Mechanize::PluggableParser + def initialize; end + + def [](content_type); end + def []=(content_type, klass); end + def csv=(klass); end + def default; end + def default=(_); end + def html=(klass); end + def parser(content_type); end + def pdf=(klass); end + def register_parser(content_type, klass); end + def xhtml=(klass); end + def xml=(klass); end +end + +Mechanize::PluggableParser::CONTENT_TYPES = T.let(T.unsafe(nil), Hash) + +Mechanize::PluggableParser::InvalidContentTypeError = MIME::Type::InvalidContentType + +class Mechanize::RedirectLimitReachedError < ::Mechanize::Error + def initialize(page, redirects); end + + def page; end + def redirects; end + def response_code; end +end + +class Mechanize::RedirectNotGetOrHeadError < ::Mechanize::Error + def initialize(page, verb); end + + def inspect; end + def page; end + def response_code; end + def to_s; end + def uri; end + def verb; end +end + +class Mechanize::ResponseCodeError < ::Mechanize::Error + def initialize(page, message = _); end + + def inspect; end + def page; end + def response_code; end + def to_s; end +end + +class Mechanize::ResponseReadError < ::Mechanize::Error + def initialize(error, response, body_io, uri, mechanize); end + + def body_io; end + def error; end + def force_parse; end + def mechanize; end + def message; end + def response; end + def uri; end +end + +class Mechanize::RobotsDisallowedError < ::Mechanize::Error + def initialize(url); end + + def inspect; end + def to_s; end + def uri; end + def url; end +end + +class Mechanize::UnauthorizedError < ::Mechanize::ResponseCodeError + def initialize(page, challenges, message); end + + def challenges; end + def to_s; end +end + +class Mechanize::UnsupportedSchemeError < ::Mechanize::Error + def initialize(scheme, uri); end + + def scheme; end + def scheme=(_); end + def uri; end + def uri=(_); end +end + +class Mechanize::Util + def self.build_query_string(parameters, enc = _); end + def self.detect_charset(src); end + def self.each_parameter(parameters, &block); end + def self.from_native_charset(s, code, ignore_encoding_error = _, log = _); end + def self.guess_encoding(src); end + def self.html_unescape(s); end + def self.uri_escape(str, unsafe = _); end + def self.uri_unescape(str); end +end + +Mechanize::Util::DefaultMimeTypes = T.let(T.unsafe(nil), Hash) + +Mechanize::VERSION = T.let(T.unsafe(nil), String) + +class Mechanize::XmlFile < ::Mechanize::File + extend(::Forwardable) + + def initialize(uri = _, response = _, body = _, code = _); end + + def at(*args, &block); end + def search(*args, &block); end + def xml; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi new file mode 100644 index 0000000000..6b60ba30e0 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi @@ -0,0 +1,64 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module MIME +end + +class MIME::Types + include(::Enumerable) + extend(::Enumerable) + + def initialize; end + + def [](type_id, complete: _, registered: _); end + def add(*types); end + def add_type(type, quiet = _); end + def count; end + def each; end + def inspect; end + def of(filename); end + def type_for(filename); end + + private + + def add_type_variant!(mime_type); end + def index_extensions!(mime_type); end + def match(pattern); end + def prune_matches(matches, complete, registered); end + def reindex_extensions!(mime_type); end + + def self.[](type_id, complete: _, registered: _); end + def self.add(*types); end + def self.count; end + def self.each; end + def self.logger; end + def self.logger=(_); end + def self.new(*_); end + def self.of(filename); end + def self.type_for(filename); end +end + +class MIME::Types::Cache < ::Struct + def data; end + def data=(_); end + def version; end + def version=(_); end + + def self.[](*_); end + def self.inspect; end + def self.load(cache_file = _); end + def self.members; end + def self.new(*_); end + def self.save(types = _, cache_file = _); end +end + +module MIME::Types::Data +end + +MIME::Types::Data::PATH = T.let(T.unsafe(nil), String) + +MIME::Types::Data::VERSION = T.let(T.unsafe(nil), String) + +MIME::Types::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi new file mode 100644 index 0000000000..b346c24567 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi @@ -0,0 +1,253 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module MIME +end + +class MIME::Type + include(::Comparable) + + def initialize(content_type); end + + def <=>(other); end + def add_extensions(*extensions); end + def ascii?; end + def binary?; end + def complete?; end + def content_type; end + def default_encoding; end + def docs; end + def docs=(_); end + def encode_with(coder); end + def encoding; end + def encoding=(enc); end + def eql?(other); end + def extensions; end + def extensions=(value); end + def friendly(lang = _); end + def i18n_key; end + def init_with(coder); end + def inspect; end + def like?(other); end + def media_type; end + def obsolete; end + def obsolete=(_); end + def obsolete?; end + def preferred_extension; end + def preferred_extension=(value); end + def priority_compare(other); end + def raw_media_type; end + def raw_sub_type; end + def registered; end + def registered=(_); end + def registered?; end + def signature; end + def signature=(_); end + def signature?; end + def simplified; end + def sub_type; end + def to_h; end + def to_json(*args); end + def to_s; end + def to_str; end + def use_instead; end + def use_instead=(_); end + def xref_urls; end + def xrefs; end + def xrefs=(xrefs); end + + private + + def content_type=(type_string); end + def intern_string(string); end + def xref_map(values, helper); end + def xref_url_for_draft(value); end + def xref_url_for_person(value); end + def xref_url_for_rfc(value); end + def xref_url_for_rfc_errata(value); end + def xref_url_for_template(value); end + + def self.i18n_key(content_type); end + def self.match(content_type); end + def self.simplified(content_type, remove_x_prefix: _); end +end + +class MIME::Type::Columnar < ::MIME::Type + def initialize(container, content_type, extensions); end + + def docs(*args); end + def docs=(*args); end + def encode_with(coder); end + def encoding(*args); end + def encoding=(*args); end + def friendly(*args); end + def obsolete(*args); end + def obsolete=(*args); end + def obsolete?(*args); end + def preferred_extension(*args); end + def preferred_extension=(*args); end + def registered(*args); end + def registered=(*args); end + def registered?(*args); end + def signature(*args); end + def signature=(*args); end + def signature?(*args); end + def use_instead(*args); end + def use_instead=(*args); end + def xref_urls(*args); end + def xrefs(*args); end + def xrefs=(*args); end +end + +class MIME::Type::InvalidContentType < ::ArgumentError + def initialize(type_string); end + + def to_s; end +end + +class MIME::Type::InvalidEncoding < ::ArgumentError + def initialize(encoding); end + + def to_s; end +end + +MIME::Type::VERSION = T.let(T.unsafe(nil), String) + +class MIME::Types + include(::Enumerable) + extend(::Enumerable) + + def initialize; end + + def [](type_id, complete: _, registered: _); end + def add(*types); end + def add_type(type, quiet = _); end + def count; end + def each; end + def inspect; end + def of(filename); end + def type_for(filename); end + + private + + def add_type_variant!(mime_type); end + def index_extensions!(mime_type); end + def match(pattern); end + def prune_matches(matches, complete, registered); end + def reindex_extensions!(mime_type); end + + def self.[](type_id, complete: _, registered: _); end + def self.add(*types); end + def self.count; end + def self.each; end + def self.logger; end + def self.logger=(_); end + def self.new(*_); end + def self.of(filename); end + def self.type_for(filename); end +end + +class MIME::Types::Cache < ::Struct + def data; end + def data=(_); end + def version; end + def version=(_); end + + def self.[](*_); end + def self.inspect; end + def self.load(cache_file = _); end + def self.members; end + def self.new(*_); end + def self.save(types = _, cache_file = _); end +end + +module MIME::Types::Columnar + def load_base_data(path); end + + private + + def arr(line); end + def dict(line, array: _); end + def each_file_line(name, lookup = _); end + def flag(line); end + def load_docs; end + def load_encoding; end + def load_flags; end + def load_friendly; end + def load_preferred_extension; end + def load_use_instead; end + def load_xrefs; end + def opt(line); end + + def self.extended(obj); end +end + +MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex) + +class MIME::Types::Container + extend(::Forwardable) + + def initialize(hash = _); end + + def ==(*args, &block); end + def [](key); end + def []=(key, value); end + def add(key, value); end + def count(*args, &block); end + def each(*args, &block); end + def each_value(*args, &block); end + def empty?(*args, &block); end + def encode_with(coder); end + def flat_map(*args, &block); end + def init_with(coder); end + def keys(*args, &block); end + def marshal_dump; end + def marshal_load(hash); end + def merge(other); end + def merge!(other); end + def select(*args, &block); end + def to_hash; end + def values(*args, &block); end + + protected + + def container; end + def container=(_); end + def normalize; end +end + +class MIME::Types::Loader + def initialize(path = _, container = _); end + + def container; end + def load(options = _); end + def load_columnar; end + def load_json; end + def load_yaml; end + def path; end + + private + + def columnar_path; end + def json_path; end + def yaml_path; end + + def self.load(options = _); end + def self.load_from_json(filename); end + def self.load_from_yaml(filename); end +end + +MIME::Types::VERSION = T.let(T.unsafe(nil), String) + +class MIME::Types::WarnLogger < ::Logger + def initialize(_one, _two = _, _three = _); end +end + +class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice + def initialize(*_); end + + def close; end + def write(m); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.9.rbi b/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.9.rbi new file mode 100644 index 0000000000..c2db268606 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.10.9.rbi @@ -0,0 +1,1551 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Nokogiri + def self.HTML(thing, url = _, encoding = _, options = _, &block); end + def self.Slop(*args, &block); end + def self.XML(thing, url = _, encoding = _, options = _, &block); end + def self.XSLT(stylesheet, modules = _); end + def self.install_default_aliases; end + def self.jruby?; end + def self.make(input = _, opts = _, &blk); end + def self.parse(string, url = _, encoding = _, options = _); end + def self.uses_libxml?; end +end + +module Nokogiri::CSS + def self.parse(selector); end + def self.xpath_for(selector, options = _); end +end + +class Nokogiri::CSS::Node + def initialize(type, value); end + + def accept(visitor); end + def find_by_type(types); end + def to_a; end + def to_type; end + def to_xpath(prefix = _, visitor = _); end + def type; end + def type=(_); end + def value; end + def value=(_); end +end + +Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array) + +class Nokogiri::CSS::Parser < ::Racc::Parser + def initialize(namespaces = _); end + + def _reduce_1(val, _values, result); end + def _reduce_11(val, _values, result); end + def _reduce_12(val, _values, result); end + def _reduce_13(val, _values, result); end + def _reduce_14(val, _values, result); end + def _reduce_15(val, _values, result); end + def _reduce_16(val, _values, result); end + def _reduce_18(val, _values, result); end + def _reduce_2(val, _values, result); end + def _reduce_20(val, _values, result); end + def _reduce_21(val, _values, result); end + def _reduce_22(val, _values, result); end + def _reduce_23(val, _values, result); end + def _reduce_25(val, _values, result); end + def _reduce_26(val, _values, result); end + def _reduce_27(val, _values, result); end + def _reduce_28(val, _values, result); end + def _reduce_29(val, _values, result); end + def _reduce_3(val, _values, result); end + def _reduce_30(val, _values, result); end + def _reduce_31(val, _values, result); end + def _reduce_32(val, _values, result); end + def _reduce_33(val, _values, result); end + def _reduce_34(val, _values, result); end + def _reduce_35(val, _values, result); end + def _reduce_36(val, _values, result); end + def _reduce_37(val, _values, result); end + def _reduce_4(val, _values, result); end + def _reduce_40(val, _values, result); end + def _reduce_41(val, _values, result); end + def _reduce_42(val, _values, result); end + def _reduce_43(val, _values, result); end + def _reduce_44(val, _values, result); end + def _reduce_45(val, _values, result); end + def _reduce_48(val, _values, result); end + def _reduce_49(val, _values, result); end + def _reduce_5(val, _values, result); end + def _reduce_50(val, _values, result); end + def _reduce_51(val, _values, result); end + def _reduce_52(val, _values, result); end + def _reduce_58(val, _values, result); end + def _reduce_59(val, _values, result); end + def _reduce_6(val, _values, result); end + def _reduce_60(val, _values, result); end + def _reduce_61(val, _values, result); end + def _reduce_63(val, _values, result); end + def _reduce_64(val, _values, result); end + def _reduce_65(val, _values, result); end + def _reduce_66(val, _values, result); end + def _reduce_67(val, _values, result); end + def _reduce_68(val, _values, result); end + def _reduce_69(val, _values, result); end + def _reduce_7(val, _values, result); end + def _reduce_70(val, _values, result); end + def _reduce_8(val, _values, result); end + def _reduce_9(val, _values, result); end + def _reduce_none(val, _values, result); end + def next_token; end + def on_error(error_token_id, error_value, value_stack); end + def parse(string); end + def unescape_css_identifier(identifier); end + def unescape_css_string(str); end + def xpath_for(string, options = _); end + + def self.[](string); end + def self.[]=(string, value); end + def self.cache_on; end + def self.cache_on=(_); end + def self.cache_on?; end + def self.clear_cache; end + def self.parse(selector); end + def self.set_cache(_); end + def self.without_cache(&block); end +end + +Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array) + +Nokogiri::CSS::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) + +class Nokogiri::CSS::SyntaxError < ::Nokogiri::SyntaxError +end + +class Nokogiri::CSS::Tokenizer + def _next_token; end + def action; end + def filename; end + def lineno; end + def load_file(filename); end + def next_token; end + def scan(str); end + def scan_file(filename); end + def scan_setup(str); end + def scan_str(str); end + def state; end + def state=(_); end +end + +class Nokogiri::CSS::Tokenizer::ScanError < ::StandardError +end + +class Nokogiri::CSS::XPathVisitor + def accept(node); end + def visit_attribute_condition(node); end + def visit_child_selector(node); end + def visit_class_condition(node); end + def visit_combinator(node); end + def visit_conditional_selector(node); end + def visit_descendant_selector(node); end + def visit_direct_adjacent_selector(node); end + def visit_element_name(node); end + def visit_following_selector(node); end + def visit_function(node); end + def visit_id(node); end + def visit_not(node); end + def visit_pseudo_class(node); end + + private + + def is_of_type_pseudo_class?(node); end + def nth(node, options = _); end + def read_a_and_positive_b(values); end +end + +module Nokogiri::Decorators +end + +module Nokogiri::Decorators::Slop + def method_missing(name, *args, &block); end + + private + + def respond_to_missing?(name, include_private = _); end +end + +Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String) + +class Nokogiri::EncodingHandler + def name; end + + def self.[](_); end + def self.alias(_, _); end + def self.clear_aliases!; end + def self.delete(_); end +end + +module Nokogiri::HTML + def self.fragment(string, encoding = _); end + def self.parse(thing, url = _, encoding = _, options = _, &block); end +end + +class Nokogiri::HTML::Builder < ::Nokogiri::XML::Builder + def to_html; end +end + +class Nokogiri::HTML::Document < ::Nokogiri::XML::Document + def fragment(tags = _); end + def meta_encoding; end + def meta_encoding=(encoding); end + def meta_robots(custom_name = _); end + def nofollow?(custom_name = _); end + def noindex?(custom_name = _); end + def serialize(options = _); end + def title; end + def title=(text); end + def type; end + + private + + def meta_content_type; end + def parse_meta_robots(custom_name); end + def set_metadata_element(element); end + + def self.new(*_); end + def self.parse(string_or_io, url = _, encoding = _, options = _); end + def self.read_io(_, _, _, _); end + def self.read_memory(_, _, _, _); end +end + +class Nokogiri::HTML::Document::EncodingFound < ::StandardError + def initialize(encoding); end + + def found_encoding; end +end + +class Nokogiri::HTML::Document::EncodingReader + def initialize(io); end + + def encoding_found; end + def read(len); end + + def self.detect_encoding(chunk); end + def self.detect_encoding_for_jruby_without_fix(chunk); end + def self.is_jruby_without_fix?; end +end + +class Nokogiri::HTML::Document::EncodingReader::JumpSAXHandler < ::Nokogiri::HTML::Document::EncodingReader::SAXHandler + def initialize(jumptag); end + + def start_element(name, attrs = _); end +end + +class Nokogiri::HTML::Document::EncodingReader::SAXHandler < ::Nokogiri::XML::SAX::Document + def initialize; end + + def encoding; end + def start_element(name, attrs = _); end +end + +class Nokogiri::HTML::DocumentFragment < ::Nokogiri::XML::DocumentFragment + def initialize(document, tags = _, ctx = _); end + + def self.parse(tags, encoding = _); end +end + +class Nokogiri::HTML::ElementDescription + def block?; end + def default_sub_element; end + def deprecated?; end + def deprecated_attributes; end + def description; end + def empty?; end + def implied_end_tag?; end + def implied_start_tag?; end + def inline?; end + def inspect; end + def name; end + def optional_attributes; end + def required_attributes; end + def save_end_tag?; end + def sub_elements; end + def to_s; end + + private + + def default_desc; end + + def self.[](_); end +end + +Nokogiri::HTML::ElementDescription::ACTION_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::ALIGN_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::ALT_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::APPLET_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::AREA_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::A_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BASEFONT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BGCOLOR_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BLOCK = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BLOCKLI_ELT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BODY_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BODY_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BODY_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::BUTTON_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CELLHALIGN = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CELLVALIGN = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CLEAR_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::COL_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::COL_ELT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::COMPACT_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::COMPACT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CONTENT_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::COREATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CORE_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::CORE_I18N_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::DIR_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::DL_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::DefaultDescriptions = T.let(T.unsafe(nil), Hash) + +Nokogiri::HTML::ElementDescription::Desc = Struct + +Nokogiri::HTML::ElementDescription::EDIT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::EMBED_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::EMPTY = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::EVENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FIELDSET_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FLOW = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FLOW_PARAM = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FONTSTYLE = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FONT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FORMCTRL = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FORM_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FORM_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FRAMESET_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FRAMESET_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::FRAME_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HEADING = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HEAD_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HEAD_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HREF_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HR_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_CDATA = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_CONTENT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_FLOW = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_INLINE = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::HTML_PCDATA = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::I18N = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::I18N_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::IFRAME_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::IMG_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::INLINE = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::INLINE_P = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::INPUT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LABEL_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LABEL_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LANGUAGE_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LEGEND_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LINK_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LIST = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::LI_ELT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::MAP_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::META_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::MODIFIER = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::NAME_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::NOFRAMES_CONTENT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OBJECT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OBJECT_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OBJECT_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OL_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OPTGROUP_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OPTION_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::OPTION_ELT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::PARAM_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::PCDATA = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::PHRASE = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::PRE_CONTENT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::PROMPT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::QUOTE_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::ROWS_COLS_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::SCRIPT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::SELECT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::SELECT_CONTENT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::SPECIAL = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::SRC_ALT_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::STYLE_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TABLE_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TABLE_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TABLE_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TALIGN_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TARGET_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TEXTAREA_ATTRS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TH_TD_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TH_TD_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TR_CONTENTS = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TR_ELT = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::TYPE_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::UL_DEPR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::VERSION_ATTR = T.let(T.unsafe(nil), Array) + +Nokogiri::HTML::ElementDescription::WIDTH_ATTR = T.let(T.unsafe(nil), Array) + +class Nokogiri::HTML::EntityDescription < ::Struct +end + +class Nokogiri::HTML::EntityLookup + def [](name); end + def get(_); end +end + +Nokogiri::HTML::NamedCharacters = T.let(T.unsafe(nil), Nokogiri::HTML::EntityLookup) + +module Nokogiri::HTML::SAX +end + +class Nokogiri::HTML::SAX::Parser < ::Nokogiri::XML::SAX::Parser + def parse_file(filename, encoding = _); end + def parse_io(io, encoding = _); end + def parse_memory(data, encoding = _); end +end + +class Nokogiri::HTML::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext + def parse_with(_); end + + def self.file(_, _); end + def self.memory(_, _); end + def self.new(thing, encoding = _); end +end + +class Nokogiri::HTML::SAX::PushParser < ::Nokogiri::XML::SAX::PushParser + def initialize(doc = _, file_name = _, encoding = _); end + + def <<(chunk, last_chunk = _); end + def document; end + def document=(_); end + def finish; end + def write(chunk, last_chunk = _); end + + private + + def initialize_native(_, _, _); end + def native_write(_, _); end +end + +Nokogiri::LIBXML_ICONV_ENABLED = T.let(T.unsafe(nil), TrueClass) + +Nokogiri::LIBXML_PARSER_VERSION = T.let(T.unsafe(nil), String) + +Nokogiri::LIBXML_VERSION = T.let(T.unsafe(nil), String) + +Nokogiri::NOKOGIRI_LIBXML2_PATCHES = T.let(T.unsafe(nil), Array) + +Nokogiri::NOKOGIRI_LIBXML2_PATH = T.let(T.unsafe(nil), String) + +Nokogiri::NOKOGIRI_LIBXSLT_PATCHES = T.let(T.unsafe(nil), Array) + +Nokogiri::NOKOGIRI_LIBXSLT_PATH = T.let(T.unsafe(nil), String) + +Nokogiri::NOKOGIRI_USE_PACKAGED_LIBRARIES = T.let(T.unsafe(nil), TrueClass) + +class Nokogiri::SyntaxError < ::StandardError +end + +Nokogiri::VERSION = T.let(T.unsafe(nil), String) + +Nokogiri::VERSION_INFO = T.let(T.unsafe(nil), Hash) + +class Nokogiri::VersionInfo + def compiled_parser_version; end + def engine; end + def jruby?; end + def libxml2?; end + def libxml2_using_packaged?; end + def libxml2_using_system?; end + def loaded_parser_version; end + def to_hash; end + def to_markdown; end + def warnings; end + + def self.instance; end +end + +module Nokogiri::XML + def self.Reader(string_or_io, url = _, encoding = _, options = _); end + def self.RelaxNG(string_or_io); end + def self.Schema(string_or_io); end + def self.fragment(string); end + def self.parse(thing, url = _, encoding = _, options = _, &block); end +end + +class Nokogiri::XML::Attr < ::Nokogiri::XML::Node + def content=(_); end + def to_s; end + def value; end + def value=(_); end + + private + + def inspect_attributes; end + + def self.new(*_); end +end + +class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node + def attribute_type; end + def default; end + def enumeration; end + def inspect; end +end + +class Nokogiri::XML::Builder + def initialize(options = _, root = _, &block); end + + def <<(string); end + def [](ns); end + def arity; end + def arity=(_); end + def cdata(string); end + def comment(string); end + def context; end + def context=(_); end + def doc; end + def doc=(_); end + def method_missing(method, *args, &block); end + def parent; end + def parent=(_); end + def text(string); end + def to_xml(*args); end + + private + + def insert(node, &block); end + + def self.with(root, &block); end +end + +class Nokogiri::XML::Builder::NodeBuilder + def initialize(node, doc_builder); end + + def [](k); end + def []=(k, v); end + def method_missing(method, *args, &block); end +end + +class Nokogiri::XML::CDATA < ::Nokogiri::XML::Text + def name; end + + def self.new(*_); end +end + +class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node + include(::Nokogiri::XML::PP::CharacterData) +end + +class Nokogiri::XML::Comment < ::Nokogiri::XML::CharacterData + def self.new(*_); end +end + +class Nokogiri::XML::DTD < ::Nokogiri::XML::Node + def attributes; end + def each; end + def elements; end + def entities; end + def external_id; end + def html5_dtd?; end + def html_dtd?; end + def keys; end + def notations; end + def system_id; end + def validate(_); end +end + +class Nokogiri::XML::Document < ::Nokogiri::XML::Node + def initialize(*args); end + + def <<(node_or_tags); end + def add_child(node_or_tags); end + def canonicalize(*_); end + def clone(*_); end + def collect_namespaces; end + def create_cdata(string, &block); end + def create_comment(string, &block); end + def create_element(name, *args, &block); end + def create_entity(*_); end + def create_text_node(string, &block); end + def decorate(node); end + def decorators(key); end + def document; end + def dup(*_); end + def encoding; end + def encoding=(_); end + def errors; end + def errors=(_); end + def fragment(tags = _); end + def name; end + def namespaces; end + def remove_namespaces!; end + def root; end + def root=(_); end + def slop!; end + def to_java; end + def to_xml(*args, &block); end + def url; end + def validate; end + def version; end + + private + + def inspect_attributes; end + + def self.empty_doc?(string_or_io); end + def self.new(*_); end + def self.parse(string_or_io, url = _, encoding = _, options = _); end + def self.read_io(_, _, _, _); end + def self.read_memory(_, _, _, _); end + def self.wrap(document); end +end + +Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array) + +Nokogiri::XML::Document::NCNAME_CHAR = T.let(T.unsafe(nil), String) + +Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp) + +Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String) + +class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node + def initialize(document, tags = _, ctx = _); end + + def css(*args); end + def dup; end + def errors; end + def errors=(things); end + def name; end + def search(*rules); end + def serialize; end + def to_html(*args); end + def to_s; end + def to_xhtml(*args); end + def to_xml(*args); end + + private + + def coerce(data); end + def namespace_declarations(ctx); end + + def self.new(*_); end + def self.parse(tags); end +end + +class Nokogiri::XML::Element < ::Nokogiri::XML::Node +end + +class Nokogiri::XML::ElementContent + def children; end + def document; end + def name; end + def occur; end + def prefix; end + def type; end + + private + + def c1; end + def c2; end +end + +Nokogiri::XML::ElementContent::ELEMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::MULT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::ONCE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::OPT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::OR = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::PCDATA = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::PLUS = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ElementContent::SEQ = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::ElementDecl < ::Nokogiri::XML::Node + def content; end + def element_type; end + def inspect; end + def prefix; end +end + +class Nokogiri::XML::EntityDecl < ::Nokogiri::XML::Node + def content; end + def entity_type; end + def external_id; end + def inspect; end + def original_content; end + def system_id; end + + def self.new(name, doc, *args); end +end + +Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_UNPARSED = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::EntityDecl::EXTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::EntityDecl::INTERNAL_GENERAL = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::EntityDecl::INTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::EntityDecl::INTERNAL_PREDEFINED = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::EntityReference < ::Nokogiri::XML::Node + def children; end + def inspect_attributes; end + + def self.new(*_); end +end + +class Nokogiri::XML::Namespace + include(::Nokogiri::XML::PP::Node) + + def document; end + def href; end + def prefix; end + + private + + def inspect_attributes; end +end + +class Nokogiri::XML::Node + include(::Nokogiri::XML::PP::Node) + include(::Nokogiri::XML::Searchable) + include(::Enumerable) + + def initialize(name, document); end + + def <<(node_or_tags); end + def <=>(other); end + def ==(other); end + def >(selector); end + def [](name); end + def []=(name, value); end + def accept(visitor); end + def add_child(node_or_tags); end + def add_class(name); end + def add_namespace(_, _); end + def add_namespace_definition(_, _); end + def add_next_sibling(node_or_tags); end + def add_previous_sibling(node_or_tags); end + def after(node_or_tags); end + def ancestors(selector = _); end + def append_class(name); end + def attr(name); end + def attribute(_); end + def attribute_nodes; end + def attribute_with_ns(_, _); end + def attributes; end + def before(node_or_tags); end + def blank?; end + def canonicalize(mode = _, inclusive_namespaces = _, with_comments = _); end + def cdata?; end + def child; end + def children; end + def children=(node_or_tags); end + def classes; end + def clone(*_); end + def comment?; end + def content; end + def content=(string); end + def create_external_subset(_, _, _); end + def create_internal_subset(_, _, _); end + def css_path; end + def decorate!; end + def default_namespace=(url); end + def delete(name); end + def description; end + def do_xinclude(options = _); end + def document; end + def document?; end + def dup(*_); end + def each; end + def elem?; end + def element?; end + def element_children; end + def elements; end + def encode_special_chars(_); end + def external_subset; end + def first_element_child; end + def fragment(tags); end + def fragment?; end + def get_attribute(name); end + def has_attribute?(_); end + def html?; end + def inner_html(*args); end + def inner_html=(node_or_tags); end + def inner_text; end + def internal_subset; end + def key?(_); end + def keys; end + def lang; end + def lang=(_); end + def last_element_child; end + def line; end + def matches?(selector); end + def name; end + def name=(_); end + def namespace; end + def namespace=(ns); end + def namespace_definitions; end + def namespace_scopes; end + def namespaced_key?(_, _); end + def namespaces; end + def native_content=(_); end + def next; end + def next=(node_or_tags); end + def next_element; end + def next_sibling; end + def node_name; end + def node_name=(_); end + def node_type; end + def parent; end + def parent=(parent_node); end + def parse(string_or_io, options = _); end + def path; end + def pointer_id; end + def prepend_child(node_or_tags); end + def previous; end + def previous=(node_or_tags); end + def previous_element; end + def previous_sibling; end + def processing_instruction?; end + def read_only?; end + def remove; end + def remove_attribute(name); end + def remove_class(name = _); end + def replace(node_or_tags); end + def serialize(*args, &block); end + def set_attribute(name, value); end + def swap(node_or_tags); end + def text; end + def text?; end + def to_html(options = _); end + def to_s; end + def to_str; end + def to_xhtml(options = _); end + def to_xml(options = _); end + def traverse(&block); end + def type; end + def unlink; end + def values; end + def wrap(html); end + def write_html_to(io, options = _); end + def write_to(io, *options); end + def write_xhtml_to(io, options = _); end + def write_xml_to(io, options = _); end + def xml?; end + + private + + def add_child_node(_); end + def add_child_node_and_reparent_attrs(node); end + def add_next_sibling_node(_); end + def add_previous_sibling_node(_); end + def add_sibling(next_or_previous, node_or_tags); end + def coerce(data); end + def compare(_); end + def dump_html; end + def get(_); end + def in_context(_, _); end + def inspect_attributes; end + def native_write_to(_, _, _, _); end + def process_xincludes(_); end + def replace_node(_); end + def set(_, _); end + def set_namespace(_); end + def to_format(save_option, options); end + def write_format_to(save_option, io, options); end + + def self.new(*_); end +end + +Nokogiri::XML::Node::ATTRIBUTE_DECL = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ATTRIBUTE_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::CDATA_SECTION_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::COMMENT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::DOCB_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::DOCUMENT_FRAG_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::DOCUMENT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::DOCUMENT_TYPE_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::DTD_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ELEMENT_DECL = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ELEMENT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ENTITY_DECL = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ENTITY_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::ENTITY_REF_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::HTML_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array) + +Nokogiri::XML::Node::NAMESPACE_DECL = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::NOTATION_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::PI_NODE = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::Node::SaveOptions + def initialize(options = _); end + + def as_html; end + def as_html?; end + def as_xhtml; end + def as_xhtml?; end + def as_xml; end + def as_xml?; end + def default_html; end + def default_html?; end + def default_xhtml; end + def default_xhtml?; end + def default_xml; end + def default_xml?; end + def format; end + def format?; end + def no_declaration; end + def no_declaration?; end + def no_empty_tags; end + def no_empty_tags?; end + def no_xhtml; end + def no_xhtml?; end + def options; end + def to_i; end +end + +Nokogiri::XML::Node::SaveOptions::AS_HTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::AS_XHTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::AS_XML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::FORMAT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::NO_DECLARATION = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::SaveOptions::NO_XHTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::TEXT_NODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::XINCLUDE_END = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Node::XINCLUDE_START = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::NodeSet + include(::Nokogiri::XML::Searchable) + include(::Enumerable) + + def initialize(document, list = _); end + + def %(*args); end + def &(_); end + def +(_); end + def -(_); end + def <<(_); end + def ==(other); end + def >(selector); end + def [](*_); end + def add_class(name); end + def after(datum); end + def append_class(name); end + def at(*args); end + def attr(key, value = _, &block); end + def attribute(key, value = _, &block); end + def before(datum); end + def children; end + def clone; end + def css(*args); end + def delete(_); end + def document; end + def document=(_); end + def dup; end + def each; end + def empty?; end + def filter(expr); end + def first(n = _); end + def include?(_); end + def index(node = _); end + def inner_html(*args); end + def inner_text; end + def inspect; end + def last; end + def length; end + def pop; end + def push(_); end + def remove; end + def remove_attr(name); end + def remove_attribute(name); end + def remove_class(name = _); end + def reverse; end + def set(key, value = _, &block); end + def shift; end + def size; end + def slice(*_); end + def text; end + def to_a; end + def to_ary; end + def to_html(*args); end + def to_s; end + def to_xhtml(*args); end + def to_xml(*args); end + def unlink; end + def wrap(html); end + def xpath(*args); end + def |(_); end +end + +Nokogiri::XML::NodeSet::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array) + +class Nokogiri::XML::Notation < ::Struct +end + +module Nokogiri::XML::PP +end + +module Nokogiri::XML::PP::CharacterData + def inspect; end + def pretty_print(pp); end +end + +module Nokogiri::XML::PP::Node + def inspect; end + def pretty_print(pp); end +end + +class Nokogiri::XML::ParseOptions + def initialize(options = _); end + + def compact; end + def compact?; end + def default_html; end + def default_html?; end + def default_xml; end + def default_xml?; end + def dtdattr; end + def dtdattr?; end + def dtdload; end + def dtdload?; end + def dtdvalid; end + def dtdvalid?; end + def huge; end + def huge?; end + def inspect; end + def nobasefix; end + def nobasefix?; end + def noblanks; end + def noblanks?; end + def nocdata; end + def nocdata?; end + def nocompact; end + def nodefault_html; end + def nodefault_xml; end + def nodict; end + def nodict?; end + def nodtdattr; end + def nodtdload; end + def nodtdvalid; end + def noent; end + def noent?; end + def noerror; end + def noerror?; end + def nohuge; end + def nonet; end + def nonet?; end + def nonobasefix; end + def nonoblanks; end + def nonocdata; end + def nonodict; end + def nonoent; end + def nonoerror; end + def nononet; end + def nonowarning; end + def nonoxincnode; end + def nonsclean; end + def noold10; end + def nopedantic; end + def norecover; end + def nosax1; end + def nowarning; end + def nowarning?; end + def noxinclude; end + def noxincnode; end + def noxincnode?; end + def nsclean; end + def nsclean?; end + def old10; end + def old10?; end + def options; end + def options=(_); end + def pedantic; end + def pedantic?; end + def recover; end + def recover?; end + def sax1; end + def sax1?; end + def strict; end + def strict?; end + def to_i; end + def xinclude; end + def xinclude?; end +end + +Nokogiri::XML::ParseOptions::COMPACT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::DTDATTR = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::DTDLOAD = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::DTDVALID = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::HUGE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOBASEFIX = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOBLANKS = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOCDATA = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NODICT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOERROR = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NONET = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOWARNING = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NOXINCNODE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::NSCLEAN = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::OLD10 = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::PEDANTIC = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::RECOVER = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::SAX1 = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::STRICT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::ParseOptions::XINCLUDE = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node + def initialize(document, name, content); end + + def self.new(*_); end +end + +class Nokogiri::XML::Reader + include(::Enumerable) + + def initialize(source, url = _, encoding = _); end + + def attribute(_); end + def attribute_at(_); end + def attribute_count; end + def attribute_nodes; end + def attributes; end + def attributes?; end + def base_uri; end + def default?; end + def depth; end + def each; end + def empty_element?; end + def encoding; end + def errors; end + def errors=(_); end + def inner_xml; end + def lang; end + def local_name; end + def name; end + def namespace_uri; end + def namespaces; end + def node_type; end + def outer_xml; end + def prefix; end + def read; end + def self_closing?; end + def source; end + def state; end + def value; end + def value?; end + def xml_version; end + + private + + def attr_nodes; end + + def self.from_io(*_); end + def self.from_memory(*_); end +end + +Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_CDATA = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_COMMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_DOCUMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_DOCUMENT_FRAGMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_DOCUMENT_TYPE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_ELEMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_END_ELEMENT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_END_ENTITY = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_ENTITY = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_ENTITY_REFERENCE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_NONE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_NOTATION = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_PROCESSING_INSTRUCTION = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_TEXT = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_WHITESPACE = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::Reader::TYPE_XML_DECLARATION = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema + + private + + def validate_document(_); end + + def self.from_document(_); end + def self.read_memory(_); end +end + +module Nokogiri::XML::SAX +end + +class Nokogiri::XML::SAX::Document + def cdata_block(string); end + def characters(string); end + def comment(string); end + def end_document; end + def end_element(name); end + def end_element_namespace(name, prefix = _, uri = _); end + def error(string); end + def processing_instruction(name, content); end + def start_document; end + def start_element(name, attrs = _); end + def start_element_namespace(name, attrs = _, prefix = _, uri = _, ns = _); end + def warning(string); end + def xmldecl(version, encoding, standalone); end +end + +class Nokogiri::XML::SAX::Parser + def initialize(doc = _, encoding = _); end + + def document; end + def document=(_); end + def encoding; end + def encoding=(_); end + def parse(thing, &block); end + def parse_file(filename); end + def parse_io(io, encoding = _); end + def parse_memory(data); end + + private + + def check_encoding(encoding); end +end + +class Nokogiri::XML::SAX::Parser::Attribute < ::Struct +end + +Nokogiri::XML::SAX::Parser::ENCODINGS = T.let(T.unsafe(nil), Hash) + +class Nokogiri::XML::SAX::ParserContext + def column; end + def line; end + def parse_with(_); end + def recovery; end + def recovery=(_); end + def replace_entities; end + def replace_entities=(_); end + + def self.file(_); end + def self.io(_, _); end + def self.memory(_); end + def self.new(thing, encoding = _); end +end + +class Nokogiri::XML::SAX::PushParser + def initialize(doc = _, file_name = _, encoding = _); end + + def <<(chunk, last_chunk = _); end + def document; end + def document=(_); end + def finish; end + def options; end + def options=(_); end + def replace_entities; end + def replace_entities=(_); end + def write(chunk, last_chunk = _); end + + private + + def initialize_native(_, _); end + def native_write(_, _); end +end + +class Nokogiri::XML::Schema + def errors; end + def errors=(_); end + def valid?(thing); end + def validate(thing); end + + private + + def validate_document(_); end + def validate_file(_); end + + def self.from_document(_); end + def self.new(string_or_io); end + def self.read_memory(_); end +end + +module Nokogiri::XML::Searchable + def %(*args); end + def /(*args); end + def at(*args); end + def at_css(*args); end + def at_xpath(*args); end + def css(*args); end + def search(*args); end + def xpath(*args); end + + private + + def css_internal(node, rules, handler, ns); end + def css_rules_to_xpath(rules, ns); end + def extract_params(params); end + def xpath_impl(node, path, handler, ns, binds); end + def xpath_internal(node, paths, handler, ns, binds); end + def xpath_query_from_css_rule(rule, ns); end +end + +Nokogiri::XML::Searchable::LOOKS_LIKE_XPATH = T.let(T.unsafe(nil), Regexp) + +class Nokogiri::XML::SyntaxError < ::Nokogiri::SyntaxError + def code; end + def column; end + def domain; end + def error?; end + def fatal?; end + def file; end + def int1; end + def level; end + def line; end + def none?; end + def str1; end + def str2; end + def str3; end + def to_s; end + def warning?; end + + private + + def level_to_s; end + def location_to_s; end + def nil_or_zero?(attribute); end +end + +class Nokogiri::XML::Text < ::Nokogiri::XML::CharacterData + def content=(string); end + + def self.new(*_); end +end + +Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::XML_C14N_1_1 = T.let(T.unsafe(nil), Integer) + +Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0 = T.let(T.unsafe(nil), Integer) + +class Nokogiri::XML::XPath + def document; end + def document=(_); end +end + +class Nokogiri::XML::XPath::SyntaxError < ::Nokogiri::XML::SyntaxError + def to_s; end +end + +class Nokogiri::XML::XPathContext + def evaluate(*_); end + def register_namespaces(namespaces); end + def register_ns(_, _); end + def register_variable(_, _); end + + def self.new(_); end +end + +module Nokogiri::XSLT + def self.parse(string, modules = _); end + def self.quote_params(params); end + def self.register(_, _); end +end + +class Nokogiri::XSLT::Stylesheet + def apply_to(document, params = _); end + def serialize(_); end + def transform(*_); end + + def self.parse_stylesheet_doc(_); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi new file mode 100644 index 0000000000..ac12411ec2 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi @@ -0,0 +1,232 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Net::NTLM + def self.apply_des(plain, keys); end + def self.decode_utf16le(str); end + def self.encode_utf16le(str); end + def self.gen_keys(str); end + def self.lm_hash(password); end + def self.lm_response(arg); end + def self.lmv2_response(arg, opt = _); end + def self.ntlm2_session(arg, opt = _); end + def self.ntlm_hash(password, opt = _); end + def self.ntlm_response(arg); end + def self.ntlmv2_hash(user, password, target, opt = _); end + def self.ntlmv2_response(arg, opt = _); end + def self.pack_int64le(val); end + def self.split7(str); end + def self.swap16(str); end +end + +class Net::NTLM::Blob < ::Net::NTLM::FieldSet + def blob_signature; end + def blob_signature=(val); end + def challenge; end + def challenge=(val); end + def reserved; end + def reserved=(val); end + def target_info; end + def target_info=(val); end + def timestamp; end + def timestamp=(val); end + def unknown1; end + def unknown1=(val); end + def unknown2; end + def unknown2=(val); end + + def self.inherited(subclass); end +end + +class Net::NTLM::Field + def initialize(opts); end + + def active; end + def active=(_); end + def size; end + def value; end + def value=(_); end +end + +class Net::NTLM::FieldSet + def initialize; end + + def [](name); end + def []=(name, val); end + def disable(name); end + def enable(name); end + def parse(str, offset = _); end + def serialize; end + def size; end + + def self.define(&block); end + def self.int16LE(name, opts); end + def self.int32LE(name, opts); end + def self.int64LE(name, opts); end + def self.names; end + def self.opts; end + def self.prototypes; end + def self.security_buffer(name, opts); end + def self.string(name, opts); end + def self.types; end +end + +class Net::NTLM::Int16LE < ::Net::NTLM::Field + def initialize(opt); end + + def parse(str, offset = _); end + def serialize; end +end + +class Net::NTLM::Int32LE < ::Net::NTLM::Field + def initialize(opt); end + + def parse(str, offset = _); end + def serialize; end +end + +class Net::NTLM::Int64LE < ::Net::NTLM::Field + def initialize(opt); end + + def parse(str, offset = _); end + def serialize; end +end + +class Net::NTLM::Message < ::Net::NTLM::FieldSet + def data_size; end + def decode64(str); end + def dump_flags; end + def encode64; end + def has_flag?(flag); end + def head_size; end + def serialize; end + def set_flag(flag); end + def size; end + + private + + def data_edge; end + def deflag; end + def security_buffers; end + + def self.decode64(str); end + def self.parse(str); end +end + +class Net::NTLM::Message::Type0 < ::Net::NTLM::Message + def sign; end + def sign=(val); end + def type; end + def type=(val); end + + def self.inherited(subclass); end +end + +class Net::NTLM::Message::Type1 < ::Net::NTLM::Message + def domain; end + def domain=(val); end + def flag; end + def flag=(val); end + def padding; end + def padding=(val); end + def parse(str); end + def sign; end + def sign=(val); end + def type; end + def type=(val); end + def workstation; end + def workstation=(val); end + + def self.inherited(subclass); end + def self.parse(str); end +end + +class Net::NTLM::Message::Type2 < ::Net::NTLM::Message + def challenge; end + def challenge=(val); end + def context; end + def context=(val); end + def flag; end + def flag=(val); end + def padding; end + def padding=(val); end + def parse(str); end + def response(arg, opt = _); end + def sign; end + def sign=(val); end + def target_info; end + def target_info=(val); end + def target_name; end + def target_name=(val); end + def type; end + def type=(val); end + + def self.inherited(subclass); end + def self.parse(str); end +end + +class Net::NTLM::Message::Type3 < ::Net::NTLM::Message + def domain; end + def domain=(val); end + def flag; end + def flag=(val); end + def lm_response; end + def lm_response=(val); end + def ntlm_response; end + def ntlm_response=(val); end + def session_key; end + def session_key=(val); end + def sign; end + def sign=(val); end + def type; end + def type=(val); end + def user; end + def user=(val); end + def workstation; end + def workstation=(val); end + + def self.create(arg, opt = _); end + def self.inherited(subclass); end + def self.parse(str); end +end + +class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet + def initialize(opts); end + + def active; end + def active=(_); end + def allocated; end + def allocated=(val); end + def data_size; end + def length; end + def length=(val); end + def offset; end + def offset=(val); end + def parse(str, offset = _); end + def serialize; end + def value; end + def value=(val); end + + def self.inherited(subclass); end +end + +class Net::NTLM::String < ::Net::NTLM::Field + def initialize(opts); end + + def parse(str, offset = _); end + def serialize; end + def value=(val); end +end + +module Net::NTLM::VERSION +end + +Net::NTLM::VERSION::MAJOR = T.let(T.unsafe(nil), Integer) + +Net::NTLM::VERSION::MINOR = T.let(T.unsafe(nil), Integer) + +Net::NTLM::VERSION::STRING = T.let(T.unsafe(nil), String) + +Net::NTLM::VERSION::TINY = T.let(T.unsafe(nil), Integer) diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.1.rbi new file mode 100644 index 0000000000..c8028fd195 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/parallel@1.19.1.rbi @@ -0,0 +1,90 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Parallel + extend(::Parallel::ProcessorCount) + + def self.all?(*args, &block); end + def self.any?(*args, &block); end + def self.each(array, options = _, &block); end + def self.each_with_index(array, options = _, &block); end + def self.flat_map(*args, &block); end + def self.in_processes(options = _, &block); end + def self.in_threads(options = _); end + def self.map(source, options = _, &block); end + def self.map_with_index(array, options = _, &block); end + def self.worker_number; end + def self.worker_number=(worker_num); end +end + +class Parallel::Break < ::StandardError +end + +class Parallel::DeadWorker < ::StandardError +end + +class Parallel::ExceptionWrapper + def initialize(exception); end + + def exception; end +end + +class Parallel::JobFactory + def initialize(source, mutex); end + + def next; end + def pack(item, index); end + def size; end + def unpack(data); end + + private + + def producer?; end + def queue_wrapper(array); end +end + +class Parallel::Kill < ::StandardError +end + +module Parallel::ProcessorCount + def physical_processor_count; end + def processor_count; end +end + +Parallel::Stop = T.let(T.unsafe(nil), Object) + +class Parallel::UndumpableException < ::StandardError + def initialize(original); end + + def backtrace; end +end + +class Parallel::UserInterruptHandler + def self.kill(thing); end + def self.kill_on_ctrl_c(pids, options); end +end + +Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol) + +Parallel::VERSION = T.let(T.unsafe(nil), String) + +Parallel::Version = T.let(T.unsafe(nil), String) + +class Parallel::Worker + def initialize(read, write, pid); end + + def close_pipes; end + def pid; end + def read; end + def stop; end + def thread; end + def thread=(_); end + def work(data); end + def write; end + + private + + def wait; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi new file mode 100644 index 0000000000..af1353e250 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi @@ -0,0 +1,80 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module ParallelTests + def self.bundler_enabled?; end + def self.delta; end + def self.determine_number_of_processes(count); end + def self.first_process?; end + def self.last_process?; end + def self.now; end + def self.number_of_running_processes; end + def self.pid_file_path; end + def self.pids; end + def self.stop_all_processes; end + def self.wait_for_other_processes_to_finish; end + def self.with_pid_file; end + def self.with_ruby_binary(command); end +end + +class ParallelTests::CLI + def run(argv); end + + private + + def any_test_failed?(test_results); end + def append_test_options(options, argv); end + def detailed_duration(seconds); end + def execute_in_parallel(items, num_processes, options); end + def execute_shell_command_in_parallel(command, num_processes, options); end + def extract_file_paths(argv); end + def extract_test_options(argv); end + def final_fail_message; end + def first_is_1?; end + def handle_interrupt; end + def load_runner(type); end + def lock(lockfile); end + def parse_options!(argv); end + def report_failure_rerun_commmand(test_results, options); end + def report_number_of_tests(groups); end + def report_results(test_results, options); end + def report_time_taken; end + def reprint_output(result, lockfile); end + def run_tests(group, process_number, num_processes, options); end + def run_tests_in_parallel(num_processes, options); end + def simulate_output_for_ci(simulate); end + def use_colors?; end +end + +class ParallelTests::Grouper + def self.by_scenarios(tests, num_groups, options = _); end + def self.by_steps(tests, num_groups, options); end + def self.in_even_groups_by_size(items, num_groups, options = _); end +end + +class ParallelTests::Pids + def initialize(file_path); end + + def add(pid); end + def all; end + def count; end + def delete(pid); end + def file_path; end + def mutex; end + + private + + def clear; end + def pids; end + def read; end + def save; end + def sync; end +end + +ParallelTests::RUBY_BINARY = T.let(T.unsafe(nil), String) + +ParallelTests::VERSION = T.let(T.unsafe(nil), String) + +ParallelTests::Version = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.3.rbi new file mode 100644 index 0000000000..282993d64d --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/parser@2.7.1.3.rbi @@ -0,0 +1,1131 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Parser +end + +module Parser::AST +end + +class Parser::AST::Node < ::AST::Node + def assign_properties(properties); end + def loc; end + def location; end +end + +class Parser::AST::Processor < ::AST::Processor + def on_alias(node); end + def on_and(node); end + def on_and_asgn(node); end + def on_arg(node); end + def on_arg_expr(node); end + def on_args(node); end + def on_argument(node); end + def on_array(node); end + def on_array_pattern(node); end + def on_array_pattern_with_tail(node); end + def on_back_ref(node); end + def on_begin(node); end + def on_block(node); end + def on_block_pass(node); end + def on_blockarg(node); end + def on_blockarg_expr(node); end + def on_break(node); end + def on_case(node); end + def on_case_match(node); end + def on_casgn(node); end + def on_class(node); end + def on_const(node); end + def on_const_pattern(node); end + def on_csend(node); end + def on_cvar(node); end + def on_cvasgn(node); end + def on_def(node); end + def on_def_e(node); end + def on_defined?(node); end + def on_defs(node); end + def on_defs_e(node); end + def on_dstr(node); end + def on_dsym(node); end + def on_eflipflop(node); end + def on_empty_else(node); end + def on_ensure(node); end + def on_erange(node); end + def on_for(node); end + def on_gvar(node); end + def on_gvasgn(node); end + def on_hash(node); end + def on_hash_pattern(node); end + def on_if(node); end + def on_if_guard(node); end + def on_iflipflop(node); end + def on_in_match(node); end + def on_in_pattern(node); end + def on_index(node); end + def on_indexasgn(node); end + def on_irange(node); end + def on_ivar(node); end + def on_ivasgn(node); end + def on_kwarg(node); end + def on_kwbegin(node); end + def on_kwoptarg(node); end + def on_kwrestarg(node); end + def on_kwsplat(node); end + def on_lambda(node); end + def on_lvar(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_match_alt(node); end + def on_match_as(node); end + def on_match_current_line(node); end + def on_match_rest(node); end + def on_match_var(node); end + def on_match_with_lvasgn(node); end + def on_mlhs(node); end + def on_module(node); end + def on_mrasgn(node); end + def on_next(node); end + def on_not(node); end + def on_nth_ref(node); end + def on_numblock(node); end + def on_op_asgn(node); end + def on_optarg(node); end + def on_or(node); end + def on_or_asgn(node); end + def on_pair(node); end + def on_pin(node); end + def on_postexe(node); end + def on_preexe(node); end + def on_procarg0(node); end + def on_rasgn(node); end + def on_redo(node); end + def on_regexp(node); end + def on_resbody(node); end + def on_rescue(node); end + def on_restarg(node); end + def on_restarg_expr(node); end + def on_retry(node); end + def on_return(node); end + def on_sclass(node); end + def on_send(node); end + def on_shadowarg(node); end + def on_splat(node); end + def on_super(node); end + def on_undef(node); end + def on_unless_guard(node); end + def on_until(node); end + def on_until_post(node); end + def on_var(node); end + def on_vasgn(node); end + def on_when(node); end + def on_while(node); end + def on_while_post(node); end + def on_xstr(node); end + def on_yield(node); end + def process_argument_node(node); end + def process_regular_node(node); end + def process_var_asgn_node(node); end + def process_variable_node(node); end +end + +class Parser::Base < ::Racc::Parser + def initialize(builder = _); end + + def builder; end + def context; end + def current_arg_stack; end + def diagnostics; end + def max_numparam_stack; end + def parse(source_buffer); end + def parse_with_comments(source_buffer); end + def pattern_hash_keys; end + def pattern_variables; end + def reset; end + def source_buffer; end + def static_env; end + def tokenize(source_buffer, recover = _); end + + private + + def check_kwarg_name(name_t); end + def diagnostic(level, reason, arguments, location_t, highlights_ts = _); end + def next_token; end + def on_error(error_token_id, error_value, value_stack); end + + def self.default_parser; end + def self.parse(string, file = _, line = _); end + def self.parse_file(filename); end + def self.parse_file_with_comments(filename); end + def self.parse_with_comments(string, file = _, line = _); end +end + +module Parser::Builders +end + +class Parser::Builders::Default + def initialize; end + + def __ENCODING__(__ENCODING__t); end + def __FILE__(__FILE__t); end + def __LINE__(__LINE__t); end + def accessible(node); end + def alias(alias_t, to, from); end + def arg(name_t); end + def arg_expr(expr); end + def args(begin_t, args, end_t, check_args = _); end + def array(begin_t, elements, end_t); end + def array_pattern(lbrack_t, elements, rbrack_t); end + def assign(lhs, eql_t, rhs); end + def assignable(node); end + def associate(begin_t, pairs, end_t); end + def attr_asgn(receiver, dot_t, selector_t); end + def back_ref(token); end + def begin(begin_t, body, end_t); end + def begin_body(compound_stmt, rescue_bodies = _, else_t = _, else_ = _, ensure_t = _, ensure_ = _); end + def begin_keyword(begin_t, body, end_t); end + def binary_op(receiver, operator_t, arg); end + def block(method_call, begin_t, args, body, end_t); end + def block_pass(amper_t, arg); end + def blockarg(amper_t, name_t); end + def blockarg_expr(amper_t, expr); end + def call_lambda(lambda_t); end + def call_method(receiver, dot_t, selector_t, lparen_t = _, args = _, rparen_t = _); end + def call_type_for_dot(dot_t); end + def case(case_t, expr, when_bodies, else_t, else_body, end_t); end + def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end + def character(char_t); end + def complex(complex_t); end + def compstmt(statements); end + def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end + def condition_mod(if_true, if_false, cond_t, cond); end + def const(name_t); end + def const_fetch(scope, t_colon2, name_t); end + def const_global(t_colon3, name_t); end + def const_op_assignable(node); end + def const_pattern(const, ldelim_t, pattern, rdelim_t); end + def cvar(token); end + def dedent_string(node, dedent_level); end + def def_class(class_t, name, lt_t, superclass, body, end_t); end + def def_endless_method(def_t, name_t, args, assignment_t, body); end + def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end + def def_method(def_t, name_t, args, body, end_t); end + def def_module(module_t, name, body, end_t); end + def def_sclass(class_t, lshft_t, expr, body, end_t); end + def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end + def emit_file_line_as_literals; end + def emit_file_line_as_literals=(_); end + def false(false_t); end + def float(float_t); end + def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end + def forward_args(begin_t, dots_t, end_t); end + def forwarded_args(dots_t); end + def gvar(token); end + def hash_pattern(lbrace_t, kwargs, rbrace_t); end + def ident(token); end + def if_guard(if_t, if_body); end + def in_match(lhs, in_t, rhs); end + def in_pattern(in_t, pattern, guard, then_t, body); end + def index(receiver, lbrack_t, indexes, rbrack_t); end + def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end + def integer(integer_t); end + def ivar(token); end + def keyword_cmd(type, keyword_t, lparen_t = _, args = _, rparen_t = _); end + def kwarg(name_t); end + def kwnilarg(dstar_t, nil_t); end + def kwoptarg(name_t, value); end + def kwrestarg(dstar_t, name_t = _); end + def kwsplat(dstar_t, arg); end + def logical_op(type, lhs, op_t, rhs); end + def loop(type, keyword_t, cond, do_t, body, end_t); end + def loop_mod(type, body, keyword_t, cond); end + def match_alt(left, pipe_t, right); end + def match_as(value, assoc_t, as); end + def match_hash_var(name_t); end + def match_hash_var_from_str(begin_t, strings, end_t); end + def match_label(label_type, label); end + def match_nil_pattern(dstar_t, nil_t); end + def match_op(receiver, match_t, arg); end + def match_pair(label_type, label, value); end + def match_rest(star_t, name_t = _); end + def match_var(name_t); end + def match_with_trailing_comma(match, comma_t); end + def multi_assign(lhs, eql_t, rhs); end + def multi_lhs(begin_t, items, end_t); end + def multi_rassign(lhs, assoc_t, rhs); end + def nil(nil_t); end + def not_op(not_t, begin_t = _, receiver = _, end_t = _); end + def nth_ref(token); end + def numargs(max_numparam); end + def objc_kwarg(kwname_t, assoc_t, name_t); end + def objc_restarg(star_t, name = _); end + def objc_varargs(pair, rest_of_varargs); end + def op_assign(lhs, op_t, rhs); end + def optarg(name_t, eql_t, value); end + def pair(key, assoc_t, value); end + def pair_keyword(key_t, value); end + def pair_list_18(list); end + def pair_quoted(begin_t, parts, end_t, value); end + def parser; end + def parser=(_); end + def pin(pin_t, var); end + def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end + def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end + def procarg0(arg); end + def range_exclusive(lhs, dot3_t, rhs); end + def range_inclusive(lhs, dot2_t, rhs); end + def rassign(lhs, assoc_t, rhs); end + def rational(rational_t); end + def regexp_compose(begin_t, parts, end_t, options); end + def regexp_options(regopt_t); end + def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end + def restarg(star_t, name_t = _); end + def restarg_expr(star_t, expr = _); end + def self(token); end + def shadowarg(name_t); end + def splat(star_t, arg = _); end + def string(string_t); end + def string_compose(begin_t, parts, end_t); end + def string_internal(string_t); end + def symbol(symbol_t); end + def symbol_compose(begin_t, parts, end_t); end + def symbol_internal(symbol_t); end + def symbols_compose(begin_t, parts, end_t); end + def ternary(cond, question_t, if_true, colon_t, if_false); end + def true(true_t); end + def unary_num(unary_t, numeric); end + def unary_op(op_t, receiver); end + def undef_method(undef_t, names); end + def unless_guard(unless_t, unless_body); end + def when(when_t, patterns, then_t, body); end + def word(parts); end + def words_compose(begin_t, parts, end_t); end + def xstring_compose(begin_t, parts, end_t); end + + private + + def arg_name_collides?(this_name, that_name); end + def arg_prefix_map(op_t, name_t = _); end + def binary_op_map(left_e, op_t, right_e); end + def block_map(receiver_l, begin_t, end_t); end + def check_assignment_to_numparam(node); end + def check_condition(cond); end + def check_duplicate_arg(this_arg, map = _); end + def check_duplicate_args(args, map = _); end + def check_duplicate_pattern_key(name, loc); end + def check_duplicate_pattern_variable(name, loc); end + def check_lvar_name(name, loc); end + def collapse_string_parts?(parts); end + def collection_map(begin_t, parts, end_t); end + def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end + def constant_map(scope, colon2_t, name_t); end + def definition_map(keyword_t, operator_t, name_t, end_t); end + def delimited_string_map(string_t); end + def diagnostic(type, reason, arguments, location, highlights = _); end + def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end + def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end + def expr_map(loc); end + def for_map(keyword_t, in_t, begin_t, end_t); end + def guard_map(keyword_t, guard_body_e); end + def index_map(receiver_e, lbrack_t, rbrack_t); end + def join_exprs(left_expr, right_expr); end + def keyword_map(keyword_t, begin_t, args, end_t); end + def keyword_mod_map(pre_e, keyword_t, post_e); end + def kwarg_map(name_t, value_e = _); end + def loc(token); end + def module_definition_map(keyword_t, name_e, operator_t, end_t); end + def n(type, children, source_map); end + def n0(type, source_map); end + def numeric(kind, token); end + def pair_keyword_map(key_t, value_e); end + def pair_quoted_map(begin_t, end_t, value_e); end + def prefix_string_map(symbol); end + def range_map(start_e, op_t, end_e); end + def regexp_map(begin_t, end_t, options_e); end + def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end + def send_binary_op_map(lhs_e, selector_t, rhs_e); end + def send_index_map(receiver_e, lbrack_t, rbrack_t); end + def send_map(receiver_e, dot_t, selector_t, begin_t = _, args = _, end_t = _); end + def send_unary_op_map(selector_t, arg_e); end + def static_regexp(parts, options); end + def static_regexp_node(node); end + def static_string(nodes); end + def string_map(begin_t, parts, end_t); end + def string_value(token); end + def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end + def token_map(token); end + def unary_op_map(op_t, arg_e = _); end + def unquoted_map(token); end + def validate_definee(definee); end + def value(token); end + def var_send_map(variable_e); end + def variable_map(name_t); end + + def self.emit_arg_inside_procarg0; end + def self.emit_arg_inside_procarg0=(_); end + def self.emit_encoding; end + def self.emit_encoding=(_); end + def self.emit_index; end + def self.emit_index=(_); end + def self.emit_lambda; end + def self.emit_lambda=(_); end + def self.emit_procarg0; end + def self.emit_procarg0=(_); end + def self.modernize; end +end + +class Parser::ClobberingError < ::RuntimeError +end + +class Parser::Context + def initialize; end + + def class_definition_allowed?; end + def dynamic_const_definition_allowed?; end + def in_block?; end + def in_class?; end + def in_dynamic_block?; end + def in_lambda?; end + def indirectly_in_def?; end + def module_definition_allowed?; end + def pop; end + def push(state); end + def reset; end + def stack; end +end + +class Parser::CurrentArgStack + def initialize; end + + def pop; end + def push(value); end + def reset; end + def set(value); end + def stack; end + def top; end +end + +module Parser::Deprecation + def warn_of_deprecation; end + def warned_of_deprecation=(_); end +end + +class Parser::Diagnostic + def initialize(level, reason, arguments, location, highlights = _); end + + def arguments; end + def highlights; end + def level; end + def location; end + def message; end + def reason; end + def render; end + + private + + def first_line_only(range); end + def last_line_only(range); end + def render_line(range, ellipsis = _, range_end = _); end +end + +class Parser::Diagnostic::Engine + def initialize(consumer = _); end + + def all_errors_are_fatal; end + def all_errors_are_fatal=(_); end + def consumer; end + def consumer=(_); end + def ignore_warnings; end + def ignore_warnings=(_); end + def process(diagnostic); end + + protected + + def ignore?(diagnostic); end + def raise?(diagnostic); end +end + +Parser::Diagnostic::LEVELS = T.let(T.unsafe(nil), Array) + +class Parser::Lexer + def initialize(version); end + + def advance; end + def cmdarg; end + def cmdarg=(_); end + def command_start; end + def command_start=(_); end + def comments; end + def comments=(_); end + def cond; end + def cond=(_); end + def context; end + def context=(_); end + def dedent_level; end + def diagnostics; end + def diagnostics=(_); end + def encoding; end + def force_utf32; end + def force_utf32=(_); end + def in_kwarg; end + def in_kwarg=(_); end + def pop_cmdarg; end + def pop_cond; end + def push_cmdarg; end + def push_cond; end + def reset(reset_state = _); end + def source_buffer; end + def source_buffer=(source_buffer); end + def state; end + def state=(state); end + def static_env; end + def static_env=(_); end + def tokens; end + def tokens=(_); end + + protected + + def arg_or_cmdarg(cmd_state); end + def diagnostic(type, reason, arguments = _, location = _, highlights = _); end + def emit(type, value = _, s = _, e = _); end + def emit_comment(s = _, e = _); end + def emit_do(do_block = _); end + def emit_table(table, s = _, e = _); end + def encode_escape(ord); end + def eof_codepoint?(point); end + def literal; end + def next_state_for_literal(literal); end + def pop_literal; end + def push_literal(*args); end + def range(s = _, e = _); end + def stack_pop; end + def tok(s = _, e = _); end + def version?(*versions); end + + def self.lex_en_expr_arg; end + def self.lex_en_expr_arg=(_); end + def self.lex_en_expr_beg; end + def self.lex_en_expr_beg=(_); end + def self.lex_en_expr_cmdarg; end + def self.lex_en_expr_cmdarg=(_); end + def self.lex_en_expr_dot; end + def self.lex_en_expr_dot=(_); end + def self.lex_en_expr_end; end + def self.lex_en_expr_end=(_); end + def self.lex_en_expr_endarg; end + def self.lex_en_expr_endarg=(_); end + def self.lex_en_expr_endfn; end + def self.lex_en_expr_endfn=(_); end + def self.lex_en_expr_fname; end + def self.lex_en_expr_fname=(_); end + def self.lex_en_expr_labelarg; end + def self.lex_en_expr_labelarg=(_); end + def self.lex_en_expr_mid; end + def self.lex_en_expr_mid=(_); end + def self.lex_en_expr_value; end + def self.lex_en_expr_value=(_); end + def self.lex_en_expr_variable; end + def self.lex_en_expr_variable=(_); end + def self.lex_en_interp_backslash_delimited; end + def self.lex_en_interp_backslash_delimited=(_); end + def self.lex_en_interp_backslash_delimited_words; end + def self.lex_en_interp_backslash_delimited_words=(_); end + def self.lex_en_interp_string; end + def self.lex_en_interp_string=(_); end + def self.lex_en_interp_words; end + def self.lex_en_interp_words=(_); end + def self.lex_en_leading_dot; end + def self.lex_en_leading_dot=(_); end + def self.lex_en_line_begin; end + def self.lex_en_line_begin=(_); end + def self.lex_en_line_comment; end + def self.lex_en_line_comment=(_); end + def self.lex_en_plain_backslash_delimited; end + def self.lex_en_plain_backslash_delimited=(_); end + def self.lex_en_plain_backslash_delimited_words; end + def self.lex_en_plain_backslash_delimited_words=(_); end + def self.lex_en_plain_string; end + def self.lex_en_plain_string=(_); end + def self.lex_en_plain_words; end + def self.lex_en_plain_words=(_); end + def self.lex_en_regexp_modifiers; end + def self.lex_en_regexp_modifiers=(_); end + def self.lex_error; end + def self.lex_error=(_); end + def self.lex_start; end + def self.lex_start=(_); end +end + +class Parser::Lexer::Dedenter + def initialize(dedent_level); end + + def dedent(string); end + def interrupt; end +end + +Parser::Lexer::Dedenter::TAB_WIDTH = T.let(T.unsafe(nil), Integer) + +Parser::Lexer::ESCAPES = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::KEYWORDS = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash) + +class Parser::Lexer::Literal + def initialize(lexer, str_type, delimiter, str_s, heredoc_e = _, indent = _, dedent_body = _, label_allowed = _); end + + def backslash_delimited?; end + def dedent_level; end + def end_interp_brace_and_try_closing; end + def extend_content; end + def extend_space(ts, te); end + def extend_string(string, ts, te); end + def flush_string; end + def heredoc?; end + def heredoc_e; end + def infer_indent_level(line); end + def interpolate?; end + def munge_escape?(character); end + def nest_and_try_closing(delimiter, ts, te, lookahead = _); end + def plain_heredoc?; end + def regexp?; end + def saved_herebody_s; end + def saved_herebody_s=(_); end + def squiggly_heredoc?; end + def start_interp_brace; end + def str_s; end + def supports_line_continuation_via_slash?; end + def type; end + def words?; end + + protected + + def clear_buffer; end + def coerce_encoding(string); end + def delimiter?(delimiter); end + def emit(token, type, s, e); end + def emit_start_tok; end +end + +Parser::Lexer::Literal::DELIMITERS = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::Literal::TYPES = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::PUNCTUATION = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::PUNCTUATION_BEGIN = T.let(T.unsafe(nil), Hash) + +Parser::Lexer::REGEXP_META_CHARACTERS = T.let(T.unsafe(nil), Regexp) + +class Parser::Lexer::StackState + def initialize(name); end + + def active?; end + def clear; end + def empty?; end + def inspect; end + def lexpop; end + def pop; end + def push(bit); end + def to_s; end +end + +Parser::MESSAGES = T.let(T.unsafe(nil), Hash) + +class Parser::MaxNumparamStack + def initialize; end + + def has_numparams?; end + def has_ordinary_params!; end + def has_ordinary_params?; end + def pop; end + def push; end + def register(numparam); end + def stack; end + def top; end + + private + + def set(value); end +end + +module Parser::Messages + def self.compile(reason, arguments); end +end + +module Parser::Meta +end + +Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set) + +class Parser::Rewriter < ::Parser::AST::Processor + extend(::Parser::Deprecation) + + def initialize(*_); end + + def assignment?(node); end + def insert_after(range, content); end + def insert_before(range, content); end + def remove(range); end + def replace(range, content); end + def rewrite(source_buffer, ast); end + def wrap(range, before, after); end +end + +Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +module Parser::Source +end + +class Parser::Source::Buffer + def initialize(name, first_line = _, source: _); end + + def column_for_position(position); end + def decompose_position(position); end + def first_line; end + def last_line; end + def line_for_position(position); end + def line_range(lineno); end + def name; end + def raw_source=(input); end + def read; end + def slice(range); end + def source; end + def source=(input); end + def source_line(lineno); end + def source_lines; end + def source_range; end + + private + + def line_begins; end + def line_for(position); end + + def self.recognize_encoding(string); end + def self.reencode_string(input); end +end + +Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp) + +class Parser::Source::Comment + def initialize(range); end + + def ==(other); end + def document?; end + def inline?; end + def inspect; end + def loc; end + def location; end + def text; end + def type; end + + def self.associate(ast, comments); end + def self.associate_locations(ast, comments); end +end + +class Parser::Source::Comment::Associator + def initialize(ast, comments); end + + def associate; end + def associate_locations; end + def skip_directives; end + def skip_directives=(_); end + + private + + def advance_comment; end + def advance_through_directives; end + def associate_and_advance_comment(node); end + def children_in_source_order(node); end + def current_comment_before?(node); end + def current_comment_before_end?(node); end + def current_comment_decorates?(node); end + def do_associate; end + def process_leading_comments(node); end + def process_trailing_comments(node); end + def visit(node); end +end + +Parser::Source::Comment::Associator::MAGIC_COMMENT_RE = T.let(T.unsafe(nil), Regexp) + +Parser::Source::Comment::Associator::POSTFIX_TYPES = T.let(T.unsafe(nil), Set) + +class Parser::Source::Map + def initialize(expression); end + + def ==(other); end + def column; end + def expression; end + def first_line; end + def last_column; end + def last_line; end + def line; end + def node; end + def node=(node); end + def to_hash; end + def with_expression(expression_l); end + + protected + + def update_expression(expression_l); end + def with(&block); end + + private + + def initialize_copy(other); end +end + +class Parser::Source::Map::Collection < ::Parser::Source::Map + def initialize(begin_l, end_l, expression_l); end + + def begin; end + def end; end +end + +class Parser::Source::Map::Condition < ::Parser::Source::Map + def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end + + def begin; end + def else; end + def end; end + def keyword; end +end + +class Parser::Source::Map::Constant < ::Parser::Source::Map + def initialize(double_colon, name, expression); end + + def double_colon; end + def name; end + def operator; end + def with_operator(operator_l); end + + protected + + def update_operator(operator_l); end +end + +class Parser::Source::Map::Definition < ::Parser::Source::Map + def initialize(keyword_l, operator_l, name_l, end_l); end + + def end; end + def keyword; end + def name; end + def operator; end +end + +class Parser::Source::Map::EndlessDefinition < ::Parser::Source::Map + def initialize(keyword_l, operator_l, name_l, assignment_l, body_l); end + + def assignment; end + def keyword; end + def name; end + def operator; end +end + +class Parser::Source::Map::For < ::Parser::Source::Map + def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end + + def begin; end + def end; end + def in; end + def keyword; end +end + +class Parser::Source::Map::Heredoc < ::Parser::Source::Map + def initialize(begin_l, body_l, end_l); end + + def heredoc_body; end + def heredoc_end; end +end + +class Parser::Source::Map::Index < ::Parser::Source::Map + def initialize(begin_l, end_l, expression_l); end + + def begin; end + def end; end + def operator; end + def with_operator(operator_l); end + + protected + + def update_operator(operator_l); end +end + +class Parser::Source::Map::Keyword < ::Parser::Source::Map + def initialize(keyword_l, begin_l, end_l, expression_l); end + + def begin; end + def end; end + def keyword; end +end + +class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map + def initialize(keyword_l, operator_l, argument_l, expression_l); end + + def argument; end + def keyword; end + def operator; end +end + +class Parser::Source::Map::Operator < ::Parser::Source::Map + def initialize(operator, expression); end + + def operator; end +end + +class Parser::Source::Map::RescueBody < ::Parser::Source::Map + def initialize(keyword_l, assoc_l, begin_l, expression_l); end + + def assoc; end + def begin; end + def keyword; end +end + +class Parser::Source::Map::Send < ::Parser::Source::Map + def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end + + def begin; end + def dot; end + def end; end + def operator; end + def selector; end + def with_operator(operator_l); end + + protected + + def update_operator(operator_l); end +end + +class Parser::Source::Map::Ternary < ::Parser::Source::Map + def initialize(question_l, colon_l, expression_l); end + + def colon; end + def question; end +end + +class Parser::Source::Map::Variable < ::Parser::Source::Map + def initialize(name_l, expression_l = _); end + + def name; end + def operator; end + def with_operator(operator_l); end + + protected + + def update_operator(operator_l); end +end + +class Parser::Source::Range + include(::Comparable) + + def initialize(source_buffer, begin_pos, end_pos); end + + def <=>(other); end + def adjust(begin_pos: _, end_pos: _); end + def begin; end + def begin_pos; end + def column; end + def column_range; end + def contained?(other); end + def contains?(other); end + def crossing?(other); end + def disjoint?(other); end + def empty?; end + def end; end + def end_pos; end + def eql?(_); end + def first_line; end + def hash; end + def inspect; end + def intersect(other); end + def is?(*what); end + def join(other); end + def last_column; end + def last_line; end + def length; end + def line; end + def overlaps?(other); end + def resize(new_size); end + def size; end + def source; end + def source_buffer; end + def source_line; end + def to_a; end + def to_range; end + def to_s; end + def with(begin_pos: _, end_pos: _); end +end + +class Parser::Source::Rewriter + extend(::Parser::Deprecation) + + def initialize(source_buffer); end + + def diagnostics; end + def insert_after(range, content); end + def insert_after_multi(range, content); end + def insert_before(range, content); end + def insert_before_multi(range, content); end + def process; end + def remove(range); end + def replace(range, content); end + def source_buffer; end + def transaction; end + def wrap(range, before, after); end + + private + + def active_clobber; end + def active_clobber=(value); end + def active_insertions; end + def active_insertions=(value); end + def active_queue; end + def adjacent?(range1, range2); end + def adjacent_insertion_mask(range); end + def adjacent_insertions?(range); end + def adjacent_position_mask(range); end + def adjacent_updates?(range); end + def append(action); end + def can_merge?(action, existing); end + def clobbered_insertion?(insertion); end + def clobbered_position_mask(range); end + def in_transaction?; end + def merge_actions(action, existing); end + def merge_actions!(action, existing); end + def merge_replacements(actions); end + def raise_clobber_error(action, existing); end + def record_insertion(range); end + def record_replace(range); end + def replace_actions(old, updated); end + def replace_compatible_with_insertion?(replace, insertion); end +end + +class Parser::Source::Rewriter::Action + include(::Comparable) + + def initialize(range, replacement = _, allow_multiple_insertions = _, order = _); end + + def <=>(other); end + def allow_multiple_insertions; end + def allow_multiple_insertions?; end + def order; end + def range; end + def replacement; end + def to_s; end +end + +Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +class Parser::Source::TreeRewriter + extend(::Parser::Deprecation) + + def initialize(source_buffer, crossing_deletions: _, different_replacements: _, swallowed_insertions: _); end + + def diagnostics; end + def empty?; end + def in_transaction?; end + def insert_after(range, content); end + def insert_after_multi(range, text); end + def insert_before(range, content); end + def insert_before_multi(range, text); end + def merge(with); end + def merge!(with); end + def process; end + def remove(range); end + def replace(range, content); end + def source_buffer; end + def transaction; end + def wrap(range, insert_before, insert_after); end + + protected + + def action_root; end + + private + + def check_policy_validity; end + def check_range_validity(range); end + def combine(range, attributes); end + def enforce_policy(event); end + def trigger_policy(event, range: _, conflict: _, **arguments); end +end + +Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array) + +class Parser::Source::TreeRewriter::Action + def initialize(range, enforcer, insert_before: _, replacement: _, insert_after: _, children: _); end + + def combine(action); end + def empty?; end + def insert_after; end + def insert_before; end + def insertion?; end + def ordered_replacements; end + def range; end + def replacement; end + + protected + + def analyse_hierarchy(action); end + def bsearch_child_index(from = _); end + def call_enforcer_for_merge(action); end + def check_fusible(action, *fusible); end + def children; end + def combine_children(more_children); end + def do_combine(action); end + def fuse_deletions(action, fusible, other_sibblings); end + def merge(action); end + def place_in_hierarchy(action); end + def swallow(children); end + def with(range: _, enforcer: _, children: _, insert_before: _, replacement: _, insert_after: _); end +end + +Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash) + +class Parser::StaticEnvironment + def initialize; end + + def declare(name); end + def declare_forward_args; end + def declared?(name); end + def declared_forward_args?; end + def extend_dynamic; end + def extend_static; end + def reset; end + def unextend; end +end + +Parser::StaticEnvironment::FORWARD_ARGS = T.let(T.unsafe(nil), Symbol) + +class Parser::SyntaxError < ::StandardError + def initialize(diagnostic); end + + def diagnostic; end +end + +class Parser::TreeRewriter < ::Parser::AST::Processor + def assignment?(node); end + def insert_after(range, content); end + def insert_before(range, content); end + def remove(range); end + def replace(range, content); end + def rewrite(source_buffer, ast, **policy); end + def wrap(range, before, after); end +end + +Parser::VERSION = T.let(T.unsafe(nil), String) + +class Parser::VariablesStack + def initialize; end + + def declare(name); end + def declared?(name); end + def pop; end + def push; end + def reset; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi new file mode 100644 index 0000000000..c71ad6f371 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi @@ -0,0 +1,125 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Plist + def self.parse_xml(filename_or_xml); end +end + +module Plist::Emit + def save_plist(filename, options = _); end + def to_plist(envelope = _, options = _); end + + def self.comment(content); end + def self.dump(obj, envelope = _, options = _); end + def self.element_type(item); end + def self.plist_node(element, options = _); end + def self.save_plist(obj, filename, options = _); end + def self.tag(type, contents = _, options = _, &block); end + def self.wrap(contents); end +end + +Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String) + +class Plist::Emit::IndentedString + def initialize(str = _); end + + def <<(val); end + def indent_string; end + def indent_string=(_); end + def lower_indent; end + def raise_indent; end + def to_s; end +end + +class Plist::Listener + def initialize; end + + def open; end + def open=(_); end + def result; end + def result=(_); end + def tag_end(name); end + def tag_start(name, attributes); end + def text(contents); end +end + +class Plist::PArray < ::Plist::PTag + def to_ruby; end +end + +class Plist::PData < ::Plist::PTag + def to_ruby; end +end + +class Plist::PDate < ::Plist::PTag + def to_ruby; end +end + +class Plist::PDict < ::Plist::PTag + def to_ruby; end +end + +class Plist::PFalse < ::Plist::PTag + def to_ruby; end +end + +class Plist::PInteger < ::Plist::PTag + def to_ruby; end +end + +class Plist::PKey < ::Plist::PTag + def to_ruby; end +end + +class Plist::PList < ::Plist::PTag + def to_ruby; end +end + +class Plist::PReal < ::Plist::PTag + def to_ruby; end +end + +class Plist::PString < ::Plist::PTag + def to_ruby; end +end + +class Plist::PTag + def initialize; end + + def children; end + def children=(_); end + def text; end + def text=(_); end + def to_ruby; end + + def self.inherited(sub_class); end + def self.mappings; end +end + +class Plist::PTrue < ::Plist::PTag + def to_ruby; end +end + +class Plist::StreamParser + def initialize(plist_data_or_file, listener); end + + def parse; end + + private + + def parse_encoding_from_xml_declaration(xml_declaration); end +end + +Plist::StreamParser::COMMENT_END = T.let(T.unsafe(nil), Regexp) + +Plist::StreamParser::COMMENT_START = T.let(T.unsafe(nil), Regexp) + +Plist::StreamParser::DOCTYPE_PATTERN = T.let(T.unsafe(nil), Regexp) + +Plist::StreamParser::TEXT = T.let(T.unsafe(nil), Regexp) + +Plist::StreamParser::XMLDECL_PATTERN = T.let(T.unsafe(nil), Regexp) + +Plist::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi new file mode 100644 index 0000000000..3a5115bbf6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi @@ -0,0 +1,142 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Rainbow + def self.enabled; end + def self.enabled=(value); end + def self.global; end + def self.new; end + def self.uncolor(string); end +end + +class Rainbow::Color + def ground; end + + def self.build(ground, values); end + def self.parse_hex_color(hex); end +end + +class Rainbow::Color::Indexed < ::Rainbow::Color + def initialize(ground, num); end + + def codes; end + def num; end +end + +class Rainbow::Color::Named < ::Rainbow::Color::Indexed + def initialize(ground, name); end + + def self.color_names; end + def self.valid_names; end +end + +Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash) + +class Rainbow::Color::RGB < ::Rainbow::Color::Indexed + def initialize(ground, *values); end + + def b; end + def codes; end + def g; end + def r; end + + private + + def code_from_rgb; end + + def self.to_ansi_domain(value); end +end + +class Rainbow::Color::X11Named < ::Rainbow::Color::RGB + include(::Rainbow::X11ColorNames) + + def initialize(ground, name); end + + def self.color_names; end + def self.valid_names; end +end + +class Rainbow::NullPresenter < ::String + def background(*_values); end + def bg(*_values); end + def black; end + def blink; end + def blue; end + def bold; end + def bright; end + def color(*_values); end + def cyan; end + def dark; end + def faint; end + def fg(*_values); end + def foreground(*_values); end + def green; end + def hide; end + def inverse; end + def italic; end + def magenta; end + def method_missing(method_name, *args); end + def red; end + def reset; end + def underline; end + def white; end + def yellow; end + + private + + def respond_to_missing?(method_name, *args); end +end + +class Rainbow::Presenter < ::String + def background(*values); end + def bg(*values); end + def black; end + def blink; end + def blue; end + def bold; end + def bright; end + def color(*values); end + def cyan; end + def dark; end + def faint; end + def fg(*values); end + def foreground(*values); end + def green; end + def hide; end + def inverse; end + def italic; end + def magenta; end + def method_missing(method_name, *args); end + def red; end + def reset; end + def underline; end + def white; end + def yellow; end + + private + + def respond_to_missing?(method_name, *args); end + def wrap_with_sgr(codes); end +end + +Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash) + +class Rainbow::StringUtils + def self.uncolor(string); end + def self.wrap_with_sgr(string, codes); end +end + +class Rainbow::Wrapper + def initialize(enabled = _); end + + def enabled; end + def enabled=(_); end + def wrap(string); end +end + +module Rainbow::X11ColorNames +end + +Rainbow::X11ColorNames::NAMES = T.let(T.unsafe(nil), Hash) diff --git a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi new file mode 100644 index 0000000000..c3f1a92010 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@1.7.1.rbi @@ -0,0 +1,1507 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Regexp::Expression + def self.parsed(exp); end +end + +class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation + def alternatives; end + def match_length; end +end + +Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative + +class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence +end + +module Regexp::Expression::Anchor +end + +Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine + +Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString + +class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base + def match_length; end +end + +class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base +end + +Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine + +Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString + +Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine + +class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base +end + +class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base +end + +module Regexp::Expression::Assertion +end + +class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base + def match_length; end +end + +class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base +end + +class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base +end + +class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base +end + +class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base +end + +module Regexp::Expression::Backreference +end + +class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base + def match_length; end + def referenced_expression; end + def referenced_expression=(_); end +end + +class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base + def initialize(token, options = _); end + + def name; end + def reference; end +end + +class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name +end + +class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name + def initialize(token, options = _); end + + def recursion_level; end +end + +class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base + def initialize(token, options = _); end + + def number; end + def reference; end +end + +class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number +end + +class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative +end + +class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number + def initialize(token, options = _); end + + def recursion_level; end +end + +class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number + def effective_number; end + def effective_number=(_); end + def reference; end +end + +class Regexp::Expression::Base + def initialize(token, options = _); end + + def =~(string, offset = _); end + def a?; end + def ascii_classes?; end + def attributes; end + def case_insensitive?; end + def coded_offset; end + def conditional_level; end + def conditional_level=(_); end + def d?; end + def default_classes?; end + def extended?; end + def free_spacing?; end + def full_length; end + def greedy?; end + def i?; end + def ignore_case?; end + def is?(test_token, test_type = _); end + def lazy?; end + def level; end + def level=(_); end + def m?; end + def match(string, offset = _); end + def match?(string); end + def matches?(string); end + def multiline?; end + def nesting_level; end + def nesting_level=(_); end + def offset; end + def one_of?(scope, top = _); end + def options; end + def options=(_); end + def possessive?; end + def quantified?; end + def quantifier; end + def quantifier=(_); end + def quantifier_affix(expression_format); end + def quantify(token, text, min = _, max = _, mode = _); end + def quantity; end + def reluctant?; end + def repetitions; end + def set_level; end + def set_level=(_); end + def starts_at; end + def strfre(format = _, indent_offset = _, index = _); end + def strfregexp(format = _, indent_offset = _, index = _); end + def terminal?; end + def text; end + def text=(_); end + def to_h; end + def to_re(format = _); end + def to_s(format = _); end + def token; end + def token=(_); end + def ts; end + def ts=(_); end + def type; end + def type=(_); end + def type?(test_type); end + def u?; end + def unicode_classes?; end + def unquantified_clone; end + def x?; end + + private + + def initialize_clone(orig); end +end + +class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression + def initialize(token, options = _); end + + def close; end + def closed; end + def closed=(_); end + def closed?; end + def match_length; end + def negate; end + def negated?; end + def negative; end + def negative=(_); end + def negative?; end + def to_s(format = _); end +end + +class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence + def match_length; end +end + +class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation + def match_length; end +end + +Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence + +class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression + def <<(exp); end + def complete?; end + def match_length; end + def starts_at; end + def to_s(_format = _); end + def ts; end +end + +module Regexp::Expression::CharacterType +end + +class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base + def match_length; end +end + +class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base +end + +class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace +end + +module Regexp::Expression::Conditional +end + +class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence +end + +class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base + def match_length; end + def reference; end + def referenced_expression; end + def referenced_expression=(_); end +end + +class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression + def <<(exp); end + def add_sequence(active_opts = _); end + def branch(active_opts = _); end + def branches; end + def condition; end + def condition=(exp); end + def match_length; end + def reference; end + def referenced_expression; end + def referenced_expression=(_); end + def to_s(format = _); end +end + +class Regexp::Expression::Conditional::TooManyBranches < ::StandardError + def initialize; end +end + +module Regexp::Expression::EscapeSequence +end + +class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base + def char; end + + private + + def control_sequence_to_s(control_sequence); end + def meta_char_to_codepoint(meta_char); end +end + +class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base + def char; end + def codepoint; end + def match_length; end +end + +class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base + def char; end + def chars; end + def codepoint; end + def codepoints; end + def match_length; end +end + +class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + def codepoint; end +end + +class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base + def char; end +end + +class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + def codepoint; end +end + +class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + def codepoint; end +end + +class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base + def char; end +end + +class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base +end + +class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base + def match_length; end + def quantify(token, text, min = _, max = _, mode = _); end +end + +module Regexp::Expression::Group +end + +class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base + def match_length; end +end + +class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base +end + +class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression + def capturing?; end + def comment?; end + def to_s(format = _); end +end + +class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base + def capturing?; end + def identifier; end + def number; end + def number=(_); end + def number_at_level; end + def number_at_level=(_); end +end + +class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base + def comment?; end + def to_s(_format = _); end +end + +class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture + def initialize(token, options = _); end + + def identifier; end + def name; end + + private + + def initialize_clone(orig); end +end + +class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base + def option_changes; end + def option_changes=(_); end +end + +class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base +end + +module Regexp::Expression::Keep +end + +class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base + def match_length; end +end + +class Regexp::Expression::Literal < ::Regexp::Expression::Base + def match_length; end +end + +Regexp::Expression::MatchLength = Regexp::MatchLength + +class Regexp::Expression::PosixClass < ::Regexp::Expression::Base + def match_length; end + def name; end + def negative?; end +end + +class Regexp::Expression::Quantifier + def initialize(token, text, min, max, mode); end + + def greedy?; end + def lazy?; end + def max; end + def min; end + def mode; end + def possessive?; end + def reluctant?; end + def text; end + def to_h; end + def to_s; end + def to_str; end + def token; end + + private + + def initialize_clone(orig); end +end + +Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array) + +class Regexp::Expression::Root < ::Regexp::Expression::Subexpression + def initialize(*args); end + + def self.build(options = _); end + def self.build_token; end +end + +class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression + def initialize(*args); end + + def quantify(token, text, min = _, max = _, mode = _); end + def starts_at; end + def ts; end + + def self.add_to(subexpression, params = _, active_opts = _); end + def self.at_levels(level, set_level, conditional_level); end +end + +class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression + def <<(exp); end + def add_sequence(active_opts = _); end + def operands; end + def operator; end + def sequences; end + def starts_at; end + def to_s(format = _); end + def ts; end +end + +class Regexp::Expression::Subexpression < ::Regexp::Expression::Base + include(::Enumerable) + + def initialize(token, options = _); end + + def <<(exp); end + def [](*args, &block); end + def at(*args, &block); end + def dig(*indices); end + def each(*args, &block); end + def each_expression(include_self = _, &block); end + def empty?(*args, &block); end + def expressions; end + def expressions=(_); end + def fetch(*args, &block); end + def flat_map(include_self = _, &block); end + def index(*args, &block); end + def inner_match_length; end + def join(*args, &block); end + def last(*args, &block); end + def length(*args, &block); end + def match_length; end + def strfre_tree(format = _, include_self = _, separator = _); end + def strfregexp_tree(format = _, include_self = _, separator = _); end + def te; end + def to_h; end + def to_s(format = _); end + def traverse(include_self = _, &block); end + def values_at(*args, &block); end + def walk(include_self = _, &block); end + + private + + def initialize_clone(orig); end +end + +module Regexp::Expression::UnicodeProperty +end + +class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base + def match_length; end + def name; end + def negative?; end + def shortcut; end +end + +class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Codepoint +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base +end + +class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Letter +end + +class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base +end + +class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Mark +end + +class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base +end + +class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base +end + +class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base +end + +class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base +end + +class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base +end + +class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Number +end + +class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base +end + +class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base +end + +class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base +end + +class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base +end + +class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Punctuation +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base +end + +class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Separator +end + +class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base +end + +class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base +end + +class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base +end + +class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base +end + +class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base +end + +module Regexp::Expression::UnicodeProperty::Symbol +end + +class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base +end + +class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base +end + +class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base +end + +class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base +end + +class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base +end + +class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base +end + +class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace + def merge(exp); end +end + +class Regexp::Lexer + def lex(input, syntax = _, &block); end + + private + + def ascend(type, token); end + def break_codepoint_list(token); end + def break_literal(token); end + def conditional_nesting; end + def conditional_nesting=(_); end + def descend(type, token); end + def merge_condition(current); end + def nesting; end + def nesting=(_); end + def set_nesting; end + def set_nesting=(_); end + def shift; end + def shift=(_); end + def tokens; end + def tokens=(_); end + + def self.lex(input, syntax = _, &block); end + def self.scan(input, syntax = _, &block); end +end + +Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array) + +Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array) + +class Regexp::MatchLength + include(::Enumerable) + + def initialize(exp, opts = _); end + + def each(opts = _); end + def endless_each(&block); end + def fixed?; end + def include?(length); end + def inspect; end + def max; end + def min; end + def minmax; end + def to_re; end + + private + + def base_max; end + def base_max=(_); end + def base_min; end + def base_min=(_); end + def exp_class; end + def exp_class=(_); end + def max_rep; end + def max_rep=(_); end + def min_rep; end + def min_rep=(_); end + def reify; end + def reify=(_); end + def test_regexp; end + + def self.of(obj); end +end + +class Regexp::Parser + include(::Regexp::Expression) + include(::Regexp::Syntax) + include(::Regexp::Expression::UnicodeProperty) + + def parse(input, syntax = _, &block); end + + private + + def active_opts; end + def anchor(token); end + def assign_effective_number(exp); end + def assign_referenced_expressions; end + def backref(token); end + def captured_group_count_at_level; end + def captured_group_counts; end + def captured_group_counts=(_); end + def close_completed_character_set_range; end + def close_group; end + def close_set; end + def conditional(token); end + def conditional_nesting; end + def conditional_nesting=(_); end + def count_captured_group; end + def decrease_nesting; end + def escape(token); end + def free_space(token); end + def group(token); end + def intersection(token); end + def interval(target_node, token); end + def keep(token); end + def meta(token); end + def negate_set; end + def nest(exp); end + def nest_conditional(exp); end + def nesting; end + def nesting=(_); end + def node; end + def node=(_); end + def open_group(token); end + def open_set(token); end + def options_from_input(input); end + def options_group(token); end + def options_stack; end + def options_stack=(_); end + def parse_token(token); end + def posixclass(token); end + def property(token); end + def quantifier(token); end + def range(token); end + def root; end + def root=(_); end + def sequence_operation(klass, token); end + def set(token); end + def switching_options; end + def switching_options=(_); end + def total_captured_group_count; end + def type(token); end + def update_transplanted_subtree(exp, new_parent); end + + def self.parse(input, syntax = _, &block); end +end + +Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array) + +Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array) + +class Regexp::Parser::ParserError < ::StandardError +end + +class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError + def initialize(type, token); end +end + +class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError + def initialize(type, token); end +end + +Regexp::Parser::VERSION = T.let(T.unsafe(nil), String) + +class Regexp::Scanner + def emit(type, token, text, ts, te); end + def scan(input_object, &block); end + + private + + def append_literal(data, ts, te); end + def block; end + def block=(_); end + def conditional_stack; end + def conditional_stack=(_); end + def copy(data, range); end + def emit_literal; end + def emit_meta_control_sequence(data, ts, te, token); end + def emit_options(text, ts, te); end + def free_spacing; end + def free_spacing=(_); end + def group_depth; end + def group_depth=(_); end + def in_group?; end + def in_set?; end + def literal; end + def literal=(_); end + def set_depth; end + def set_depth=(_); end + def spacing_stack; end + def spacing_stack=(_); end + def text(data, ts, te, soff = _); end + def tokens; end + def tokens=(_); end + def validation_error(type, what, reason); end + + def self.long_prop_map; end + def self.scan(input_object, &block); end + def self.short_prop_map; end +end + +class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError + def initialize(what, reason); end +end + +class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError + def initialize(what, reason); end +end + +class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError + def initialize(option, text); end +end + +class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError + def initialize(what = _, where = _); end +end + +Regexp::Scanner::PROP_MAPS_DIR = T.let(T.unsafe(nil), String) + +class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError + def initialize(where = _); end +end + +class Regexp::Scanner::ScannerError < ::StandardError +end + +class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError + def initialize(name); end +end + +class Regexp::Scanner::ValidationError < ::StandardError + def initialize(reason); end +end + +module Regexp::Syntax + + private + + def comparable_version(name); end + def const_missing(const_name); end + def fallback_version_class(version); end + def inherit_from_version(parent_version, new_version); end + def new(name); end + def specified_versions; end + def supported?(name); end + def version_class(version); end + def version_const_name(version_string); end + def warn_if_future_version(const_name); end + + def self.comparable_version(name); end + def self.const_missing(const_name); end + def self.fallback_version_class(version); end + def self.inherit_from_version(parent_version, new_version); end + def self.new(name); end + def self.specified_versions; end + def self.supported?(name); end + def self.version_class(version); end + def self.version_const_name(version_string); end + def self.warn_if_future_version(const_name); end +end + +class Regexp::Syntax::Any < ::Regexp::Syntax::Base + def initialize; end + + def implements!(type, token); end + def implements?(type, token); end +end + +class Regexp::Syntax::Base + include(::Regexp::Syntax::Token) + + def initialize; end + + def check!(type, token); end + def check?(type, token); end + def excludes(type, tokens); end + def features; end + def implementations(type); end + def implements(type, tokens); end + def implements!(type, token); end + def implements?(type, token); end + def normalize(type, token); end + def normalize_backref(type, token); end + def normalize_group(type, token); end + + def self.inspect; end +end + +class Regexp::Syntax::InvalidVersionNameError < ::SyntaxError + def initialize(name); end +end + +class Regexp::Syntax::NotImplementedError < ::SyntaxError + def initialize(syntax, type, token); end +end + +class Regexp::Syntax::SyntaxError < ::StandardError +end + +module Regexp::Syntax::Token +end + +Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array) + +module Regexp::Syntax::Token::Anchor +end + +Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Assertion +end + +Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Backreference +end + +Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::CharacterSet +end + +Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::CharacterType +end + +Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Conditional +end + +Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Escape +end + +Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array) + +module Regexp::Syntax::Token::FreeSpace +end + +Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Group +end + +Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array) + +module Regexp::Syntax::Token::Keep +end + +Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Literal +end + +Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash) + +module Regexp::Syntax::Token::Meta +end + +Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::PosixClass +end + +Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::Quantifier +end + +Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol) + +module Regexp::Syntax::Token::SubexpressionCall +end + +Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array) + +module Regexp::Syntax::Token::UnicodeProperty +end + +Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array) + +module Regexp::Syntax::Token::UnicodeProperty::Category +end + +Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array) + +Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array) + +class Regexp::Syntax::UnknownSyntaxNameError < ::SyntaxError + def initialize(name); end +end + +class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base + def initialize; end +end + +class Regexp::Syntax::V1_9 < ::Regexp::Syntax::V1_9_3 +end + +class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6 + def initialize; end +end + +class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1 + def initialize; end +end + +class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9 + def initialize; end +end + +class Regexp::Syntax::V2_1 < ::Regexp::Syntax::V2_0_0 +end + +class Regexp::Syntax::V2_2 < ::Regexp::Syntax::V2_2_0 +end + +class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_1 + def initialize; end +end + +class Regexp::Syntax::V2_3 < ::Regexp::Syntax::V2_3_0 +end + +class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2 + def initialize; end +end + +class Regexp::Syntax::V2_4 < ::Regexp::Syntax::V2_4_1 +end + +class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3 + def initialize; end +end + +class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0 + def initialize; end +end + +class Regexp::Syntax::V2_5 < ::Regexp::Syntax::V2_5_0 +end + +class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4 + def initialize; end +end + +class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5 + def initialize; end +end + +class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0 + def initialize; end +end + +class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2 + def initialize; end +end + +Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp) + +Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String) + +Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp) + +Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array) + +class Regexp::Token < ::Struct + def conditional_level; end + def conditional_level=(_); end + def length; end + def level; end + def level=(_); end + def next; end + def next=(_); end + def offset; end + def previous; end + def previous=(_); end + def set_level; end + def set_level=(_); end + def te; end + def te=(_); end + def text; end + def text=(_); end + def token; end + def token=(_); end + def ts; end + def ts=(_); end + def type; end + def type=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi new file mode 100644 index 0000000000..d01c2cbc39 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi @@ -0,0 +1,678 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class Array + include(::Enumerable) + include(::JSON::Ext::Generator::GeneratorMethods::Array) + include(::Plist::Emit) + + def dclone; end +end + +class Float < ::Numeric + include(::JSON::Ext::Generator::GeneratorMethods::Float) + + def dclone; end +end + +class Integer < ::Numeric + include(::JSON::Ext::Generator::GeneratorMethods::Integer) + + def dclone; end +end + +Integer::GMP_VERSION = T.let(T.unsafe(nil), String) + +class Object < ::BasicObject + include(::Kernel) + include(::JSON::Ext::Generator::GeneratorMethods::Object) + include(::PP::ObjectMixin) + + def dclone; end +end + +class REXML::AttlistDecl < ::REXML::Child + include(::Enumerable) + + def initialize(source); end + + def [](key); end + def each(&block); end + def element_name; end + def include?(key); end + def node_type; end + def write(out, indent = _); end +end + +class REXML::Attribute + include(::REXML::Node) + include(::REXML::XMLTokens) + include(::REXML::Namespace) + + def initialize(first, second = _, parent = _); end + + def ==(other); end + def clone; end + def doctype; end + def element; end + def element=(element); end + def hash; end + def inspect; end + def namespace(arg = _); end + def node_type; end + def normalized=(_); end + def prefix; end + def remove; end + def to_s; end + def to_string; end + def value; end + def write(output, indent = _); end + def xpath; end +end + +class REXML::Attributes < ::Hash + def initialize(element); end + + def <<(attribute); end + def [](name); end + def []=(name, value); end + def add(attribute); end + def delete(attribute); end + def delete_all(name); end + def each; end + def each_attribute; end + def get_attribute(name); end + def get_attribute_ns(namespace, name); end + def length; end + def namespaces; end + def prefixes; end + def size; end + def to_a; end +end + +class REXML::CData < ::REXML::Text + def initialize(first, whitespace = _, parent = _); end + + def clone; end + def to_s; end + def value; end + def write(output = _, indent = _, transitive = _, ie_hack = _); end +end + +class REXML::Child + include(::REXML::Node) + + def initialize(parent = _); end + + def bytes; end + def document; end + def next_sibling; end + def next_sibling=(other); end + def parent; end + def parent=(other); end + def previous_sibling; end + def previous_sibling=(other); end + def remove; end + def replace_with(child); end +end + +class REXML::Comment < ::REXML::Child + include(::Comparable) + + def initialize(first, second = _); end + + def <=>(other); end + def ==(other); end + def clone; end + def node_type; end + def string; end + def string=(_); end + def to_s; end + def write(output, indent = _, transitive = _, ie_hack = _); end +end + +class REXML::Declaration < ::REXML::Child + def initialize(src); end + + def to_s; end + def write(output, indent); end +end + +class REXML::DocType < ::REXML::Parent + include(::REXML::XMLTokens) + + def initialize(first, parent = _); end + + def add(child); end + def attribute_of(element, attribute); end + def attributes_of(element); end + def clone; end + def context; end + def entities; end + def entity(name); end + def external_id; end + def name; end + def namespaces; end + def node_type; end + def notation(name); end + def notations; end + def public; end + def system; end + def write(output, indent = _, transitive = _, ie_hack = _); end + + private + + def strip_quotes(quoted_string); end +end + +class REXML::Document < ::REXML::Element + def initialize(source = _, context = _); end + + def <<(child); end + def add(child); end + def add_element(arg = _, arg2 = _); end + def clone; end + def doctype; end + def document; end + def encoding; end + def entity_expansion_count; end + def expanded_name; end + def name; end + def node_type; end + def record_entity_expansion; end + def root; end + def stand_alone?; end + def version; end + def write(*arguments); end + def xml_decl; end + + private + + def build(source); end + + def self.entity_expansion_limit; end + def self.entity_expansion_limit=(val); end + def self.entity_expansion_text_limit; end + def self.entity_expansion_text_limit=(val); end + def self.parse_stream(source, listener); end +end + +class REXML::Element < ::REXML::Parent + include(::REXML::XMLTokens) + include(::REXML::Namespace) + + def initialize(arg = _, parent = _, context = _); end + + def [](name_or_index); end + def add_attribute(key, value = _); end + def add_attributes(hash); end + def add_element(element, attrs = _); end + def add_namespace(prefix, uri = _); end + def add_text(text); end + def attribute(name, namespace = _); end + def attributes; end + def cdatas; end + def clone; end + def comments; end + def context; end + def context=(_); end + def delete_attribute(key); end + def delete_element(element); end + def delete_namespace(namespace = _); end + def document; end + def each_element(xpath = _, &block); end + def each_element_with_attribute(key, value = _, max = _, name = _, &block); end + def each_element_with_text(text = _, max = _, name = _, &block); end + def elements; end + def get_elements(xpath); end + def get_text(path = _); end + def has_attributes?; end + def has_elements?; end + def has_text?; end + def ignore_whitespace_nodes; end + def inspect; end + def instructions; end + def namespace(prefix = _); end + def namespaces; end + def next_element; end + def node_type; end + def prefixes; end + def previous_element; end + def raw; end + def root; end + def root_node; end + def text(path = _); end + def text=(text); end + def texts; end + def whitespace; end + def write(output = _, indent = _, transitive = _, ie_hack = _); end + def xpath; end + + private + + def __to_xpath_helper(node); end + def each_with_something(test, max = _, name = _); end +end + +class REXML::Elements + include(::Enumerable) + + def initialize(parent); end + + def <<(element = _); end + def [](index, name = _); end + def []=(index, element); end + def add(element = _); end + def collect(xpath = _); end + def delete(element); end + def delete_all(xpath); end + def each(xpath = _); end + def empty?; end + def index(element); end + def inject(xpath = _, initial = _); end + def size; end + def to_a(xpath = _); end + + private + + def literalize(name); end +end + +module REXML::Encoding + def decode(string); end + def encode(string); end + def encoding; end + def encoding=(encoding); end + + private + + def find_encoding(name); end +end + +class REXML::Entity < ::REXML::Child + include(::REXML::XMLTokens) + + def initialize(stream, value = _, parent = _, reference = _); end + + def external; end + def name; end + def ndata; end + def normalized; end + def pubid; end + def ref; end + def to_s; end + def unnormalized; end + def value; end + def write(out, indent = _); end + + def self.matches?(string); end +end + +class REXML::ExternalEntity < ::REXML::Child + def initialize(src); end + + def to_s; end + def write(output, indent); end +end + +class REXML::Formatters::Default + def initialize(ie_hack = _); end + + def write(node, output); end + + protected + + def write_cdata(node, output); end + def write_comment(node, output); end + def write_document(node, output); end + def write_element(node, output); end + def write_instruction(node, output); end + def write_text(node, output); end +end + +class REXML::Formatters::Pretty < ::REXML::Formatters::Default + def initialize(indentation = _, ie_hack = _); end + + def compact; end + def compact=(_); end + def width; end + def width=(_); end + + protected + + def write_cdata(node, output); end + def write_comment(node, output); end + def write_document(node, output); end + def write_element(node, output); end + def write_text(node, output); end + + private + + def indent_text(string, level = _, style = _, indentfirstline = _); end + def wrap(string, width); end +end + +class REXML::IOSource < ::REXML::Source + def initialize(arg, block_size = _, encoding = _); end + + def consume(pattern); end + def current_line; end + def empty?; end + def match(pattern, cons = _); end + def position; end + def read; end + def scan(pattern, cons = _); end + + private + + def encoding_updated; end + def readline; end +end + +class REXML::Instruction < ::REXML::Child + def initialize(target, content = _); end + + def ==(other); end + def clone; end + def content; end + def content=(_); end + def inspect; end + def node_type; end + def target; end + def target=(_); end + def write(writer, indent = _, transitive = _, ie_hack = _); end +end + +class REXML::NotationDecl < ::REXML::Child + def initialize(name, middle, pub, sys); end + + def name; end + def public; end + def public=(_); end + def system; end + def system=(_); end + def to_s; end + def write(output, indent = _); end +end + +class REXML::Output + include(::REXML::Encoding) + + def initialize(real_IO, encd = _); end + + def <<(content); end + def encoding; end + def to_s; end +end + +class REXML::Parent < ::REXML::Child + include(::Enumerable) + + def initialize(parent = _); end + + def <<(object); end + def [](index); end + def []=(*args); end + def add(object); end + def children; end + def deep_clone; end + def delete(object); end + def delete_at(index); end + def delete_if(&block); end + def each(&block); end + def each_child(&block); end + def each_index(&block); end + def index(child); end + def insert_after(child1, child2); end + def insert_before(child1, child2); end + def length; end + def parent?; end + def push(object); end + def replace_child(to_replace, replacement); end + def size; end + def to_a; end + def unshift(object); end +end + +class REXML::ParseException < ::RuntimeError + def initialize(message, source = _, parser = _, exception = _); end + + def context; end + def continued_exception; end + def continued_exception=(_); end + def line; end + def parser; end + def parser=(_); end + def position; end + def source; end + def source=(_); end + def to_s; end +end + +class REXML::Parsers::BaseParser + def initialize(source); end + + def add_listener(listener); end + def empty?; end + def entity(reference, entities); end + def has_next?; end + def normalize(input, entities = _, entity_filter = _); end + def peek(depth = _); end + def position; end + def pull; end + def source; end + def stream=(source); end + def unnormalize(string, entities = _, filter = _); end + def unshift(token); end + + private + + def need_source_encoding_update?(xml_declaration_encoding); end + def parse_attributes(prefixes, curr_ns); end + def process_instruction; end + def pull_event; end +end + +REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp) + +REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String) + +class REXML::Parsers::StreamParser + def initialize(source, listener); end + + def add_listener(listener); end + def parse; end +end + +class REXML::Parsers::TreeParser + def initialize(source, build_context = _); end + + def add_listener(listener); end + def parse; end +end + +class REXML::Parsers::XPathParser + include(::REXML::XMLTokens) + + def abbreviate(path); end + def expand(path); end + def namespaces=(namespaces); end + def parse(path); end + def predicate(path); end + def predicate_to_string(path, &block); end + + private + + def AdditiveExpr(path, parsed); end + def AndExpr(path, parsed); end + def EqualityExpr(path, parsed); end + def FilterExpr(path, parsed); end + def FunctionCall(rest, parsed); end + def LocationPath(path, parsed); end + def MultiplicativeExpr(path, parsed); end + def NodeTest(path, parsed); end + def OrExpr(path, parsed); end + def PathExpr(path, parsed); end + def Predicate(path, parsed); end + def PrimaryExpr(path, parsed); end + def RelationalExpr(path, parsed); end + def RelativeLocationPath(path, parsed); end + def UnaryExpr(path, parsed); end + def UnionExpr(path, parsed); end + def get_group(string); end + def parse_args(string); end +end + +REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp) + +REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp) + +class REXML::Source + include(::REXML::Encoding) + + def initialize(arg, encoding = _); end + + def buffer; end + def consume(pattern); end + def current_line; end + def empty?; end + def encoding; end + def encoding=(enc); end + def line; end + def match(pattern, cons = _); end + def match_to(char, pattern); end + def match_to_consume(char, pattern); end + def position; end + def read; end + def scan(pattern, cons = _); end + + private + + def detect_encoding; end + def encoding_updated; end +end + +class REXML::Text < ::REXML::Child + include(::Comparable) + + def initialize(arg, respect_whitespace = _, parent = _, raw = _, entity_filter = _, illegal = _); end + + def <<(to_append); end + def <=>(other); end + def clone; end + def doctype; end + def empty?; end + def indent_text(string, level = _, style = _, indentfirstline = _); end + def inspect; end + def node_type; end + def parent=(parent); end + def raw; end + def raw=(_); end + def to_s; end + def value; end + def value=(val); end + def wrap(string, width, addnewline = _); end + def write(writer, indent = _, transitive = _, ie_hack = _); end + def write_with_substitution(out, input); end + def xpath; end + + private + + def clear_cache; end + + def self.check(string, pattern, doctype); end + def self.expand(ref, doctype, filter); end + def self.normalize(input, doctype = _, entity_filter = _); end + def self.read_with_substitution(input, illegal = _); end + def self.unnormalize(string, doctype = _, filter = _, illegal = _); end +end + +class REXML::XMLDecl < ::REXML::Child + include(::REXML::Encoding) + + def initialize(version = _, encoding = _, standalone = _); end + + def ==(other); end + def clone; end + def dowrite; end + def encoding=(enc); end + def inspect; end + def node_type; end + def nowrite; end + def old_enc=(encoding); end + def stand_alone?; end + def standalone; end + def standalone=(_); end + def version; end + def version=(_); end + def write(writer, indent = _, transitive = _, ie_hack = _); end + def writeencoding; end + def writethis; end + def xmldecl(version, encoding, standalone); end + + private + + def content(enc); end + + def self.default; end +end + +class REXML::XPathNode + def initialize(node, context = _); end + + def context; end + def position; end + def raw_node; end +end + +class REXML::XPathParser + include(::REXML::XMLTokens) + + def initialize(strict: _); end + + def []=(variable_name, value); end + def first(path_stack, node); end + def get_first(path, nodeset); end + def match(path_stack, nodeset); end + def namespaces=(namespaces = _); end + def parse(path, nodeset); end + def predicate(path, nodeset); end + def variables=(vars = _); end + + private + + def child(nodeset); end + def compare(a, operator, b); end + def descendant(nodeset, include_self); end + def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end + def each_unnode(nodeset); end + def enter(tag, *args); end + def equality_relational_compare(set1, op, set2); end + def evaluate_predicate(expression, nodesets); end + def expr(path_stack, nodeset, context = _); end + def filter_nodeset(nodeset); end + def following(node); end + def following_node_of(node); end + def get_namespace(node, prefix); end + def leave(tag, *args); end + def next_sibling_node(node); end + def node_test(path_stack, nodesets, any_type: _); end + def norm(b); end + def normalize_compare_values(a, operator, b); end + def preceding(node); end + def preceding_node_of(node); end + def sort(array_of_nodes, order); end + def step(path_stack, any_type: _, order: _); end + def strict?; end + def trace(*args); end + def unnode(nodeset); end + def value_type(value); end +end + +class Symbol + include(::Comparable) + + def dclone; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi new file mode 100644 index 0000000000..a511fdb79d --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.9.2.rbi @@ -0,0 +1,2347 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RSpec + extend(::RSpec::Support::Warnings) + extend(::RSpec::Core::Warnings) + + def self.clear_examples; end + def self.configuration; end + def self.configuration=(_); end + def self.configure; end + def self.const_missing(name); end + def self.context(*args, &example_group_block); end + def self.current_example; end + def self.current_example=(example); end + def self.describe(*args, &example_group_block); end + def self.example_group(*args, &example_group_block); end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.reset; end + def self.shared_context(name, *args, &block); end + def self.shared_examples(name, *args, &block); end + def self.shared_examples_for(name, *args, &block); end + def self.world; end + def self.world=(_); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end +end + +module RSpec::Core + def self.path_to_executable; end +end + +class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup + def self.metadata; end +end + +class RSpec::Core::BacktraceFormatter + def initialize; end + + def backtrace_line(line); end + def exclude?(line); end + def exclusion_patterns; end + def exclusion_patterns=(_); end + def filter_gem(gem_name); end + def format_backtrace(backtrace, options = _); end + def full_backtrace=(_); end + def full_backtrace?; end + def inclusion_patterns; end + def inclusion_patterns=(_); end + + private + + def matches?(patterns, line); end +end + +class RSpec::Core::Configuration + include(::RSpec::Core::Hooks) + include(::RSpec::Core::Configuration::Readers) + + def initialize; end + + def add_formatter(formatter, output = _); end + def add_setting(name, opts = _); end + def after(scope = _, *meta, &block); end + def alias_example_group_to(new_name, *args); end + def alias_example_to(name, *args); end + def alias_it_behaves_like_to(new_name, report_label = _); end + def alias_it_should_behave_like_to(new_name, report_label = _); end + def append_after(scope = _, *meta, &block); end + def append_before(scope = _, *meta, &block); end + def apply_derived_metadata_to(metadata); end + def around(scope = _, *meta, &block); end + def backtrace_exclusion_patterns; end + def backtrace_exclusion_patterns=(patterns); end + def backtrace_formatter; end + def backtrace_inclusion_patterns; end + def backtrace_inclusion_patterns=(patterns); end + def before(scope = _, *meta, &block); end + def bisect_runner; end + def bisect_runner=(value); end + def bisect_runner_class; end + def color; end + def color=(_); end + def color_enabled?(output = _); end + def color_mode; end + def color_mode=(_); end + def configure_example(example, example_hooks); end + def configure_expectation_framework; end + def configure_group(group); end + def configure_mock_framework; end + def default_color; end + def default_color=(_); end + def default_color?; end + def default_formatter; end + def default_formatter=(value); end + def default_path; end + def default_path=(path); end + def default_path?; end + def define_derived_metadata(*filters, &block); end + def deprecation_stream; end + def deprecation_stream=(value); end + def detail_color; end + def detail_color=(_); end + def detail_color?; end + def disable_monkey_patching; end + def disable_monkey_patching!; end + def disable_monkey_patching=(_); end + def drb; end + def drb=(_); end + def drb?; end + def drb_port; end + def drb_port=(_); end + def drb_port?; end + def dry_run; end + def dry_run=(_); end + def dry_run?; end + def error_stream; end + def error_stream=(_); end + def error_stream?; end + def example_status_persistence_file_path; end + def example_status_persistence_file_path=(value); end + def exclude_pattern; end + def exclude_pattern=(value); end + def exclusion_filter; end + def exclusion_filter=(filter); end + def expect_with(*frameworks); end + def expectation_framework=(framework); end + def expectation_frameworks; end + def expose_current_running_example_as(method_name); end + def expose_dsl_globally=(value); end + def expose_dsl_globally?; end + def extend(mod, *filters); end + def fail_fast; end + def fail_fast=(value); end + def fail_if_no_examples; end + def fail_if_no_examples=(_); end + def fail_if_no_examples?; end + def failure_color; end + def failure_color=(_); end + def failure_color?; end + def failure_exit_code; end + def failure_exit_code=(_); end + def failure_exit_code?; end + def files_or_directories_to_run=(*files); end + def files_to_run; end + def files_to_run=(_); end + def filter; end + def filter=(filter); end + def filter_gems_from_backtrace(*gem_names); end + def filter_manager; end + def filter_manager=(_); end + def filter_run(*args); end + def filter_run_excluding(*args); end + def filter_run_including(*args); end + def filter_run_when_matching(*args); end + def fixed_color; end + def fixed_color=(_); end + def fixed_color?; end + def force(hash); end + def format_docstrings(&block); end + def format_docstrings_block; end + def formatter=(formatter, output = _); end + def formatter_loader; end + def formatters; end + def full_backtrace=(true_or_false); end + def full_backtrace?; end + def full_description; end + def full_description=(description); end + def hooks; end + def in_project_source_dir_regex; end + def include(mod, *filters); end + def include_context(shared_group_name, *filters); end + def inclusion_filter; end + def inclusion_filter=(filter); end + def last_run_statuses; end + def libs; end + def libs=(libs); end + def load_spec_files; end + def loaded_spec_files; end + def max_displayed_failure_line_count; end + def max_displayed_failure_line_count=(_); end + def max_displayed_failure_line_count?; end + def mock_framework; end + def mock_framework=(framework); end + def mock_with(framework); end + def on_example_group_definition(&block); end + def on_example_group_definition_callbacks; end + def only_failures; end + def only_failures?; end + def only_failures_but_not_configured?; end + def order=(*args, &block); end + def ordering_manager; end + def ordering_registry(*args, &block); end + def output_stream; end + def output_stream=(value); end + def pattern; end + def pattern=(value); end + def pending_color; end + def pending_color=(_); end + def pending_color?; end + def prepend(mod, *filters); end + def prepend_after(scope = _, *meta, &block); end + def prepend_before(scope = _, *meta, &block); end + def profile_examples; end + def profile_examples=(_); end + def profile_examples?; end + def project_source_dirs; end + def project_source_dirs=(_); end + def project_source_dirs?; end + def raise_errors_for_deprecations!; end + def raise_on_warning=(value); end + def register_ordering(*args, &block); end + def reporter; end + def requires; end + def requires=(paths); end + def reset; end + def reset_filters; end + def reset_reporter; end + def run_all_when_everything_filtered; end + def run_all_when_everything_filtered=(_); end + def run_all_when_everything_filtered?; end + def seed(*args, &block); end + def seed=(*args, &block); end + def seed_used?(*args, &block); end + def shared_context_metadata_behavior; end + def shared_context_metadata_behavior=(value); end + def silence_filter_announcements; end + def silence_filter_announcements=(_); end + def silence_filter_announcements?; end + def spec_files_with_failures; end + def start_time; end + def start_time=(_); end + def start_time?; end + def static_config_filter_manager; end + def static_config_filter_manager=(_); end + def success_color; end + def success_color=(_); end + def success_color?; end + def threadsafe; end + def threadsafe=(_); end + def threadsafe?; end + def treat_symbols_as_metadata_keys_with_true_values=(_value); end + def tty; end + def tty=(_); end + def tty?; end + def warnings=(value); end + def warnings?; end + def when_first_matching_example_defined(*filters); end + def with_suite_hooks; end + def world; end + def world=(_); end + + private + + def absolute_pattern?(pattern); end + def add_hook_to_existing_matching_groups(meta, scope, &block); end + def assert_no_example_groups_defined(config_option); end + def clear_values_derived_from_example_status_persistence_file_path; end + def command; end + def conditionally_disable_expectations_monkey_patching; end + def conditionally_disable_mocks_monkey_patching; end + def configure_group_with(group, module_list, application_method); end + def define_built_in_hooks; end + def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end + def extract_location(path); end + def file_glob_from(path, pattern); end + def gather_directories(path); end + def get_files_to_run(paths); end + def get_matching_files(path, pattern); end + def handle_suite_hook(scope, meta); end + def load_file_handling_errors(method, file); end + def metadata_applies_to_group?(meta, group); end + def on_existing_matching_groups(meta); end + def output_to_tty?(output = _); end + def output_wrapper; end + def paths_to_check(paths); end + def pattern_might_load_specs_from_vendored_dirs?; end + def rspec_expectations_loaded?; end + def rspec_mocks_loaded?; end + def run_suite_hooks(hook_description, hooks); end + def safe_extend(mod, host); end + def safe_include(mod, host); end + def safe_prepend(mod, host); end + def update_pattern_attr(name, value); end + def value_for(key); end + + def self.add_read_only_setting(name, opts = _); end + def self.add_setting(name, opts = _); end + def self.define_aliases(name, alias_name); end + def self.define_predicate_for(*names); end + def self.define_reader(name); end + def self.delegate_to_ordering_manager(*methods); end +end + +RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc) + +class RSpec::Core::Configuration::DeprecationReporterBuffer + def initialize; end + + def deprecation(*args); end + def play_onto(reporter); end +end + +module RSpec::Core::Configuration::ExposeCurrentExample +end + +RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String) + +RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash) + +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError +end + +RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String) + +RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String) + +RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc) + +module RSpec::Core::Configuration::Readers + def default_color; end + def default_path; end + def deprecation_stream; end + def detail_color; end + def drb; end + def drb_port; end + def dry_run; end + def error_stream; end + def example_status_persistence_file_path; end + def exclude_pattern; end + def fail_fast; end + def fail_if_no_examples; end + def failure_color; end + def failure_exit_code; end + def fixed_color; end + def libs; end + def max_displayed_failure_line_count; end + def only_failures; end + def output_stream; end + def pattern; end + def pending_color; end + def profile_examples; end + def project_source_dirs; end + def requires; end + def run_all_when_everything_filtered; end + def shared_context_metadata_behavior; end + def silence_filter_announcements; end + def start_time; end + def success_color; end + def threadsafe; end + def tty; end +end + +RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String) + +RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array) + +class RSpec::Core::ConfigurationOptions + def initialize(args); end + + def args; end + def configure(config); end + def configure_filter_manager(filter_manager); end + def options; end + + private + + def args_from_options_file(path); end + def command_line_options; end + def custom_options; end + def custom_options_file; end + def env_options; end + def file_options; end + def force?(key); end + def global_options; end + def global_options_file; end + def home_options_file_path; end + def load_formatters_into(config); end + def local_options; end + def local_options_file; end + def options_file_as_erb_string(path); end + def options_from(path); end + def order(keys); end + def organize_options; end + def parse_args_ignoring_files_or_dirs_to_run(args, source); end + def process_options_into(config); end + def project_options; end + def project_options_file; end + def resolve_xdg_config_home; end + def xdg_options_file_if_exists; end + def xdg_options_file_path; end +end + +RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array) + +RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +module RSpec::Core::DSL + def self.change_global_dsl(&changes); end + def self.example_group_aliases; end + def self.expose_example_group_alias(name); end + def self.expose_example_group_alias_globally(method_name); end + def self.expose_globally!; end + def self.exposed_globally?; end + def self.remove_globally!; end + def self.top_level; end + def self.top_level=(_); end +end + +class RSpec::Core::DeprecationError < ::StandardError +end + +class RSpec::Core::DidYouMean + def initialize(relative_file_name); end + + def call; end + def relative_file_name; end + + private + + def formats(probables); end + def red_font(mytext); end + def top_and_tail(rspec_format); end +end + +class RSpec::Core::Example + def initialize(example_group_class, description, user_metadata, example_block = _); end + + def clock; end + def clock=(_); end + def description; end + def display_exception; end + def display_exception=(ex); end + def duplicate_with(metadata_overrides = _); end + def example_group; end + def example_group_instance; end + def exception; end + def execution_result; end + def fail_with_exception(reporter, exception); end + def file_path; end + def full_description; end + def id; end + def inspect; end + def inspect_output; end + def instance_exec(*args, &block); end + def location; end + def location_rerun_argument; end + def metadata; end + def pending; end + def pending?; end + def reporter; end + def rerun_argument; end + def run(example_group_instance, reporter); end + def set_aggregate_failures_exception(exception); end + def set_exception(exception); end + def skip; end + def skip_with_exception(reporter, exception); end + def skipped?; end + def to_s; end + def update_inherited_metadata(updates); end + + private + + def assign_generated_description; end + def finish(reporter); end + def generate_description; end + def hooks; end + def location_description; end + def mocks_need_verification?; end + def record_finished(status, reporter); end + def run_after_example; end + def run_before_example; end + def start(reporter); end + def verify_mocks; end + def with_around_and_singleton_context_hooks; end + def with_around_example_hooks; end + + def self.delegate_to_metadata(key); end + def self.parse_id(id); end +end + +RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + +class RSpec::Core::Example::ExecutionResult + include(::RSpec::Core::HashImitatable) + extend(::RSpec::Core::HashImitatable::ClassMethods) + + def ensure_timing_set(clock); end + def example_skipped?; end + def exception; end + def exception=(_); end + def finished_at; end + def finished_at=(_); end + def pending_exception; end + def pending_exception=(_); end + def pending_fixed; end + def pending_fixed=(_); end + def pending_fixed?; end + def pending_message; end + def pending_message=(_); end + def record_finished(status, finished_at); end + def run_time; end + def run_time=(_); end + def started_at; end + def started_at=(_); end + def status; end + def status=(_); end + + private + + def calculate_run_time(finished_at); end + def get_value(name); end + def hash_for_delegation; end + def issue_deprecation(_method_name, *_args); end + def set_value(name, value); end +end + +class RSpec::Core::Example::Procsy + def initialize(example, &block); end + + def <<(*a, &b); end + def ===(*a, &b); end + def >>(*a, &b); end + def [](*a, &b); end + def arity(*a, &b); end + def binding(*a, &b); end + def call(*args, &block); end + def clock(*a, &b); end + def clock=(*a, &b); end + def clone(*a, &b); end + def curry(*a, &b); end + def description(*a, &b); end + def dup(*a, &b); end + def duplicate_with(*a, &b); end + def example; end + def example_group(*a, &b); end + def example_group_instance(*a, &b); end + def exception(*a, &b); end + def executed?; end + def execution_result(*a, &b); end + def file_path(*a, &b); end + def full_description(*a, &b); end + def hash(*a, &b); end + def id(*a, &b); end + def inspect; end + def inspect_output(*a, &b); end + def lambda?(*a, &b); end + def location(*a, &b); end + def location_rerun_argument(*a, &b); end + def metadata(*a, &b); end + def parameters(*a, &b); end + def pending(*a, &b); end + def pending?(*a, &b); end + def reporter(*a, &b); end + def rerun_argument(*a, &b); end + def run(*args, &block); end + def skip(*a, &b); end + def skipped?(*a, &b); end + def source_location(*a, &b); end + def to_proc; end + def update_inherited_metadata(*a, &b); end + def wrap(&block); end + def yield(*a, &b); end +end + +class RSpec::Core::ExampleGroup + include(::RSpec::Core::MemoizedHelpers) + include(::RSpec::Core::Pending) + extend(::RSpec::Core::Hooks) + extend(::RSpec::Core::MemoizedHelpers::ClassMethods) + extend(::RSpec::Core::SharedExampleGroup) + + def initialize(inspect_output = _); end + + def described_class; end + def inspect; end + + private + + def method_missing(name, *args); end + + def self.add_example(example); end + def self.before_context_ivars; end + def self.children; end + def self.context(*args, &example_group_block); end + def self.currently_executing_a_context_hook?; end + def self.declaration_locations; end + def self.define_example_group_method(name, metadata = _); end + def self.define_example_method(name, extra_options = _); end + def self.define_nested_shared_group_method(new_name, report_label = _); end + def self.delegate_to_metadata(*names); end + def self.descendant_filtered_examples; end + def self.descendants; end + def self.describe(*args, &example_group_block); end + def self.described_class; end + def self.description; end + def self.each_instance_variable_for_example(group); end + def self.ensure_example_groups_are_configured; end + def self.example(*all_args, &block); end + def self.example_group(*args, &example_group_block); end + def self.examples; end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.fexample(*all_args, &block); end + def self.file_path; end + def self.filtered_examples; end + def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end + def self.fit(*all_args, &block); end + def self.focus(*all_args, &block); end + def self.for_filtered_examples(reporter, &block); end + def self.fspecify(*all_args, &block); end + def self.id; end + def self.idempotently_define_singleton_method(name, &definition); end + def self.include_context(name, *args, &block); end + def self.include_examples(name, *args, &block); end + def self.it(*all_args, &block); end + def self.it_behaves_like(name, *args, &customization_block); end + def self.it_should_behave_like(name, *args, &customization_block); end + def self.location; end + def self.metadata; end + def self.next_runnable_index_for(file); end + def self.ordering_strategy; end + def self.parent_groups; end + def self.pending(*all_args, &block); end + def self.remove_example(example); end + def self.reset_memoized; end + def self.run(reporter = _); end + def self.run_after_context_hooks(example_group_instance); end + def self.run_before_context_hooks(example_group_instance); end + def self.run_examples(reporter); end + def self.set_it_up(description, args, registration_collection, &example_group_block); end + def self.set_ivars(instance, ivars); end + def self.skip(*all_args, &block); end + def self.specify(*all_args, &block); end + def self.store_before_context_ivars(example_group_instance); end + def self.subclass(parent, description, args, registration_collection, &example_group_block); end + def self.superclass_before_context_ivars; end + def self.superclass_metadata; end + def self.top_level?; end + def self.top_level_description; end + def self.traverse_tree_until(&block); end + def self.update_inherited_metadata(updates); end + def self.with_replaced_metadata(meta); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end + def self.xexample(*all_args, &block); end + def self.xit(*all_args, &block); end + def self.xspecify(*all_args, &block); end +end + +RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol) + +class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError +end + +class RSpec::Core::ExampleStatusPersister + def initialize(examples, file_name); end + + def persist; end + + private + + def dump_statuses(unparsed_previous_runs); end + def statuses_from_this_run; end + + def self.load_from(file_name); end + def self.persist(examples, file_name); end +end + +RSpec::Core::ExclusionRules = RSpec::Core::FilterRules + +class RSpec::Core::FilterManager + def initialize; end + + def add_ids(rerun_path, scoped_ids); end + def add_location(file_path, line_numbers); end + def empty?; end + def exclude(*args); end + def exclude_only(*args); end + def exclude_with_low_priority(*args); end + def exclusions; end + def include(*args); end + def include_only(*args); end + def include_with_low_priority(*args); end + def inclusions; end + def prune(examples); end + + private + + def add_path_to_arrays_filter(filter_key, path, values); end + def file_scoped_include?(ex_metadata, ids, locations); end + def prune_conditionally_filtered_examples(examples); end +end + +class RSpec::Core::FilterRules + def initialize(rules = _); end + + def [](key); end + def add(updated); end + def add_with_low_priority(updated); end + def clear; end + def delete(key); end + def description; end + def each_pair(&block); end + def empty?; end + def fetch(*args, &block); end + def include_example?(example); end + def opposite; end + def opposite=(_); end + def rules; end + def use_only(updated); end + + def self.build; end +end + +RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp) + +RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String) + +module RSpec::Core::FilterableItemRepository +end + +class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized + def initialize(applies_predicate); end + + def append(item, metadata); end + def delete(item, metadata); end + def items_for(metadata); end + def prepend(item, metadata); end + + private + + def applicable_metadata_from(metadata); end + def find_items_for(request_meta); end + def handle_mutation(metadata); end + def proc_keys_from(metadata); end + def reconstruct_caches; end +end + +class RSpec::Core::FilterableItemRepository::UpdateOptimized + def initialize(applies_predicate); end + + def append(item, metadata); end + def delete(item, metadata); end + def items_and_filters; end + def items_for(request_meta); end + def prepend(item, metadata); end +end + +module RSpec::Core::FlatMap + + private + + def flat_map(array, &block); end + + def self.flat_map(array, &block); end +end + +module RSpec::Core::Formatters + def self.register(formatter_class, *notifications); end +end + +class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter + def initialize(_output); end + + def notify_results(results); end +end + +module RSpec::Core::Formatters::ConsoleCodes + + private + + def config_colors_to_methods; end + def console_code_for(code_or_symbol); end + def wrap(text, code_or_symbol); end + + def self.config_colors_to_methods; end + def self.console_code_for(code_or_symbol); end + def self.wrap(text, code_or_symbol); end +end + +RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash) + +RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash) + +class RSpec::Core::Formatters::DeprecationFormatter + def initialize(deprecation_stream, summary_stream); end + + def count; end + def deprecation(notification); end + def deprecation_message_for(data); end + def deprecation_stream; end + def deprecation_summary(_notification); end + def output; end + def printer; end + def summary_stream; end +end + +RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String) + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def deprecation_formatter; end + def deprecation_stream; end + def deprecation_summary; end + def print_deferred_deprecation_warnings; end + def print_deprecation_message(data); end + def stash_deprecation_message(deprecation_message); end + def summary_stream; end +end + +RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer) + +class RSpec::Core::Formatters::DeprecationFormatter::FileStream + def initialize(file); end + + def puts(*args); end + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct + def initialize(data); end + + def to_s; end + def too_many_warnings_message; end + def type; end + def type=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def deprecation_formatter; end + def deprecation_stream; end + def deprecation_summary; end + def print_deprecation_message(data); end + def summary_stream; end +end + +RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String) + +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream + def puts(message); end + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct + def initialize(data); end + + def to_s; end + def too_many_warnings_message; end + def type; end + def type=(_); end + + private + + def deprecation_type_for(data); end + def output_formatted(str); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String) + +class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter + def initialize(output); end + + def example_failed(failure); end + def example_group_finished(_notification); end + def example_group_started(notification); end + def example_passed(passed); end + def example_pending(pending); end + def example_started(_notification); end + def message(notification); end + + private + + def current_indentation(offset = _); end + def failure_output(example); end + def flush_messages; end + def next_failure_index; end + def passed_output(example); end + def pending_output(example, message); end +end + +class RSpec::Core::Formatters::ExceptionPresenter + def initialize(exception, example, options = _); end + + def colorized_formatted_backtrace(colorizer = _); end + def colorized_message_lines(colorizer = _); end + def description; end + def example; end + def exception; end + def formatted_backtrace(exception = _); end + def formatted_cause(exception); end + def fully_formatted(failure_number, colorizer = _); end + def fully_formatted_lines(failure_number, colorizer); end + def message_lines; end + + private + + def add_shared_group_lines(lines, colorizer); end + def backtrace_formatter; end + def detail_formatter; end + def encoded_description(description); end + def encoded_string(string); end + def encoding_of(string); end + def exception_backtrace; end + def exception_class_name(exception = _); end + def exception_lines; end + def extra_detail_formatter; end + def extra_failure_lines; end + def failure_lines; end + def failure_slash_error_lines; end + def final_exception(exception, previous = _); end + def find_failed_line; end + def formatted_message_and_backtrace(colorizer); end + def indent_lines(lines, failure_number); end + def message_color; end + def read_failed_lines; end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory + def initialize(example); end + + def build; end + + private + + def multiple_exception_summarizer(exception, prior_detail_formatter, color); end + def multiple_exceptions_error?(exception); end + def options; end + def pending_options; end + def sub_failure_list_formatter(exception, message_color); end + def with_multiple_error_options_as_needed(exception, options); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater + def initialize(parent); end + + def with_truncated_backtrace(child); end +end + +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter + def self.format_backtrace(*_); end +end + +RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc) + +class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter + def dump_profile(_profile); end + def example_failed(failure); end + def message(_message); end +end + +class RSpec::Core::Formatters::FallbackMessageFormatter + def initialize(output); end + + def message(notification); end + def output; end +end + +module RSpec::Core::Formatters::Helpers + def self.format_duration(duration); end + def self.format_seconds(float, precision = _); end + def self.organize_ids(ids); end + def self.pluralize(count, string); end +end + +RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer) + +RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer) + +class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter + def initialize(output); end + + def dump_summary(summary); end + def example_failed(failure); end + def example_group_started(notification); end + def example_passed(passed); end + def example_pending(pending); end + def example_started(_notification); end + def start(notification); end + def start_dump(_notification); end + + private + + def example_group_number; end + def example_number; end + def extra_failure_content(failure); end + def percent_done; end +end + +class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter + def initialize(output); end + + def close(_notification); end + def dump_profile(profile); end + def dump_profile_slowest_example_groups(profile); end + def dump_profile_slowest_examples(profile); end + def dump_summary(summary); end + def message(notification); end + def output_hash; end + def seed(notification); end + def stop(notification); end + + private + + def format_example(example); end +end + +class RSpec::Core::Formatters::Loader + def initialize(reporter); end + + def add(formatter_to_use, *paths); end + def default_formatter; end + def default_formatter=(_); end + def formatters; end + def prepare_default(output_stream, deprecation_stream); end + def reporter; end + def setup_default(output_stream, deprecation_stream); end + + private + + def built_in_formatter(key); end + def custom_formatter(formatter_ref); end + def duplicate_formatter_exists?(new_formatter); end + def existing_formatter_implements?(notification); end + def find_formatter(formatter_to_use); end + def notifications_for(formatter_class); end + def open_stream(path_or_wrapper); end + def path_for(const_ref); end + def register(formatter, notifications); end + def string_const?(str); end + def underscore(camel_cased_word); end + def underscore_with_fix_for_non_standard_rspec_naming(string); end + + def self.formatters; end +end + +class RSpec::Core::Formatters::ProfileFormatter + def initialize(output); end + + def dump_profile(profile); end + def output; end + + private + + def bold(text); end + def dump_profile_slowest_example_groups(profile); end + def dump_profile_slowest_examples(profile); end + def format_caller(caller_info); end +end + +class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter + def example_failed(_notification); end + def example_passed(_notification); end + def example_pending(_notification); end + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::SnippetExtractor + def initialize(source, beginning_line_number, max_line_count = _); end + + def beginning_line_number; end + def expression_lines; end + def max_line_count; end + def source; end + + private + + def expression_node; end + def expression_outmost_node?(node); end + def line_range_of_expression; end + def line_range_of_location_nodes_in_expression; end + def location_nodes_at_beginning_line; end + def unclosed_tokens_in_line_range(line_range); end + + def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count = _); end + def self.extract_line_at(file_path, line_number); end + def self.least_indentation_from(lines); end + def self.source_from_file(path); end +end + +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError +end + +class RSpec::Core::Formatters::SyntaxHighlighter + def initialize(configuration); end + + def highlight(lines); end + + private + + def color_enabled_implementation; end + def implementation; end + + def self.attempt_to_add_rspec_terms_to_coderay_keywords; end +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + def self.highlight_syntax(lines); end +end + +RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String) + +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + def self.highlight_syntax(lines); end +end + +RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + +module RSpec::Core::HashImitatable + mixes_in_class_methods(::RSpec::Core::HashImitatable::ClassMethods) + + def <(*args, &block); end + def <=(*args, &block); end + def >(*args, &block); end + def >=(*args, &block); end + def [](key); end + def []=(key, value); end + def all?(*args, &block); end + def any?(*args, &block); end + def assoc(*args, &block); end + def chain(*args, &block); end + def chunk(*args, &block); end + def chunk_while(*args, &block); end + def clear(*args, &block); end + def collect(*args, &block); end + def collect_concat(*args, &block); end + def compact(*args, &block); end + def compact!(*args, &block); end + def compare_by_identity(*args, &block); end + def compare_by_identity?(*args, &block); end + def count(*args, &block); end + def cycle(*args, &block); end + def default(*args, &block); end + def default=(*args, &block); end + def default_proc(*args, &block); end + def default_proc=(*args, &block); end + def delete(*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_key(*args, &block); end + def each_pair(*args, &block); end + def each_slice(*args, &block); end + def each_value(*args, &block); end + def each_with_index(*args, &block); end + def each_with_object(*args, &block); end + def empty?(*args, &block); end + def entries(*args, &block); end + def fetch(*args, &block); end + def fetch_values(*args, &block); end + def filter(*args, &block); end + def filter!(*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 grep(*args, &block); end + def grep_v(*args, &block); end + def group_by(*args, &block); end + def has_key?(*args, &block); end + def has_value?(*args, &block); end + def include?(*args, &block); end + def index(*args, &block); end + def inject(*args, &block); end + def invert(*args, &block); end + def keep_if(*args, &block); end + def key(*args, &block); end + def key?(*args, &block); end + def keys(*args, &block); end + def lazy(*args, &block); end + def length(*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 merge(*args, &block); end + def merge!(*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 partition(*args, &block); end + def rassoc(*args, &block); end + def reduce(*args, &block); end + def rehash(*args, &block); end + def reject(*args, &block); end + def reject!(*args, &block); end + def replace(*args, &block); end + def reverse_each(*args, &block); end + def select(*args, &block); end + def select!(*args, &block); end + def shift(*args, &block); end + def size(*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_by(*args, &block); end + def store(*args, &block); end + def sum(*args, &block); end + def take(*args, &block); end + def take_while(*args, &block); end + def to_a(*args, &block); end + def to_h; end + def to_hash(*args, &block); end + def to_proc(*args, &block); end + def to_set(*args, &block); end + def transform_keys(*args, &block); end + def transform_keys!(*args, &block); end + def transform_values(*args, &block); end + def transform_values!(*args, &block); end + def uniq(*args, &block); end + def update(*args, &block); end + def value?(*args, &block); end + def values(*args, &block); end + def values_at(*args, &block); end + def zip(*args, &block); end + + private + + def directly_supports_attribute?(name); end + def extra_hash_attributes; end + def get_value(name); end + def hash_for_delegation; end + def issue_deprecation(_method_name, *_args); end + def set_value(name, value); end + + def self.included(klass); end +end + +module RSpec::Core::HashImitatable::ClassMethods + def attr_accessor(*names); end + def hash_attribute_names; end +end + +module RSpec::Core::Hooks + def after(*args, &block); end + def append_after(*args, &block); end + def append_before(*args, &block); end + def around(*args, &block); end + def before(*args, &block); end + def hooks; end + def prepend_after(*args, &block); end + def prepend_before(*args, &block); end +end + +class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook + def run(example); end +end + +class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook + def run(example); end +end + +class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook + def execute_with(example, procsy); end + def hook_description; end +end + +class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook + def run(example); end +end + +class RSpec::Core::Hooks::Hook < ::Struct + def block; end + def block=(_); end + def options; end + def options=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Hooks::HookCollections + def initialize(owner, filterable_item_repo_class); end + + def register(prepend_or_append, position, *args, &block); end + def register_global_singleton_context_hooks(example, globals); end + def register_globals(host, globals); end + def run(position, scope, example_or_group); end + + protected + + def all_hooks_for(position, scope); end + def matching_hooks_for(position, scope, example_or_group); end + def processable_hooks_for(position, scope, host); end + def run_owned_hooks_for(position, scope, example_or_group); end + + private + + def ensure_hooks_initialized_for(position, scope); end + def extract_scope_from(args); end + def hooks_for(position, scope); end + def known_scope?(scope); end + def normalized_scope_for(scope); end + def owner_parent_groups; end + def process(host, parent_groups, globals, position, scope); end + def run_around_example_hooks_for(example); end + def run_example_hooks_for(example, position, each_method); end + def scope_and_options_from(*args); end +end + +RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array) + +RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash) + +RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array) + +RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash) + +class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules + def add(*args); end + def add_with_low_priority(*args); end + def include_example?(example); end + def split_file_scoped_rules; end + def standalone?; end + + private + + def apply_standalone_filter(updated); end + def is_standalone_filter?(rules); end + def replace_filters(new_rules); end +end + +module RSpec::Core::Invocations +end + +class RSpec::Core::Invocations::Bisect + def call(options, err, out); end + + private + + def bisect_formatter_klass_for(argument); end +end + +class RSpec::Core::Invocations::DRbWithFallback + def call(options, err, out); end +end + +class RSpec::Core::Invocations::InitializeProject + def call(*_args); end +end + +class RSpec::Core::Invocations::PrintHelp < ::Struct + def call(_options, _err, out); end + def hidden_options; end + def hidden_options=(_); end + def parser; end + def parser=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Invocations::PrintVersion + def call(_options, _err, out); end +end + +class RSpec::Core::LegacyExampleGroupHash + include(::RSpec::Core::HashImitatable) + extend(::RSpec::Core::HashImitatable::ClassMethods) + + def initialize(metadata); end + + def to_h; end + + private + + def directly_supports_attribute?(name); end + def get_value(name); end + def set_value(name, value); end +end + +module RSpec::Core::MemoizedHelpers + def initialize(*_); end + + def is_expected; end + def should(matcher = _, message = _); end + def should_not(matcher = _, message = _); end + def subject; end + + private + + def __init_memoized; end + def __memoized; end + + def self.define_helpers_on(example_group); end + def self.get_constant_or_yield(example_group, name); end + def self.module_for(example_group); end +end + +module RSpec::Core::MemoizedHelpers::ClassMethods + def let(name, &block); end + def let!(name, &block); end + def subject(name = _, &block); end + def subject!(name = _, &block); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.fetch_or_store(key, &_block); end + def self.isolate_for_context_hook(example_group_instance); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.article; end + def self.hook_expression; end + def self.hook_intention; end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.article; end + def self.hook_expression; end + def self.hook_intention; end +end + +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized + def initialize; end + + def fetch_or_store(key); end +end + +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized + def initialize; end + + def fetch_or_store(key); end +end + +module RSpec::Core::Metadata + def self.ascend(metadata); end + def self.ascending(metadata); end + def self.build_hash_from(args, warn_about_example_group_filtering = _); end + def self.deep_hash_dup(object); end + def self.id_from(metadata); end + def self.location_tuple_from(metadata); end + def self.relative_path(line); end + def self.relative_path_regex; end +end + +class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator + + private + + def described_class; end + def full_description; end + + def self.backwards_compatibility_default_proc(&example_group_selector); end + def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end + def self.hash_with_backwards_compatibility_default_proc; end +end + +class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator + + private + + def described_class; end + def full_description; end + + def self.create(group_metadata, user_metadata, index_provider, description, block); end +end + +class RSpec::Core::Metadata::HashPopulator + def initialize(metadata, user_metadata, index_provider, description_args, block); end + + def block; end + def description_args; end + def metadata; end + def populate; end + def user_metadata; end + + private + + def build_description_from(parent_description = _, my_description = _); end + def build_scoped_id_for(file_path); end + def description_separator(parent_part, child_part); end + def ensure_valid_user_keys; end + def file_path_and_line_number_from(backtrace); end + def populate_location_attributes; end +end + +RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array) + +module RSpec::Core::MetadataFilter + def self.apply?(predicate, filters, metadata); end + def self.filter_applies?(key, filter_value, metadata); end + def self.silence_metadata_example_group_deprecations; end +end + +class RSpec::Core::MultipleExceptionError < ::StandardError + include(::RSpec::Core::MultipleExceptionError::InterfaceTag) + + def initialize(*exceptions); end + + def aggregation_block_label; end + def aggregation_metadata; end + def all_exceptions; end + def exception_count_description; end + def failures; end + def message; end + def other_errors; end + def summary; end +end + +module RSpec::Core::MultipleExceptionError::InterfaceTag + def add(exception); end + + def self.for(ex); end +end + +module RSpec::Core::Notifications +end + +class RSpec::Core::Notifications::CustomNotification < ::Struct + def self.for(options = _); end +end + +class RSpec::Core::Notifications::DeprecationNotification < ::Struct + def call_site; end + def call_site=(_); end + def deprecated; end + def deprecated=(_); end + def message; end + def message=(_); end + def replacement; end + def replacement=(_); end + + def self.[](*_); end + def self.from_hash(data); end + def self.inspect; end + def self.members; end +end + +class RSpec::Core::Notifications::ExampleNotification < ::Struct + def example; end + def example=(_); end + + def self.[](*_); end + def self.for(example); end + def self.inspect; end + def self.members; end +end + +class RSpec::Core::Notifications::ExamplesNotification + def initialize(reporter); end + + def examples; end + def failed_examples; end + def failure_notifications; end + def fully_formatted_failed_examples(colorizer = _); end + def fully_formatted_pending_examples(colorizer = _); end + def notifications; end + def pending_examples; end + def pending_notifications; end + + private + + def format_examples(examples); end +end + +class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification + def initialize(example, exception_presenter = _); end + + def colorized_formatted_backtrace(colorizer = _); end + def colorized_message_lines(colorizer = _); end + def description; end + def exception; end + def formatted_backtrace; end + def fully_formatted(failure_number, colorizer = _); end + def fully_formatted_lines(failure_number, colorizer = _); end + def message_lines; end +end + +class RSpec::Core::Notifications::GroupNotification < ::Struct + def group; end + def group=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Notifications::MessageNotification < ::Struct + def message; end + def message=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RSpec::Core::Notifications::NullColorizer + + private + + def wrap(line, _code_or_symbol); end + + def self.wrap(line, _code_or_symbol); end +end + +class RSpec::Core::Notifications::NullNotification +end + +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification +end + +class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification +end + +class RSpec::Core::Notifications::ProfileNotification + def initialize(duration, examples, number_of_examples, example_groups); end + + def duration; end + def examples; end + def number_of_examples; end + def percentage; end + def slow_duration; end + def slowest_examples; end + def slowest_groups; end + + private + + def calculate_slowest_groups; end +end + +class RSpec::Core::Notifications::SeedNotification < ::Struct + def fully_formatted; end + def seed; end + def seed=(_); end + def seed_used?; end + def used=(_); end + + private + + def used; end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification + def fully_formatted(pending_number, colorizer = _); end +end + +class RSpec::Core::Notifications::StartNotification < ::Struct + def count; end + def count=(_); end + def load_time; end + def load_time=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Notifications::SummaryNotification < ::Struct + include(::RSpec::Core::ShellEscape) + + def colorized_rerun_commands(colorizer = _); end + def colorized_totals_line(colorizer = _); end + def duration; end + def duration=(_); end + def errors_outside_of_examples_count; end + def errors_outside_of_examples_count=(_); end + def example_count; end + def examples; end + def examples=(_); end + def failed_examples; end + def failed_examples=(_); end + def failure_count; end + def formatted_duration; end + def formatted_load_time; end + def fully_formatted(colorizer = _); end + def load_time; end + def load_time=(_); end + def pending_count; end + def pending_examples; end + def pending_examples=(_); end + def totals_line; end + + private + + def duplicate_rerun_locations; end + def rerun_argument_for(example); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::NullReporter +end + +module RSpec::Core::Ordering +end + +class RSpec::Core::Ordering::ConfigurationManager + def initialize; end + + def force(hash); end + def order=(type); end + def ordering_registry; end + def register_ordering(name, strategy = _); end + def seed; end + def seed=(seed); end + def seed_used?; end +end + +class RSpec::Core::Ordering::Custom + def initialize(callable); end + + def order(list); end +end + +class RSpec::Core::Ordering::Identity + def order(items); end +end + +class RSpec::Core::Ordering::Random + def initialize(configuration); end + + def order(items); end + def used?; end + + private + + def jenkins_hash_digest(string); end +end + +RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer) + +class RSpec::Core::Ordering::Registry + def initialize(configuration); end + + def fetch(name, &fallback); end + def register(sym, strategy); end + def used_random_seed?; end +end + +class RSpec::Core::OutputWrapper + def initialize(output); end + + def <<(*args, &block); end + def advise(*args, &block); end + def autoclose=(*args, &block); end + def autoclose?(*args, &block); end + def binmode(*args, &block); end + def binmode?(*args, &block); end + def bytes(*args, &block); end + def chars(*args, &block); end + def close(*args, &block); end + def close_on_exec=(*args, &block); end + def close_on_exec?(*args, &block); end + def close_read(*args, &block); end + def close_write(*args, &block); end + def closed?(*args, &block); end + def codepoints(*args, &block); end + def each(*args, &block); end + def each_byte(*args, &block); end + def each_char(*args, &block); end + def each_codepoint(*args, &block); end + def each_line(*args, &block); end + def eof(*args, &block); end + def eof?(*args, &block); end + def external_encoding(*args, &block); end + def fcntl(*args, &block); end + def fdatasync(*args, &block); end + def fileno(*args, &block); end + def flush(*args, &block); end + def fsync(*args, &block); end + def getbyte(*args, &block); end + def getc(*args, &block); end + def gets(*args, &block); end + def inspect(*args, &block); end + def internal_encoding(*args, &block); end + def ioctl(*args, &block); end + def isatty(*args, &block); end + def lineno(*args, &block); end + def lineno=(*args, &block); end + def lines(*args, &block); end + def method_missing(name, *args, &block); end + def output; end + def output=(_); end + def pathconf(*args, &block); end + def pid(*args, &block); end + def pos(*args, &block); end + def pos=(*args, &block); end + def pread(*args, &block); end + def print(*args, &block); end + def printf(*args, &block); end + def putc(*args, &block); end + def puts(*args, &block); end + def pwrite(*args, &block); end + def read(*args, &block); end + def read_nonblock(*args, &block); end + def readbyte(*args, &block); end + def readchar(*args, &block); end + def readline(*args, &block); end + def readlines(*args, &block); end + def readpartial(*args, &block); end + def reopen(*args, &block); end + def respond_to?(name, priv = _); end + def rewind(*args, &block); end + def seek(*args, &block); end + def set_encoding(*args, &block); end + def stat(*args, &block); end + def sync(*args, &block); end + def sync=(*args, &block); end + def sysread(*args, &block); end + def sysseek(*args, &block); end + def syswrite(*args, &block); end + def tell(*args, &block); end + def to_i(*args, &block); end + def to_io(*args, &block); end + def tty?(*args, &block); end + def ungetbyte(*args, &block); end + def ungetc(*args, &block); end + def write(*args, &block); end + def write_nonblock(*args, &block); end +end + +class RSpec::Core::Parser + def initialize(original_args); end + + def original_args; end + def parse(source = _); end + + private + + def add_tag_filter(options, filter_type, tag_name, value = _); end + def configure_only_failures(options); end + def parser(options); end + def set_fail_fast(options, value); end + + def self.parse(args, source = _); end +end + +module RSpec::Core::Pending + def pending(message = _); end + def skip(message = _); end + + def self.mark_fixed!(example); end + def self.mark_pending!(example, message_or_bool); end + def self.mark_skipped!(example, message_or_bool); end +end + +RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String) + +RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String) + +class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError +end + +class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError + def initialize(argument); end + + def argument; end +end + +class RSpec::Core::Profiler + def initialize; end + + def example_group_finished(notification); end + def example_group_started(notification); end + def example_groups; end + def example_started(notification); end +end + +RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array) + +class RSpec::Core::Reporter + def initialize(configuration); end + + def abort_with(msg, exit_status); end + def close_after; end + def deprecation(hash); end + def example_failed(example); end + def example_finished(example); end + def example_group_finished(group); end + def example_group_started(group); end + def example_passed(example); end + def example_pending(example); end + def example_started(example); end + def examples; end + def exit_early(exit_code); end + def fail_fast_limit_met?; end + def failed_examples; end + def finish; end + def message(message); end + def notify(event, notification); end + def notify_non_example_exception(exception, context_description); end + def pending_examples; end + def prepare_default(loader, output_stream, deprecation_stream); end + def publish(event, options = _); end + def register_listener(listener, *notifications); end + def registered_listeners(notification); end + def report(expected_example_count); end + def start(expected_example_count, time = _); end + def stop; end + + private + + def close; end + def ensure_listeners_ready; end + def mute_profile_output?; end + def seed_used?; end +end + +RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +module RSpec::Core::RubyProject + + private + + def add_dir_to_load_path(dir); end + def add_to_load_path(*dirs); end + def ascend_until; end + def determine_root; end + def find_first_parent_containing(dir); end + def root; end + + def self.add_dir_to_load_path(dir); end + def self.add_to_load_path(*dirs); end + def self.ascend_until; end + def self.determine_root; end + def self.find_first_parent_containing(dir); end + def self.root; end +end + +class RSpec::Core::Runner + def initialize(options, configuration = _, world = _); end + + def configuration; end + def configure(err, out); end + def options; end + def run(err, out); end + def run_specs(example_groups); end + def setup(err, out); end + def world; end + + private + + def persist_example_statuses; end + + def self.autorun; end + def self.autorun_disabled?; end + def self.disable_autorun!; end + def self.handle_interrupt; end + def self.installed_at_exit?; end + def self.invoke; end + def self.perform_at_exit; end + def self.run(args, err = _, out = _); end + def self.running_in_drb?; end + def self.trap_interrupt; end +end + +class RSpec::Core::Set + include(::Enumerable) + + def initialize(array = _); end + + def <<(key); end + def clear; end + def delete(key); end + def each(&block); end + def empty?; end + def include?(key); end + def merge(values); end +end + +module RSpec::Core::SharedContext + def __shared_context_recordings; end + def after(*args, &block); end + def append_after(*args, &block); end + def append_before(*args, &block); end + def around(*args, &block); end + def before(*args, &block); end + def context(*args, &block); end + def describe(*args, &block); end + def hooks(*args, &block); end + def included(group); end + def let(*args, &block); end + def let!(*args, &block); end + def prepend_after(*args, &block); end + def prepend_before(*args, &block); end + def subject(*args, &block); end + def subject!(*args, &block); end + + def self.record(methods); end +end + +class RSpec::Core::SharedContext::Recording < ::Struct + def args; end + def args=(_); end + def block; end + def block=(_); end + def method_name; end + def method_name=(_); end + def playback_onto(group); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RSpec::Core::SharedExampleGroup + def shared_context(name, *args, &block); end + def shared_examples(name, *args, &block); end + def shared_examples_for(name, *args, &block); end +end + +class RSpec::Core::SharedExampleGroup::Registry + def add(context, name, *metadata_args, &block); end + def find(lookup_contexts, name); end + + private + + def ensure_block_has_source_location(_block); end + def formatted_location(block); end + def legacy_add(context, name, *metadata_args, &block); end + def shared_example_groups; end + def valid_name?(candidate); end + def warn_if_key_taken(context, key, new_block); end +end + +module RSpec::Core::SharedExampleGroup::TopLevelDSL + def self.definitions; end + def self.expose_globally!; end + def self.exposed_globally?; end + def self.remove_globally!; end +end + +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def initialize(shared_group_name, inclusion_location); end + + def description; end + def formatted_inclusion_location; end + def inclusion_location; end + def shared_group_name; end + + def self.current_backtrace; end + def self.shared_example_group_inclusions; end + def self.with_frame(name, location); end +end + +class RSpec::Core::SharedExampleGroupModule < ::Module + def initialize(description, definition, metadata); end + + def definition; end + def include_in(klass, inclusion_line, args, customization_block); end + def included(klass); end + def inspect; end + def to_s; end +end + +module RSpec::Core::ShellEscape + + private + + def conditionally_quote(id); end + def escape(shell_command); end + def quote(argument); end + def shell_allows_unquoted_ids?; end + + def self.conditionally_quote(id); end + def self.escape(shell_command); end + def self.quote(argument); end + def self.shell_allows_unquoted_ids?; end +end + +RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array) + +class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example + def initialize(hook_description, reporter); end + + def set_exception(exception); end +end + +class RSpec::Core::Time + def self.now; end +end + +module RSpec::Core::Version +end + +RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String) + +module RSpec::Core::Warnings + def deprecate(deprecated, data = _); end + def warn_deprecation(message, opts = _); end + def warn_with(message, options = _); end +end + +class RSpec::Core::World + def initialize(configuration = _); end + + def all_example_groups; end + def all_examples; end + def announce_exclusion_filter(announcements); end + def announce_filters; end + def announce_inclusion_filter(announcements); end + def everything_filtered_message; end + def example_count(groups = _); end + def example_group_counts_by_spec_file; end + def example_groups; end + def exclusion_filter; end + def filter_manager; end + def filtered_examples; end + def inclusion_filter; end + def non_example_failure; end + def non_example_failure=(_); end + def num_example_groups_defined_in(file); end + def ordered_example_groups; end + def preceding_declaration_line(absolute_file_name, filter_line); end + def prepare_example_filtering; end + def record(example_group); end + def registered_example_group_files; end + def report_filter_message(message); end + def reporter; end + def reset; end + def shared_example_group_registry; end + def source_from_file(path); end + def syntax_highlighter; end + def traverse_example_group_trees_until(&block); end + def wants_to_quit; end + def wants_to_quit=(_); end + + private + + def descending_declaration_line_numbers_by_file; end + def fail_if_config_and_cli_options_invalid; end +end + +module RSpec::Core::World::Null + def self.all_example_groups; end + def self.example_groups; end + def self.non_example_failure; end + def self.non_example_failure=(_); end + def self.registered_example_group_files; end + def self.traverse_example_group_trees_until; end +end + +module RSpec::ExampleGroups + extend(::RSpec::Support::RecursiveConstMethods) + + def self.assign_const(group); end + def self.base_name_for(group); end + def self.constant_scope_for(group); end + def self.disambiguate(name, const_scope); end + def self.remove_all_constants; end +end + +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Core::Bisect +end + +class RSpec::Core::Bisect::BisectFailedError < ::StandardError + def self.for_failed_spec_run(spec_output); end +end + +class RSpec::Core::Bisect::Channel + def initialize; end + + def close; end + def receive; end + def send(message); end +end + +class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct + def all_example_ids; end + def all_example_ids=(_); end + def failed_example_ids; end + def failed_example_ids=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Core::Bisect::Notifier + def initialize(formatter); end + + def publish(event, *args); end +end + +class RSpec::Core::ExampleStatusDumper + def initialize(examples); end + + def dump; end + + private + + def column_widths; end + def formatted_header_rows; end + def formatted_row_from(row_values); end + def formatted_value_rows; end + def headers; end + def rows; end + + def self.dump(examples); end +end + +class RSpec::Core::ExampleStatusMerger + def initialize(this_run, from_previous_runs); end + + def merge; end + + private + + def delete_previous_examples_that_no_longer_exist; end + def example_must_no_longer_exist?(ex_id); end + def hash_from(example_list); end + def loaded_spec_files; end + def sort_value_from(example); end + def spec_file_from(ex_id); end + + def self.merge(this_run, from_previous_runs); end +end + +class RSpec::Core::ExampleStatusParser + def initialize(string); end + + def parse; end + + private + + def headers; end + def parse_row(line); end + def split_line(line); end + + def self.parse(string); end +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def initialize(expected_failures); end + + def example_failed(notification); end + def example_finished(notification); end + def start_dump(_notification); end + + def self.inherited(formatter); end +end + +class RSpec::Core::Formatters::BaseFormatter + def initialize(output); end + + def close(_notification); end + def example_group; end + def example_group=(_); end + def example_group_started(notification); end + def output; end + def start(notification); end + + private + + def output_supports_sync; end + def restore_sync_output; end + def start_sync_output; end +end + +class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter + def close(_notification); end + def dump_failures(notification); end + def dump_pending(notification); end + def dump_summary(summary); end + def message(notification); end + def seed(notification); end +end + +class RSpec::Core::Formatters::HtmlPrinter + include(::ERB::Util) + + def initialize(output); end + + def flush; end + def make_example_group_header_red(group_id); end + def make_example_group_header_yellow(group_id); end + def make_header_red; end + def make_header_yellow; end + def move_progress(percent_done); end + def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end + def print_example_group_end; end + def print_example_group_start(group_id, description, number_of_parents); end + def print_example_passed(description, run_time); end + def print_example_pending(description, pending_message); end + def print_html_start; end + def print_summary(duration, example_count, failure_count, pending_count); end + + private + + def indentation_style(number_of_parents); end +end + +RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String) + +RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String) + +RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String) + +RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi new file mode 100644 index 0000000000..b1aed5dc1c --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.9.2.rbi @@ -0,0 +1,1482 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RSpec::Expectations + def self.configuration; end + def self.differ; end + def self.fail_with(message, expected = _, actual = _); end +end + +class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget + def not_to(matcher, message = _, &block); end + def to(matcher, message = _, &block); end + def to_not(matcher, message = _, &block); end + + private + + def enforce_block_expectation(matcher); end + def supports_block_expectations?(matcher); end +end + +class RSpec::Expectations::BlockSnippetExtractor + def initialize(proc, method_name); end + + def body_content_lines; end + def method_name; end + def proc; end + + private + + def beginning_line_number; end + def block_token_extractor; end + def file_path; end + def raw_body_lines; end + def raw_body_snippet; end + def source; end + def source_location; end + + def self.try_extracting_single_line_body_of(proc, method_name); end +end + +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct + def beginning_line_number; end + def beginning_line_number=(_); end + def body_content_locations; end + def method_call_location; end + def method_name; end + def method_name=(_); end + def source; end + def source=(_); end + + private + + def block_body_node; end + def block_wrapper_node; end + def candidate_block_wrapper_nodes; end + def candidate_method_ident_nodes; end + def method_ident_node; end + def method_ident_node?(node); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct + def initialize(*_); end + + def beginning_line_number; end + def beginning_line_number=(_); end + def body_tokens; end + def method_name; end + def method_name=(_); end + def source; end + def source=(_); end + def state; end + + private + + def after_beginning_of_args_state(token); end + def after_beginning_of_body_state(token); end + def after_method_call_state(token); end + def after_opener_state(token); end + def block_locator; end + def correct_block?(body_tokens); end + def finalize_pending_tokens!; end + def finish!; end + def finish_or_find_next_block_if_incorrect!; end + def handle_closer_token(token); end + def handle_opener_token(token); end + def initial_state(token); end + def invoke_state_handler(token); end + def opener_token?(token); end + def opener_token_stack; end + def parse!; end + def pending_tokens; end + def pipe_token?(token); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError +end + +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::Configuration + def initialize; end + + def add_should_and_should_not_to(*modules); end + def backtrace_formatter; end + def backtrace_formatter=(_); end + def color?; end + def false_positives_handler; end + def include_chain_clauses_in_custom_matcher_descriptions=(_); end + def include_chain_clauses_in_custom_matcher_descriptions?; end + def max_formatted_output_length=(length); end + def on_potential_false_positives; end + def on_potential_false_positives=(behavior); end + def reset_syntaxes_to_default; end + def syntax; end + def syntax=(values); end + def warn_about_potential_false_positives=(boolean); end + def warn_about_potential_false_positives?; end +end + +RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash) + +module RSpec::Expectations::Configuration::NullBacktraceFormatter + def self.format_backtrace(backtrace); end +end + +module RSpec::Expectations::ExpectationHelper + def self.check_message(msg); end + def self.handle_failure(matcher, message, failure_message_method); end + def self.modern_matcher_from(matcher); end + def self.with_matcher(handler, matcher, message); end +end + +class RSpec::Expectations::ExpectationNotMetError < ::Exception +end + +class RSpec::Expectations::ExpectationTarget + include(::RSpec::Expectations::ExpectationTarget::InstanceMethods) + + def initialize(value); end + + def target; end + + def self.for(value, block); end +end + +module RSpec::Expectations::ExpectationTarget::InstanceMethods + def not_to(matcher = _, message = _, &block); end + def to(matcher = _, message = _, &block); end + def to_not(matcher = _, message = _, &block); end + + private + + def prevent_operator_matchers(verb); end +end + +module RSpec::Expectations::ExpectationTarget::UndefinedValue +end + +class RSpec::Expectations::FailureAggregator + def initialize(block_label, metadata); end + + def aggregate; end + def block_label; end + def call(failure, options); end + def failures; end + def metadata; end + def other_errors; end + + private + + def assign_backtrace(failure); end + def notify_aggregated_failures; end +end + +RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter + +class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator + def initialize(matcher); end + + def self.wrap(matcher); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter + def failure_message; end + def failure_message_when_negated; end + + def self.interface_matches?(matcher); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter + def failure_message; end + def failure_message_when_negated; end + + def self.interface_matches?(matcher); end +end + +class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError + def initialize(failure_aggregator); end + + def aggregation_block_label; end + def aggregation_metadata; end + def all_exceptions; end + def exception_count_description; end + def failures; end + def message; end + def other_errors; end + def summary; end + + private + + def block_description; end + def enumerated(exceptions, index_offset); end + def enumerated_errors; end + def enumerated_failures; end + def indentation; end + def indented(failure_message, index); end + def index_label(index); end + def longest_index_label_width; end + def pluralize(noun, count); end + def width_of_label(index); end +end + +class RSpec::Expectations::NegativeExpectationHandler + def self.does_not_match?(matcher, actual, &block); end + def self.handle_matcher(actual, initial_matcher, message = _, &block); end + def self.opposite_should_method; end + def self.should_method; end + def self.verb; end +end + +class RSpec::Expectations::PositiveExpectationHandler + def self.handle_matcher(actual, initial_matcher, message = _, &block); end + def self.opposite_should_method; end + def self.should_method; end + def self.verb; end +end + +module RSpec::Expectations::Syntax + + private + + def default_should_host; end + def disable_expect(syntax_host = _); end + def disable_should(syntax_host = _); end + def enable_expect(syntax_host = _); end + def enable_should(syntax_host = _); end + def expect_enabled?(syntax_host = _); end + def should_enabled?(syntax_host = _); end + def warn_about_should!; end + def warn_about_should_unless_configured(method_name); end + + def self.default_should_host; end + def self.disable_expect(syntax_host = _); end + def self.disable_should(syntax_host = _); end + def self.enable_expect(syntax_host = _); end + def self.enable_should(syntax_host = _); end + def self.expect_enabled?(syntax_host = _); end + def self.should_enabled?(syntax_host = _); end + def self.warn_about_should!; end + def self.warn_about_should_unless_configured(method_name); end +end + +module RSpec::Expectations::Version +end + +RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String) + +module RSpec::Matchers + extend(::RSpec::Matchers::DSL) + + def a_block_changing(*args, &block); end + def a_block_outputting(*args, &block); end + def a_block_raising(*args, &block); end + def a_block_throwing(*args, &block); end + def a_block_yielding_control(*args, &block); end + def a_block_yielding_successive_args(*args, &block); end + def a_block_yielding_with_args(*args, &block); end + def a_block_yielding_with_no_args(*args, &block); end + def a_collection_containing_exactly(*args, &block); end + def a_collection_ending_with(*args, &block); end + def a_collection_including(*args, &block); end + def a_collection_starting_with(*args, &block); end + def a_falsey_value(*args, &block); end + def a_falsy_value(*args, &block); end + def a_hash_including(*args, &block); end + def a_kind_of(*args, &block); end + def a_nil_value(*args, &block); end + def a_range_covering(*args, &block); end + def a_string_ending_with(*args, &block); end + def a_string_including(*args, &block); end + def a_string_matching(*args, &block); end + def a_string_starting_with(*args, &block); end + def a_truthy_value(*args, &block); end + def a_value(*args, &block); end + def a_value_between(*args, &block); end + def a_value_within(*args, &block); end + def aggregate_failures(label = _, metadata = _, &block); end + def all(expected); end + def an_instance_of(*args, &block); end + def an_object_eq_to(*args, &block); end + def an_object_eql_to(*args, &block); end + def an_object_equal_to(*args, &block); end + def an_object_existing(*args, &block); end + def an_object_having_attributes(*args, &block); end + def an_object_matching(*args, &block); end + def an_object_responding_to(*args, &block); end + def an_object_satisfying(*args, &block); end + def be(*args); end + def be_a(klass); end + def be_a_kind_of(expected); end + def be_an(klass); end + def be_an_instance_of(expected); end + def be_between(min, max); end + def be_falsey; end + def be_falsy(*args, &block); end + def be_instance_of(expected); end + def be_kind_of(expected); end + def be_nil; end + def be_truthy; end + def be_within(delta); end + def change(receiver = _, message = _, &block); end + def changing(*args, &block); end + def contain_exactly(*items); end + def containing_exactly(*args, &block); end + def cover(*values); end + def covering(*args, &block); end + def end_with(*expected); end + def ending_with(*args, &block); end + def eq(expected); end + def eq_to(*args, &block); end + def eql(expected); end + def eql_to(*args, &block); end + def equal(expected); end + def equal_to(*args, &block); end + def exist(*args); end + def existing(*args, &block); end + def expect(value = _, &block); end + def have_attributes(expected); end + def having_attributes(*args, &block); end + def include(*expected); end + def including(*args, &block); end + def match(expected); end + def match_array(items); end + def match_regex(*args, &block); end + def matching(*args, &block); end + def output(expected = _); end + def raise_error(error = _, message = _, &block); end + def raise_exception(error = _, message = _, &block); end + def raising(*args, &block); end + def respond_to(*names); end + def responding_to(*args, &block); end + def satisfy(description = _, &block); end + def satisfying(*args, &block); end + def start_with(*expected); end + def starting_with(*args, &block); end + def throw_symbol(expected_symbol = _, expected_arg = _); end + def throwing(*args, &block); end + def within(*args, &block); end + def yield_control; end + def yield_successive_args(*args); end + def yield_with_args(*args); end + def yield_with_no_args; end + def yielding_control(*args, &block); end + def yielding_successive_args(*args, &block); end + def yielding_with_args(*args, &block); end + def yielding_with_no_args(*args, &block); end + + private + + def method_missing(method, *args, &block); end + def respond_to_missing?(method, *_); end + + def self.alias_matcher(*args, &block); end + def self.clear_generated_description; end + def self.configuration; end + def self.generated_description; end + def self.is_a_describable_matcher?(obj); end + def self.is_a_matcher?(obj); end + def self.last_description; end + def self.last_expectation_handler; end + def self.last_expectation_handler=(_); end + def self.last_matcher; end + def self.last_matcher=(_); end +end + +class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator + def initialize(base_matcher, description_block); end + + def description; end + def failure_message; end + def failure_message_when_negated; end + def method_missing(*_); end +end + +class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher +end + +class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher + def does_not_match?(*args, &block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(*args, &block); end + + private + + def optimal_failure_message(same, inverted); end +end + +RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + +RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp) + +module RSpec::Matchers::BuiltIn +end + +class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(matcher); end + + def description; end + def does_not_match?(_actual); end + def failed_objects; end + def failure_message; end + def matcher; end + + private + + def add_new_line_if_needed(message); end + def failure_message_for_item(index, failure_message); end + def indent_multiline_message(message); end + def index_failed_objects; end + def initialize_copy(other); end + def iterable?; end + def match(_expected, _actual); end +end + +class RSpec::Matchers::BuiltIn::BaseMatcher + include(::RSpec::Matchers::Composable) + include(::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting) + include(::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages) + + def initialize(expected = _); end + + def actual; end + def actual_formatted; end + def description; end + def diffable?; end + def expected; end + def expected_formatted; end + def expects_call_stack_jump?; end + def match_unless_raises(*exceptions); end + def matcher_name; end + def matcher_name=(_); end + def matches?(actual); end + def present_ivars; end + def rescued_exception; end + def supports_block_expectations?; end + + private + + def assert_ivars(*expected_ivars); end + + def self.matcher_name; end +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def failure_message; end + def failure_message_when_negated; end + + def self.has_default_failure_messages?(matcher); end +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + + private + + def improve_hash_formatting(inspect_string); end + + def self.improve_hash_formatting(inspect_string); end +end + +RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object) + +class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher + include(::RSpec::Matchers::BuiltIn::BeHelpers) + + def initialize(*args); end + + def <(operand); end + def <=(operand); end + def ==(operand); end + def ===(operand); end + def =~(operand); end + def >(operand); end + def >=(operand); end + def failure_message; end + def failure_message_when_negated; end + + private + + def match(_, actual); end +end + +class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher + + private + + def match(expected, actual); end +end + +class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher + def description; end + + private + + def match(expected, actual); end +end + +class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(min, max); end + + def description; end + def exclusive; end + def failure_message; end + def inclusive; end + def matches?(actual); end + + private + + def comparable?; end + def compare; end + def not_comparable_clause; end +end + +class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher + include(::RSpec::Matchers::BuiltIn::BeHelpers) + + def initialize(operand, operator); end + + def description; end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual); end +end + +class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher + def failure_message; end + def failure_message_when_negated; end + + private + + def match(_, actual); end +end + +class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher + def failure_message; end + def failure_message_when_negated; end + + private + + def match(_, actual); end +end + +class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher + include(::RSpec::Matchers::BuiltIn::BeHelpers) + + def initialize(*args, &block); end + + def description; end + def does_not_match?(actual, &block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual, &block); end + + private + + def failure_message_expecting(value); end + def parse_expected(expected); end + def predicate; 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 private_predicate?; end + def validity_message; end +end + +class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher + def failure_message; end + def failure_message_when_negated; end + + private + + def match(_, actual); end +end + +class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(delta); end + + def description; end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual); end + def of(expected); end + def percent_of(expected); end + + private + + def needs_expected; end + def not_numeric_clause; end + def numeric?; end +end + +class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(receiver = _, message = _, &block); end + + def by(expected_delta); end + def by_at_least(minimum); end + def by_at_most(maximum); end + def description; end + def does_not_match?(event_proc); end + def failure_message; end + def failure_message_when_negated; end + def from(value); end + def matches?(event_proc); end + def supports_block_expectations?; end + def to(value); end + + private + + def change_details; end + def negative_failure_reason; end + def perform_change(event_proc); end + def positive_failure_reason; end + def raise_block_syntax_error; end +end + +class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(matcher_1, matcher_2); end + + def description; end + def diffable?; end + def does_not_match?(_actual); end + def evaluator; end + def expected; end + def expects_call_stack_jump?; end + def matcher_1; end + def matcher_2; end + def supports_block_expectations?; end + + protected + + def diffable_matcher_list; end + + private + + def compound_failure_message; end + def diffable_matcher_list_for(matcher); end + def indent_multiline_message(message); end + def initialize_copy(other); end + def match(_expected, actual); end + def matcher_1_matches?; end + def matcher_2_matches?; end + def matcher_is_diffable?(matcher); end + def matcher_supports_block_expectations?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound + def failure_message; end + + private + + def conjunction; end + def match(*_); end +end + +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + def initialize(actual, matcher_1, matcher_2); end + + def matcher_matches?(matcher); end + + private + + def inner_matcher_block(outer_args); end + def order_block_matchers; end + + def self.matcher_expects_call_stack_jump?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound + def failure_message; end + + private + + def conjunction; end + def match(*_); end +end + +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator + def initialize(actual, *_); end + + def matcher_matches?(matcher); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher + def description; end + def failure_message; end + def failure_message_when_negated; end + + private + + def actual_collection_line; end + def best_solution; end + def convert_actual_to_an_array; end + def describe_collection(collection, surface_descriptions = _); end + def expected_collection_line; end + def extra_elements_line; end + def extra_items; end + def generate_failure_message; end + def match(_expected, _actual); end + def match_when_sorted?; end + def message_line(prefix, collection, surface_descriptions = _); end + def missing_elements_line; end + def missing_items; end + def pairings_maximizer; end + def safe_sort(array); end + def to_a_disallowed?(object); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer + def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end + + def actual_to_expected_matched_indexes; end + def expected_to_actual_matched_indexes; end + def find_best_solution; end + def solution; end + + private + + def apply_pairing_to(indeterminates, original_matches, other_list_index); end + def best_solution_for_pairing(expected_index, actual_index); end + def categorize_indexes(indexes_to_categorize, other_indexes); end + def reciprocal_single_match?(matches, index, other_list); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution + def self.worse_than?(_other); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct + def +(derived_candidate_solution); end + def candidate?; end + def ideal?; end + def indeterminate_actual_indexes; end + def indeterminate_actual_indexes=(_); end + def indeterminate_expected_indexes; end + def indeterminate_expected_indexes=(_); end + def unmatched_actual_indexes; end + def unmatched_actual_indexes=(_); end + def unmatched_expected_indexes; end + def unmatched_expected_indexes=(_); end + def unmatched_item_count; end + def worse_than?(other); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*expected); end + + def does_not_match?(range); end + def matches?(range); end +end + +class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith + + private + + def element_matches?; end + def subset_matches?; end +end + +class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher + def description; end + def diffable?; end + def failure_message; end + def failure_message_when_negated; end + + private + + def match(expected, actual); end +end + +class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher + def diffable?; end + def failure_message; end + def failure_message_when_negated; end + + private + + def match(expected, actual); end +end + +class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher + def diffable?; end + def failure_message; end + def failure_message_when_negated; end + + private + + def actual_inspected; end + def detailed_failure_message; end + def expected_is_a_literal_singleton?; end + def inspect_object(o); end + def match(expected, actual); end + def simple_failure_message; end +end + +RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array) + +class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*expected); end + + def does_not_match?(actual); end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual); end +end + +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct + def actual_exists?; end + def valid_test?; end + def validity_message; end + + private + + def deprecated(predicate, actual); end + def existence_values; end + def predicates; end + def uniq_truthy_values; end +end + +class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(method_name, *args, &block); end + + def description; end + def does_not_match?(actual, &block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual, &block); end + + private + + def args_description; end + def failure_message_args_description; 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 initialize(expected); end + + def actual; end + def description; end + def diffable?; end + def does_not_match?(actual); end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual); end + def respond_to_failed; end + + private + + def actual_has_attribute?(attribute_key, attribute_value); end + def cache_all_values; end + def formatted_values; end + def perform_match(predicate); end + def respond_to_attributes?; end + def respond_to_failure_message_or; end + def respond_to_matcher; end +end + +class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*expecteds); end + + def description; end + def diffable?; end + def does_not_match?(actual); end + def expected; end + def expecteds; end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual); end + + private + + 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 comparing_hash_keys?(expected_item); end + def comparing_hash_to_a_subset?(expected_item); end + def convert_to_hash?(obj); end + def diff_would_wrongly_highlight_matched_item?; end + def excluded_from_actual; end + def format_failure_message(preposition); end + def perform_match(actual, &block); end + def readable_list_of(items); end +end + +class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(expected); end + + def description; end + def diffable?; end + def with_captures(*captures); end + + private + + def can_safely_call_match?(expected, actual); end + def match(expected, actual); end + def match_captures(expected, actual); end +end + +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::OperatorMatcher + def initialize(actual); end + + def !=(_expected); end + def !~(_expected); end + def <(expected); end + def <=(expected); end + def ==(expected); end + def ===(expected); end + def =~(expected); end + def >(expected); end + def >=(expected); end + def description; end + def fail_with_message(message); end + + private + + def eval_match(actual, operator, expected); end + def has_non_generic_implementation_of?(op); end + + def self.get(klass, operator); end + def self.register(klass, operator, matcher); end + def self.registry; end + def self.unregister(klass, operator); end + def self.use_custom_matcher_or_delegate(operator); end +end + +class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(expected); end + + def description; end + def diffable?; end + def does_not_match?(block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(block); end + def supports_block_expectations?; end + def to_stderr; end + def to_stderr_from_any_process; end + def to_stdout; end + def to_stdout_from_any_process; end + + private + + def actual_output_description; end + def captured?; end + def negative_failure_reason; end + def positive_failure_reason; end +end + +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::RaiseError + include(::RSpec::Matchers::Composable) + + def initialize(expected_error_or_message = _, expected_message = _, &block); end + + def description; end + def does_not_match?(given_proc); end + def expects_call_stack_jump?; end + def failure_message; end + def failure_message_when_negated; end + def matches?(given_proc, negative_expectation = _, &block); end + def supports_block_expectations?; end + def with_message(expected_message); end + + private + + def block_matches?; end + def error_and_message_match?; end + def eval_block; end + def expectation_matched?; end + def expected_error; end + def expecting_specific_exception?; end + def format_backtrace(backtrace); end + def given_error; end + def handle_warning(message); end + def raise_message_already_set; end + def ready_to_eval_block?; 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 warning; end + def warning_about_bare_error; end +end + +class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*names); end + + def and_any_keywords; end + def and_keywords(*keywords); end + def and_unlimited_arguments; end + def argument; end + def arguments; end + def description; end + def does_not_match?(actual); end + def failure_message; end + def failure_message_when_negated; end + def ignoring_method_signature_failure!; end + def matches?(actual); end + def with(n); end + def with_any_keywords; end + def with_keywords(*keywords); end + def with_unlimited_arguments; end + + private + + def find_failing_method_names(actual, filter_method); 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_arity; end + def with_arity_string; end + def with_keywords_string; end +end + +class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(description = _, &block); end + + def description; end + def failure_message; end + def failure_message_when_negated; end + def matches?(actual, &block); end + + private + + def block_representation; end + def extract_block_snippet; end +end + +class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith + + private + + def element_matches?; end + def subset_matches?; end +end + +class RSpec::Matchers::BuiltIn::ThrowSymbol + include(::RSpec::Matchers::Composable) + + def initialize(expected_symbol = _, expected_arg = _); end + + def description; end + def does_not_match?(given_proc); end + def expects_call_stack_jump?; end + def failure_message; end + def failure_message_when_negated; end + def matches?(given_proc); end + def supports_block_expectations?; end + + private + + def actual_result; end + def caught; end + def expected(symbol_desc = _); end + def throw_description(symbol, arg); end +end + +class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize; end + + def at_least(number); end + def at_most(number); end + def does_not_match?(block); end + def exactly(number); end + def failure_message; end + def failure_message_when_negated; end + def matches?(block); end + def once; end + def supports_block_expectations?; end + def thrice; end + def times; end + def twice; end + + private + + def count_constraint_to_number(n); end + def failure_reason; end + def human_readable_count(count); end + def human_readable_expectation_type; end + def set_expected_yields_count(relativity, n); end +end + +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*args); end + + def description; end + def does_not_match?(block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(block); end + def supports_block_expectations?; end + + private + + def expected_arg_description; end + def negative_failure_reason; end + def positive_failure_reason; end +end + +class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*args); end + + def description; end + def does_not_match?(block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(block); end + def supports_block_expectations?; end + + private + + def all_args_match?; end + def args_currently_match?; end + def expected_arg_description; end + def negative_failure_reason; end + def positive_failure_reason; end +end + +class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + def does_not_match?(block); end + def failure_message; end + def failure_message_when_negated; end + def matches?(block); end + def supports_block_expectations?; end + + private + + def negative_failure_reason; end + def positive_failure_reason; end +end + +module RSpec::Matchers::Composable + def &(matcher); end + def ===(value); end + def and(matcher); end + def or(matcher); end + def |(matcher); end + + private + + def description_of(object); end + def should_enumerate?(item); end + def surface_descriptions_in(item); end + def unreadable_io?(object); end + def values_match?(expected, actual); end + def with_matchers_cloned(object); end + + def self.should_enumerate?(item); end + def self.surface_descriptions_in(item); end + def self.unreadable_io?(object); end +end + +class RSpec::Matchers::Composable::DescribableItem < ::Struct + def inspect; end + def item; end + def item=(_); end + def pretty_print(pp); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RSpec::Matchers::DSL + def alias_matcher(new_name, old_name, options = _, &description_override); end + def define(name, &declarations); end + def define_negated_matcher(negated_name, base_name, &description_override); end + def matcher(name, &declarations); end + + private + + def warn_about_block_args(name, declarations); end +end + +module RSpec::Matchers::DSL::DefaultImplementations + include(::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages) + + def description; end + def diffable?; end + def expects_call_stack_jump?; end + def supports_block_expectations?; end + + private + + def chained_method_clause_sentences; end +end + +module RSpec::Matchers::DSL::Macros + def chain(method_name, *attr_names, &definition); end + def description(&definition); end + def diffable; end + def failure_message(&definition); end + def failure_message_when_negated(&definition); end + def match(options = _, &match_block); end + def match_unless_raises(expected_exception = _, &match_block); end + def match_when_negated(options = _, &match_block); end + def supports_block_expectations; end + + private + + def assign_attributes(attr_names); end + def define_user_override(method_name, user_def, &our_def); end +end + +module RSpec::Matchers::DSL::Macros::Deprecated + def failure_message_for_should(&definition); end + def failure_message_for_should_not(&definition); end + def match_for_should(&definition); end + def match_for_should_not(&definition); end +end + +RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc) + +class RSpec::Matchers::DSL::Matcher + include(::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages) + include(::RSpec::Matchers::DSL::DefaultImplementations) + include(::RSpec::Matchers) + include(::RSpec::Matchers::Composable) + extend(::RSpec::Matchers::DSL::Macros) + extend(::RSpec::Matchers::DSL::Macros::Deprecated) + + def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end + + def actual; end + def block_arg; end + def expected; end + def expected_as_array; end + def inspect; end + def name; end + def rescued_exception; end + + private + + def actual_arg_for(block); end + def method_missing(method, *args, &block); end + def respond_to_missing?(method, include_private = _); end +end + +RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp) + +module RSpec::Matchers::EnglishPhrasing + def self.list(obj); end + def self.split_words(sym); end +end + +class RSpec::Matchers::ExpectedsForMultipleDiffs + def initialize(expected_list); end + + def message_with_diff(message, differ, actual); end + + private + + def diffs(differ, actual); end + + def self.for_many_matchers(matchers); end + def self.from(expected); end +end + +RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String) + +RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer) + +RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp) + +class RSpec::Matchers::MatcherDelegator + include(::RSpec::Matchers::Composable) + + def initialize(base_matcher); end + + def base_matcher; end + def method_missing(*args, &block); end + + private + + def initialize_copy(other); end + def respond_to_missing?(name, include_all = _); end +end + +module RSpec::Matchers::BuiltIn::BeHelpers + + private + + def args_to_s; end + def args_to_sentence; end + def expected_to_sentence; end + def inspected_args; end + def parenthesize(string); end +end + +module RSpec::Matchers::BuiltIn::CaptureStderr + def self.capture(block); end + def self.name; end +end + +module RSpec::Matchers::BuiltIn::CaptureStdout + def self.capture(block); end + def self.name; end +end + +class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct + def capture(block); end +end + +class RSpec::Matchers::BuiltIn::ChangeDetails + def initialize(matcher_name, receiver = _, message = _, &block); end + + def actual_after; end + def actual_delta; end + def changed?; end + def perform_change(event_proc); end + def value_representation; end + + private + + def evaluate_value_proc; end + def extract_value_block_snippet; end + def message_notation(receiver, message); end +end + +class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange + def initialize(change_details, expected_before); end + + def does_not_match?(event_proc); end + def failure_message_when_negated; end + def to(value); end + + private + + def change_description; end +end + +class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(change_details, expected_delta, relativity, &comparer); end + + def description; end + def does_not_match?(_event_proc); end + def failure_message; end + def matches?(event_proc); end + def supports_block_expectations?; end + + private + + def failure_reason; end +end + +class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange + def initialize(change_details, expected_after); end + + def does_not_match?(_event_proc); end + def from(value); end + + private + + def change_description; end +end + +module RSpec::Matchers::BuiltIn::NullCapture + def self.capture(_block); end + def self.name; end +end + +class RSpec::Matchers::BuiltIn::ReliableMatchData + def initialize(match_data); end + + def captures; end + def names; end + + protected + + def match_data; end +end + +class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(change_details, from, to); end + + def description; end + def failure_message; end + def matches?(event_proc); end + def supports_block_expectations?; end + + private + + def after_value_failure; end + def before_value_failure; end + def did_change_failure; end + def did_not_change_failure; end + def matches_after?; end + def not_given_a_block_failure; end + def perform_change(event_proc); end +end + +RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject + +RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith + +class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher + def initialize(*expected); end + + def description; end + def failure_message; end + + private + + def match(_expected, actual); end + def subsets_comparable?; end +end + +class RSpec::Matchers::BuiltIn::YieldProbe + def initialize(block, &callback); end + + def assert_used!; end + def assert_valid_expect_block!; end + def has_block?; end + def num_yields; end + def num_yields=(_); end + def probe; end + def single_yield_args; end + def to_proc; end + def yielded_args; end + def yielded_args=(_); end + def yielded_once?(matcher_name); end + + def self.probe(block, &callback); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi new file mode 100644 index 0000000000..c043a8530b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.9.1.rbi @@ -0,0 +1,1434 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RSpec::Mocks + def self.allow_message(subject, message, opts = _, &block); end + def self.configuration; end + def self.error_generator; end + def self.expect_message(subject, message, opts = _, &block); end + def self.setup; end + def self.space; end + def self.teardown; end + def self.verify; end + def self.with_temporary_scope; end +end + +class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, *_args); end + def to(matcher, &block); end + def to_not(matcher, *_args); end +end + +class RSpec::Mocks::AndReturnImplementation + def initialize(values_to_return); end + + def call(*_args_to_ignore, &_block); end +end + +class RSpec::Mocks::AndWrapOriginalImplementation + def initialize(method, block); end + + def call(*args, &block); end + def initial_action=(_value); end + def inner_action; end + def inner_action=(_value); end + def present?; end + def terminal_action=(_value); end + + private + + def cannot_modify_further_error; end +end + +class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError +end + +class RSpec::Mocks::AndYieldImplementation + def initialize(args_to_yield, eval_context, error_generator); end + + def call(*_args_to_ignore, &block); end +end + +module RSpec::Mocks::AnyInstance + def self.error_generator; end +end + +class RSpec::Mocks::AnyInstance::Chain + include(::RSpec::Mocks::AnyInstance::Chain::Customizations) + + def initialize(recorder, *args, &block); end + + def constrained_to_any_of?(*constraints); end + def expectation_fulfilled!; end + def matches_args?(*args); end + def never; end + def playback!(instance); end + def with(*args, &block); end + + private + + def last_message; end + def messages; end + def negated?; end + def record(rspec_method_name, *args, &block); end +end + +module RSpec::Mocks::AnyInstance::Chain::Customizations + def and_call_original(*args, &block); end + def and_raise(*args, &block); end + def and_return(*args, &block); end + def and_throw(*args, &block); end + def and_wrap_original(*args, &block); end + def and_yield(*args, &block); end + def at_least(*args, &block); end + def at_most(*args, &block); end + def exactly(*args, &block); end + def never(*args, &block); end + def once(*args, &block); end + def thrice(*args, &block); end + def time(*args, &block); end + def times(*args, &block); end + def twice(*args, &block); end + def with(*args, &block); end + + def self.record(method_name); end +end + +class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator + def raise_does_not_implement_error(klass, method_name); end + def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end + def raise_not_supported_with_prepend_error(method_name, problem_mod); end + def raise_second_instance_received_message_error(unfulfilled_expectations); end +end + +class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain + def initialize(*args); end + + def expectation_fulfilled?; end + def playback!(instance); end + + private + + def create_message_expectation_on(instance); end + def invocation_order; end +end + +class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain + def initialize(*args, &block); end + + def expectation_fulfilled?; end + + private + + def verify_invocation_order(_rspec_method_name, *_args, &_block); end +end + +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy + def initialize(targets); end + + def method_missing(*args, &block); end + + private + + def respond_to_missing?(method_name, include_private = _); end +end + +class RSpec::Mocks::AnyInstance::MessageChains + def initialize; end + + def [](method_name); end + def add(method_name, chain); end + def all_expectations_fulfilled?; end + def each_unfulfilled_expectation_matching(method_name, *args); end + def has_expectation?(method_name); end + def playback!(instance, method_name); end + def received_expected_message!(method_name); end + def remove_stub_chains_for!(method_name); end + def unfulfilled_expectations; end + + private + + def raise_if_second_instance_to_receive_message(instance); end +end + +class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain + + private + + def create_message_expectation_on(instance); end + def invocation_order; end +end + +RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash) + +class RSpec::Mocks::AnyInstance::Proxy + def initialize(recorder, target_proxies); end + + def expect_chain(*chain, &block); end + def klass; end + def should_not_receive(method_name, &block); end + def should_receive(method_name, &block); end + def stub(method_name_or_method_map, &block); end + def stub_chain(*chain, &block); end + def unstub(method_name); end + + private + + def perform_proxying(method_name, args, block, &target_proxy_block); end +end + +class RSpec::Mocks::AnyInstance::Recorder + def initialize(klass); end + + def already_observing?(method_name); end + def build_alias_method_name(method_name); end + def expect_chain(*method_names_and_optional_return_values, &block); end + def instance_that_received(method_name); end + def klass; end + def message_chains; end + def notify_received_message(_object, message, args, _blk); end + def playback!(instance, method_name); end + def should_not_receive(method_name, &block); end + def should_receive(method_name, &block); end + def stop_all_observation!; end + def stub(method_name, &block); end + def stub_chain(*method_names_and_optional_return_values, &block); end + def stubs; end + def unstub(method_name); end + def verify; end + + protected + + def stop_observing!(method_name); end + + private + + def allow_no_prepended_module_definition_of(method_name); end + def ancestor_is_an_observer?(method_name); end + def backup_method!(method_name); end + def mark_invoked!(method_name); end + def normalize_chain(*args); end + def observe!(method_name); end + def public_protected_or_private_method_defined?(method_name); end + def received_expected_message!(method_name); end + def remove_dummy_method!(method_name); end + def restore_method!(method_name); end + def restore_original_method!(method_name); end + def super_class_observers_for(method_name); end + def super_class_observing?(method_name); end +end + +class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain + def expectation_fulfilled?; end + + private + + def create_message_expectation_on(instance); end + def invocation_order; end + def verify_invocation_order(rspec_method_name, *_args, &_block); end +end + +RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash) + +RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash) + +class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain + def initialize(*args); end + + + private + + def create_message_expectation_on(instance); end + def invocation_order; end +end + +class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, *_args); end + def to(matcher, &block); end + def to_not(matcher, *_args); end +end + +class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase + def expression; end + def not_to(matcher, &block); end + def to(matcher, &block); end + def to_not(matcher, &block); end +end + +class RSpec::Mocks::ArgumentListMatcher + def initialize(*expected_args); end + + def args_match?(*args); end + def expected_args; end + def resolve_expected_args_based_on(actual_args); end + + private + + def ensure_expected_args_valid!; end + def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end +end + +RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher) + +module RSpec::Mocks::ArgumentMatchers + def a_kind_of(klass); end + def an_instance_of(klass); end + def any_args; end + def anything; end + def array_including(*args); end + def boolean; end + def duck_type(*args); end + def hash_excluding(*args); end + def hash_including(*args); end + def hash_not_including(*args); end + def instance_of(klass); end + def kind_of(klass); end + def no_args; end + + def self.anythingize_lonely_keys(*args); end +end + +class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def ===(_other); end + def description; end +end + +RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher) + +class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def description; end +end + +RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher) + +class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher + def initialize(expected); end + + def ===(actual); end + def description; end + + private + + def formatted_expected_values; end +end + +class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def initialize(expected); end + + def ===(predicate, actual); end + def description(name); end + + private + + def formatted_expected_hash; end +end + +class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def ===(value); end + def description; end +end + +RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher) + +class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher + def initialize(*methods_to_respond_to); end + + def ===(value); end + def description; end +end + +class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(actual); end + def description; end +end + +class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(actual); end + def description; end +end + +class RSpec::Mocks::ArgumentMatchers::InstanceOf + def initialize(klass); end + + def ===(actual); end + def description; end +end + +class RSpec::Mocks::ArgumentMatchers::KindOf + def initialize(klass); end + + def ===(actual); end + def description; end +end + +class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def description; end +end + +RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher) + +class RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def self.inherited(subklass); end +end + +class RSpec::Mocks::CallbackInvocationStrategy + def call(doubled_module); end +end + +class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError +end + +class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference + def with_signature; end + + def self.applies_to?(method_name); end +end + +class RSpec::Mocks::ClassVerifyingDouble < ::Module + include(::RSpec::Mocks::TestDouble) + include(::RSpec::Mocks::VerifyingDouble) + include(::RSpec::Mocks::ObjectVerifyingDoubleMethods) +end + +class RSpec::Mocks::Configuration + def initialize; end + + def add_stub_and_should_receive_to(*modules); end + def allow_message_expectations_on_nil; end + def allow_message_expectations_on_nil=(_); end + def before_verifying_doubles(&block); end + def color?; end + def patch_marshal_to_support_partial_doubles=(val); end + def reset_syntaxes_to_default; end + def syntax; end + def syntax=(*values); end + def temporarily_suppress_partial_double_verification; end + def temporarily_suppress_partial_double_verification=(_); end + def transfer_nested_constants=(_); end + def transfer_nested_constants?; end + def verify_doubled_constant_names=(_); end + def verify_doubled_constant_names?; end + def verify_partial_doubles=(val); end + def verify_partial_doubles?; end + def verifying_double_callbacks; end + def when_declaring_verifying_double(&block); end + def yield_receiver_to_any_instance_implementation_blocks=(_); end + def yield_receiver_to_any_instance_implementation_blocks?; end +end + +class RSpec::Mocks::Constant + extend(::RSpec::Support::RecursiveConstMethods) + + def initialize(name); end + + def hidden=(_); end + def hidden?; end + def inspect; end + def mutated?; end + def name; end + def original_value; end + def original_value=(_); end + def previously_defined=(_); end + def previously_defined?; end + def stubbed=(_); end + def stubbed?; end + def to_s; end + def valid_name=(_); end + def valid_name?; end + + def self.original(name); end + def self.unmutated(name); end +end + +class RSpec::Mocks::ConstantMutator + extend(::RSpec::Support::RecursiveConstMethods) + + def self.hide(constant_name); end + def self.mutate(mutator); end + def self.raise_on_invalid_const; end + def self.stub(constant_name, value, options = _); end +end + +class RSpec::Mocks::ConstantMutator::BaseMutator + include(::RSpec::Support::RecursiveConstMethods) + + def initialize(full_constant_name, mutated_value, transfer_nested_constants); end + + def full_constant_name; end + def idempotently_reset; end + def original_value; end + def to_constant; end +end + +class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator + def mutate; end + def reset; end + def to_constant; end +end + +class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator + def initialize(*args); end + + def mutate; end + def reset; end + def should_transfer_nested_constants?; end + def to_constant; end + def transfer_nested_constants; end + def verify_constants_to_transfer!; end +end + +class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator + def mutate; end + def reset; end + def to_constant; end + + private + + def name_for(parent, name); end +end + +RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy) + +class RSpec::Mocks::DirectObjectReference + def initialize(object); end + + def const_to_replace; end + def defined?; end + def description; end + def target; end + def when_loaded; end +end + +class RSpec::Mocks::Double + include(::RSpec::Mocks::TestDouble) +end + +class RSpec::Mocks::ErrorGenerator + def initialize(target = _); end + + def default_error_message(expectation, expected_args, actual_args); end + def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end + def expectation_on_nil_message(method_name); end + def intro(unwrapped = _); end + def method_call_args_description(args, generic_prefix = _, matcher_prefix = _); end + def opts; end + def opts=(_); end + def raise_already_invoked_error(message, calling_customization); end + def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end + def raise_double_negation_error(wrapped_expression); end + def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = _, source_id = _); end + def raise_expectation_on_mocked_method(method); end + def raise_expectation_on_nil_error(method_name); end + def raise_expectation_on_unstubbed_method(method); end + def raise_expired_test_double_error; end + def raise_have_received_disallowed(type, reason); end + def raise_invalid_arguments_error(verifier); end + def raise_method_not_stubbed_error(method_name); end + def raise_missing_block_error(args_to_yield); end + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + def raise_non_public_error(method_name, visibility); end + def raise_only_valid_on_a_partial_double(method); end + def raise_out_of_order_error(message); end + def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = _); end + def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = _); end + def raise_unexpected_message_error(message, args); end + def raise_unimplemented_error(doubled_module, method_name, object); end + def raise_verifying_double_not_defined_error(ref); end + def raise_wrong_arity_error(args_to_yield, signature); end + + private + + def __raise(message, backtrace_line = _, source_id = _); end + def arg_list(args); end + def count_message(count, expectation_count_type = _); end + def diff_message(expected_args, actual_args); end + def differ; end + def error_message(expectation, args_for_multiple_calls); end + def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end + def format_args(args); end + def format_received_args(args_for_multiple_calls); end + def group_count(index, args); end + def grouped_args(args); end + def list_of_exactly_one_string?(args); end + def notify(*args); end + def prepend_to_backtrace(exception, line); end + def received_part_of_expectation_error(actual_received_count, args); end + def times(count); end + def unexpected_arguments_message(expected_args_string, actual_args_string); end + def unpack_string_args(formatted_expected_args, actual_args); end +end + +module RSpec::Mocks::ExampleMethods + include(::RSpec::Mocks::ArgumentMatchers) + + include(::RSpec::Mocks::ExampleMethods::ExpectHost) + + def allow(target); end + def allow_any_instance_of(klass); end + def allow_message_expectations_on_nil; end + def class_double(doubled_class, *args); end + def class_spy(*args); end + def double(*args); end + def expect_any_instance_of(klass); end + def have_received(method_name, &block); end + def hide_const(constant_name); end + def instance_double(doubled_class, *args); end + def instance_spy(*args); end + def object_double(object_or_name, *args); end + def object_spy(*args); end + def receive(method_name, &block); end + def receive_message_chain(*messages, &block); end + def receive_messages(message_return_value_hash); end + def spy(*args); end + def stub_const(constant_name, value, options = _); end + def without_partial_double_verification; end + + def self.declare_double(type, *args); end + def self.declare_verifying_double(type, ref, *args); end + def self.extended(object); end + def self.included(klass); end +end + +module RSpec::Mocks::ExampleMethods::ExpectHost + def expect(target); end +end + +class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain + + private + + def expectation(object, message, &return_block); end + + def self.expect_chain_on(object, *chain, &blk); end +end + +class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase + include(::RSpec::Mocks::ExpectationTargetMethods) +end + +module RSpec::Mocks::ExpectationTargetMethods + include(::RSpec::Mocks::TargetDelegationInstanceMethods) + extend(::RSpec::Mocks::TargetDelegationClassMethods) + + def expression; end + def not_to(matcher, &block); end + def to(matcher, &block); end + def to_not(matcher, &block); end +end + +class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError +end + +RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String) + +class RSpec::Mocks::Implementation + def call(*args, &block); end + def initial_action; end + def initial_action=(_); end + def inner_action; end + def inner_action=(_); end + def present?; end + def terminal_action; end + def terminal_action=(_); end + + private + + def actions; end +end + +class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference + + private + + def find_method(mod); end + def method_defined?(mod); end + def method_implemented?(mod); end + def visibility_from(mod); end +end + +class RSpec::Mocks::InstanceMethodStasher + def initialize(object, method); end + + def handle_restoration_failures; end + def method_is_stashed?; end + def original_method; end + def restore; end + def stash; end + + private + + def method_defined_directly_on_klass?; end + def method_defined_on_klass?(klass = _); end + def method_owned_by_klass?; end +end + +class RSpec::Mocks::InstanceVerifyingDouble + include(::RSpec::Mocks::TestDouble) + include(::RSpec::Mocks::VerifyingDouble) + + def __build_mock_proxy(order_group); end +end + +class RSpec::Mocks::MarshalExtension + def self.patch!; end + def self.unpatch!; end +end + +module RSpec::Mocks::Matchers +end + +class RSpec::Mocks::Matchers::HaveReceived + include(::RSpec::Mocks::Matchers::Matcher) + + def initialize(method_name, &block); end + + def at_least(*args); end + def at_most(*args); end + def description; end + def does_not_match?(subject); end + def exactly(*args); end + def failure_message; end + def failure_message_when_negated; end + def matches?(subject, &block); end + def name; end + def once(*args); end + def ordered(*args); end + def setup_allowance(_subject, &_block); end + def setup_any_instance_allowance(_subject, &_block); end + def setup_any_instance_expectation(_subject, &_block); end + def setup_any_instance_negative_expectation(_subject, &_block); end + def setup_expectation(subject, &block); end + def setup_negative_expectation(subject, &block); end + def thrice(*args); end + def time(*args); end + def times(*args); end + def twice(*args); end + def with(*args); end + + private + + def apply_constraints_to(expectation); end + def capture_failure_message; end + def count_constraint; end + def disallow(type, reason = _); end + def ensure_count_unconstrained; end + def expect; end + def expected_messages_received_in_order?; end + def mock_proxy; end + def notify_failure_message; end +end + +RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array) + +RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array) + +RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array) + +module RSpec::Mocks::Matchers::Matcher +end + +class RSpec::Mocks::Matchers::Receive + include(::RSpec::Mocks::Matchers::Matcher) + + def initialize(message, block); end + + def and_call_original(*args, &block); end + def and_raise(*args, &block); end + def and_return(*args, &block); end + def and_throw(*args, &block); end + def and_wrap_original(*args, &block); end + def and_yield(*args, &block); end + def at_least(*args, &block); end + def at_most(*args, &block); end + def description; end + def does_not_match?(subject, &block); end + def exactly(*args, &block); end + def matches?(subject, &block); end + def name; end + def never(*args, &block); end + def once(*args, &block); end + def ordered(*args, &block); end + def setup_allowance(subject, &block); end + def setup_any_instance_allowance(subject, &block); end + def setup_any_instance_expectation(subject, &block); end + def setup_any_instance_negative_expectation(subject, &block); end + def setup_expectation(subject, &block); end + def setup_negative_expectation(subject, &block); end + def thrice(*args, &block); end + def time(*args, &block); end + def times(*args, &block); end + def twice(*args, &block); end + def with(*args, &block); end + + private + + def describable; end + def move_block_to_last_customization(block); end + def setup_any_instance_method_substitute(subject, method, block); end + def setup_method_substitute(host, method, block, *args); end + def setup_mock_proxy_method_substitute(subject, method, block); end + def warn_if_any_instance(expression, subject); end +end + +class RSpec::Mocks::Matchers::Receive::DefaultDescribable + def initialize(message); end + + def description_for(verb); end +end + +class RSpec::Mocks::Matchers::ReceiveMessageChain + include(::RSpec::Mocks::Matchers::Matcher) + + def initialize(chain, &block); end + + def and_call_original(*args, &block); end + def and_raise(*args, &block); end + def and_return(*args, &block); end + def and_throw(*args, &block); end + def and_yield(*args, &block); end + def description; end + def does_not_match?(*_args); end + def matches?(subject, &block); end + def name; end + def setup_allowance(subject, &block); end + def setup_any_instance_allowance(subject, &block); end + def setup_any_instance_expectation(subject, &block); end + def setup_expectation(subject, &block); end + def setup_negative_expectation(*_args); end + def with(*args, &block); end + + private + + def formatted_chain; end + def replay_customizations(chain); end +end + +class RSpec::Mocks::Matchers::ReceiveMessages + include(::RSpec::Mocks::Matchers::Matcher) + + def initialize(message_return_value_hash); end + + def description; end + def does_not_match?(_subject); end + def matches?(subject); end + def name; end + def setup_allowance(subject); end + def setup_any_instance_allowance(subject); end + def setup_any_instance_expectation(subject); end + def setup_expectation(subject); end + def setup_negative_expectation(_subject); end + def warn_about_block; end + + private + + def any_instance_of(subject); end + def each_message_on(host); end + def proxy_on(subject); end +end + +class RSpec::Mocks::MessageExpectation + include(::RSpec::Mocks::MessageExpectation::ImplementationDetails) + + def and_call_original; end + def and_raise(*args); end + def and_return(first_value, *values); end + def and_throw(*args); end + def and_wrap_original(&block); end + def and_yield(*args, &block); end + def at_least(n, &block); end + def at_most(n, &block); end + def exactly(n, &block); end + def inspect; end + def never; end + def once(&block); end + def ordered(&block); end + def thrice(&block); end + def time(&block); end + def times(&block); end + def to_s; end + def twice(&block); end + def with(*args, &block); end +end + +module RSpec::Mocks::MessageExpectation::ImplementationDetails + def initialize(error_generator, expectation_ordering, expected_from, method_double, type = _, opts = _, &implementation_block); end + + def actual_received_count_matters?; end + def additional_expected_calls; end + def advise(*args); end + def and_yield_receiver_to_implementation; end + def argument_list_matcher=(_); end + def called_max_times?; end + def description_for(verb); end + def ensure_expected_ordering_received!; end + def expectation_count_type; end + def expected_args; end + def expected_messages_received?; end + def generate_error; end + def ignoring_args?; end + def implementation; end + def increase_actual_received_count!; end + def invoke(parent_stub, *args, &block); end + def invoke_without_incrementing_received_count(parent_stub, *args, &block); end + def matches?(message, *args); end + def matches_at_least_count?; end + def matches_at_most_count?; end + def matches_exact_count?; end + def matches_name_but_not_args(message, *args); end + def message; end + def negative?; end + def negative_expectation_for?(message); end + def ordered?; end + def orig_object; end + def raise_out_of_order_error; end + def raise_unexpected_message_args_error(args_for_multiple_calls); end + def safe_invoke(parent_stub, *args, &block); end + def similar_messages; end + def type; end + def unadvise(args); end + def verify_messages_received; end + def yield_receiver_to_implementation_block?; end + + protected + + def error_generator; end + def error_generator=(_); end + def expected_from=(_); end + def expected_received_count=(_); end + def implementation=(_); end + + private + + def exception_source_id; end + def has_been_invoked?; end + def initial_implementation_action=(action); end + def inner_implementation_action=(action); end + def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end + def raise_already_invoked_error_if_necessary(calling_customization); end + def set_expected_received_count(relativity, n); end + def terminal_implementation_action=(action); end + def warn_about_stub_override; end + def wrap_original(method_name, &block); end +end + +class RSpec::Mocks::MethodDouble + def initialize(object, method_name, proxy); end + + def add_default_stub(*args, &implementation); end + def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end + def add_simple_expectation(method_name, response, error_generator, backtrace_line); end + def add_simple_stub(method_name, response); end + def add_stub(error_generator, expectation_ordering, expected_from, opts = _, &implementation); end + def build_expectation(error_generator, expectation_ordering); end + def clear; end + def configure_method; end + def define_proxy_method; end + def expectations; end + def message_expectation_class; end + def method_name; end + def method_stasher; end + def object; end + def object_singleton_class; end + def original_implementation_callable; end + def original_method; end + def proxy_method_invoked(_obj, *args, &block); end + def raise_method_not_stubbed_error; end + def remove_stub; end + def remove_stub_if_present; end + def reset; end + def restore_original_method; end + def restore_original_visibility; end + def save_original_implementation_callable!; end + def setup_simple_method_double(method_name, response, collection, error_generator = _, backtrace_line = _); end + def show_frozen_warning; end + def stubs; end + def verify; end + def visibility; end + + private + + def definition_target; end + def new_rspec_prepended_module; end + def remove_method_from_definition_target; end + def usable_rspec_prepended_module; end +end + +class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module +end + +class RSpec::Mocks::MethodReference + def initialize(object_reference, method_name); end + + def defined?; end + def implemented?; end + def unimplemented?; end + def visibility; end + def with_signature; end + + private + + def original_method; end + + def self.for(object_reference, method_name); end + def self.instance_method_visibility_for(klass, method_name); end + def self.method_defined_at_any_visibility?(klass, method_name); end + def self.method_visibility_for(object, method_name); end +end + +class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception +end + +class RSpec::Mocks::MockExpectationError < ::Exception +end + +class RSpec::Mocks::NamedObjectReference + def initialize(const_name); end + + def const_to_replace; end + def defined?; end + def description; end + def target; end + def when_loaded; end + + private + + def object; end +end + +class RSpec::Mocks::NegationUnsupportedError < ::StandardError +end + +class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space + def initialize(parent); end + + def constant_mutator_for(name); end + def proxies_of(klass); end + def registered?(object); end + + private + + def any_instance_recorder_not_found_for(id, klass); end + def proxy_not_found_for(id, object); end +end + +class RSpec::Mocks::NoCallbackInvocationStrategy + def call(_doubled_module); end +end + +class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference + + private + + def find_method(object); end + def method_defined?(object); end + def method_implemented?(object); end + def visibility_from(object); end + + def self.for(object_reference, method_name); end +end + +class RSpec::Mocks::ObjectReference + def self.for(object_module_or_name, allow_direct_object_refs = _); end +end + +RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +class RSpec::Mocks::ObjectVerifyingDouble + include(::RSpec::Mocks::TestDouble) + include(::RSpec::Mocks::VerifyingDouble) + include(::RSpec::Mocks::ObjectVerifyingDoubleMethods) +end + +module RSpec::Mocks::ObjectVerifyingDoubleMethods + include(::RSpec::Mocks::TestDouble) + include(::RSpec::Mocks::VerifyingDouble) + + def as_stubbed_const(options = _); end + + private + + def __build_mock_proxy(order_group); end +end + +class RSpec::Mocks::OrderGroup + def initialize; end + + def clear; end + def consume; end + def empty?; end + def handle_order_constraint(expectation); end + def invoked(message); end + def ready_for?(expectation); end + def register(expectation); end + def verify_invocation_order(expectation); end + + private + + def expectation_for(message); end + def expectations_invoked_in_order?; end + def expected_invocations; end + def invoked_expectations; end + def remaining_expectations; end +end + +class RSpec::Mocks::OutsideOfExampleError < ::StandardError +end + +class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy + include(::RSpec::Mocks::PartialClassDoubleProxyMethods) +end + +module RSpec::Mocks::PartialClassDoubleProxyMethods + def initialize(source_space, *args); end + + def original_method_handle_for(message); end + + protected + + def method_double_from_ancestor_for(message); end + def original_unbound_method_handle_from_ancestor_for(message); end + def superclass_proxy; end +end + +class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy + def add_simple_expectation(method_name, response, location); end + def add_simple_stub(method_name, response); end + def message_received(message, *args, &block); end + def original_method_handle_for(message); end + def reset; end + def visibility_for(method_name); end + + private + + def any_instance_class_recorder_observing_method?(klass, method_name); end +end + +class RSpec::Mocks::Proxy + def initialize(object, order_group, options = _); end + + def add_message_expectation(method_name, opts = _, &block); end + def add_simple_expectation(method_name, response, location); end + def add_simple_stub(method_name, response); end + def add_stub(method_name, opts = _, &implementation); end + def as_null_object; end + def build_expectation(method_name); end + def check_for_unexpected_arguments(expectation); end + def ensure_implemented(*_args); end + def has_negative_expectation?(message); end + def message_received(message, *args, &block); end + def messages_arg_list; end + def method_double_if_exists_for_message(message); end + def null_object?; end + def object; end + def original_method_handle_for(_message); end + def prepended_modules_of_singleton_class; end + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + def raise_unexpected_message_error(method_name, args); end + def received_message?(method_name, *args, &block); end + def record_message_received(message, *args, &block); end + def remove_stub(method_name); end + def remove_stub_if_present(method_name); end + def replay_received_message_on(expectation, &block); end + def reset; end + def verify; end + def visibility_for(_method_name); end + + private + + def find_almost_matching_expectation(method_name, *args); end + def find_almost_matching_stub(method_name, *args); end + def find_best_matching_expectation_for(method_name); end + def find_matching_expectation(method_name, *args); end + def find_matching_method_stub(method_name, *args); end + def method_double_for(message); end + + def self.prepended_modules_of(klass); end +end + +RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash) + +class RSpec::Mocks::Proxy::SpecificMessage < ::Struct + def ==(expectation); end + def args; end + def args=(_); end + def message; end + def message=(_); end + def object; end + def object=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy + def initialize(order_group); end + + def add_message_expectation(method_name, opts = _, &block); end + def add_stub(method_name, opts = _, &implementation); end + def disallow_expectations; end + def disallow_expectations=(_); end + def warn_about_expectations; end + def warn_about_expectations=(_); end + + private + + def raise_error(method_name); end + def set_expectation_behavior; end + def warn(method_name); end + def warn_or_raise!(method_name); end +end + +class RSpec::Mocks::RootSpace + def any_instance_proxy_for(*_args); end + def any_instance_recorder_for(*_args); end + def any_instance_recorders_from_ancestry_of(_object); end + def new_scope; end + def proxy_for(*_args); end + def register_constant_mutator(_mutator); end + def registered?(_object); end + def reset_all; end + def superclass_proxy_for(*_args); end + def verify_all; end + + private + + def raise_lifecycle_message; end +end + +class RSpec::Mocks::SimpleMessageExpectation + def initialize(message, response, error_generator, backtrace_line = _); end + + def called_max_times?; end + def invoke(*_); end + def matches?(message, *_); end + def unadvise(_); end + def verify_messages_received; end +end + +class RSpec::Mocks::Space + def initialize; end + + def any_instance_mutex; end + def any_instance_proxy_for(klass); end + def any_instance_recorder_for(klass, only_return_existing = _); end + def any_instance_recorders; end + def any_instance_recorders_from_ancestry_of(object); end + def constant_mutator_for(name); end + def ensure_registered(object); end + def new_scope; end + def proxies; end + def proxies_of(klass); end + def proxy_for(object); end + def proxy_mutex; end + def register_constant_mutator(mutator); end + def registered?(object); end + def reset_all; end + def superclass_proxy_for(klass); end + def verify_all; end + + private + + def any_instance_recorder_not_found_for(id, klass); end + def class_proxy_with_callback_verification_strategy(object, strategy); end + def id_for(object); end + def new_mutex; end + def proxy_not_found_for(id, object); end + def superclass_proxy_not_found_for(id, object); end +end + +class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain + + private + + def expectation(object, message, &return_block); end + + def self.stub_chain_on(object, *chain, &blk); end +end + +module RSpec::Mocks::Syntax + def self.default_should_syntax_host; end + def self.disable_expect(syntax_host = _); end + def self.disable_should(syntax_host = _); end + def self.enable_expect(syntax_host = _); end + def self.enable_should(syntax_host = _); end + def self.expect_enabled?(syntax_host = _); end + def self.should_enabled?(syntax_host = _); end + def self.warn_about_should!; end + def self.warn_unless_should_configured(method_name, replacement = _); end +end + +class RSpec::Mocks::TargetBase + include(::RSpec::Mocks::TargetDelegationInstanceMethods) + extend(::RSpec::Mocks::TargetDelegationClassMethods) + + def initialize(target); end +end + +module RSpec::Mocks::TargetDelegationClassMethods + def delegate_not_to(matcher_method, options = _); end + def delegate_to(matcher_method); end + def disallow_negation(method_name); end +end + +module RSpec::Mocks::TargetDelegationInstanceMethods + def target; end + + private + + def define_matcher(matcher, name, &block); end + def matcher_allowed?(matcher); end + def raise_negation_unsupported(method_name, matcher); end + def raise_unsupported_matcher(method_name, matcher); end +end + +module RSpec::Mocks::TestDouble + def initialize(name = _, stubs = _); end + + def ==(other); end + def __build_mock_proxy_unless_expired(order_group); end + def __disallow_further_usage!; end + def as_null_object; end + def freeze; end + def inspect; end + def null_object?; end + def respond_to?(message, incl_private = _); end + def to_s; end + + private + + def __build_mock_proxy(order_group); end + def __mock_proxy; end + def __raise_expired_error; end + def assign_stubs(stubs); end + def initialize_copy(other); end + def method_missing(message, *args, &block); end +end + +module RSpec::Mocks::TestDoubleFormatter + def self.format(dbl, unwrap = _); end +end + +class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy + def reset; end +end + +class RSpec::Mocks::UnsupportedMatcherError < ::StandardError +end + +module RSpec::Mocks::VerifyingDouble + def initialize(doubled_module, *args); end + + def __send__(name, *args, &block); end + def method_missing(message, *args, &block); end + def respond_to?(message, include_private = _); end + def send(name, *args, &block); end +end + +module RSpec::Mocks::VerifyingDouble::SilentIO + def self.method_missing(*_); end + def self.respond_to?(*_); end +end + +class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError +end + +class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble + def with_signature; end +end + +class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble + def initialize(object, method_name, proxy); end + + def unimplemented?; end + def with_signature; end + + def self.for(object, method_name, proxy); end +end + +class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation + def initialize(*args); end + + def method_reference; end + def method_reference=(_); end + def with(*args, &block); end + + private + + def validate_expected_arguments!; end +end + +class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble + def initialize(object, method_name, proxy, method_reference); end + + def add_expectation(*args, &block); end + def add_stub(*args, &block); end + def message_expectation_class; end + def proxy_method_invoked(obj, *args, &block); end + def validate_arguments!(actual_args); end +end + +class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy + include(::RSpec::Mocks::PartialClassDoubleProxyMethods) +end + +class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy + include(::RSpec::Mocks::VerifyingProxyMethods) + + def initialize(object, expectation_ordering, optional_callback_invocation_strategy = _); end + + def ensure_implemented(_method_name); end + def method_reference; end +end + +class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy + include(::RSpec::Mocks::VerifyingProxyMethods) + + def initialize(object, order_group, doubled_module, method_reference_class); end + + def method_reference; end + def validate_arguments!(method_name, args); end + def visibility_for(method_name); end +end + +module RSpec::Mocks::VerifyingProxyMethods + def add_message_expectation(method_name, opts = _, &block); end + def add_simple_stub(method_name, *args); end + def add_stub(method_name, opts = _, &implementation); end + def ensure_implemented(method_name); end + def ensure_publicly_implemented(method_name, _object); end +end + +module RSpec::Mocks::Version +end + +RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String) + +class RSpec::Mocks::Matchers::ExpectationCustomization + def initialize(method_name, args, block); end + + def block; end + def block=(_); end + def playback_onto(expectation); end +end + +class RSpec::Mocks::MessageChain + def initialize(object, *chain, &blk); end + + def block; end + def chain; end + def object; end + def setup_chain; end + + private + + def chain_on(object, *chain, &block); end + def find_matching_expectation; end + def find_matching_stub; end + def format_chain(*chain, &blk); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi new file mode 100644 index 0000000000..74efb9a0b7 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi @@ -0,0 +1,470 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RSpec + extend(::RSpec::Support::Warnings) + extend(::RSpec::Core::Warnings) + + def self.clear_examples; end + def self.configuration; end + def self.configuration=(_); end + def self.configure; end + def self.const_missing(name); end + def self.context(*args, &example_group_block); end + def self.current_example; end + def self.current_example=(example); end + def self.describe(*args, &example_group_block); end + def self.example_group(*args, &example_group_block); end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.reset; end + def self.shared_context(name, *args, &block); end + def self.shared_examples(name, *args, &block); end + def self.shared_examples_for(name, *args, &block); end + def self.world; end + def self.world=(_); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end +end + +class RSpec::CallerFilter + def self.first_non_rspec_line(skip_frames = _, increment = _); end +end + +RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array) + +RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp) + +RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp) + +RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array) + +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Support + def self.class_of(object); end + def self.define_optimized_require_for_rspec(lib, &require_relative); end + def self.deregister_matcher_definition(&block); end + def self.failure_notifier; end + def self.failure_notifier=(callable); end + def self.is_a_matcher?(object); end + def self.matcher_definitions; end + def self.method_handle_for(object, method_name); end + def self.notify_failure(failure, options = _); end + def self.register_matcher_definition(&block); end + def self.require_rspec_core(f); end + def self.require_rspec_expectations(f); end + def self.require_rspec_matchers(f); end + def self.require_rspec_mocks(f); end + def self.require_rspec_support(f); end + def self.rspec_description_for_object(object); end + def self.thread_local_data; end + def self.warning_notifier; end + def self.warning_notifier=(_); end + def self.with_failure_notifier(callable); end +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + def self.===(exception); end +end + +RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array) + +class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature + def classify_parameters; end +end + +class RSpec::Support::ComparableVersion + include(::Comparable) + + def initialize(string); end + + def <=>(other); end + def segments; end + def string; end +end + +RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc) + +RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc) + +class RSpec::Support::Differ + def initialize(opts = _); end + + def color?; end + def diff(actual, expected); end + def diff_as_object(actual, expected); end + def diff_as_string(actual, expected); end + + private + + def add_old_hunk_to_hunk(hunk, oldhunk); end + def add_to_output(output, string); end + def all_strings?(*args); end + def any_multiline_strings?(*args); end + def blue(text); end + def build_hunks(actual, expected); end + def coerce_to_string(string_or_array); end + def color(text, color_code); end + def color_diff(diff); end + def diffably_stringify(array); end + def finalize_output(output, final_line); end + def format_type; end + def green(text); end + def handle_encoding_errors(actual, expected); end + def hash_to_string(hash); end + def multiline?(string); end + def no_numbers?(*args); end + def no_procs?(*args); end + def normal(text); end + def object_to_string(object); end + def red(text); end + def safely_flatten(array); end +end + +class RSpec::Support::DirectoryMaker + def self.mkdir_p(path); end +end + +class RSpec::Support::EncodedString + def initialize(string, encoding = _); end + + def <<(string); end + def ==(*args, &block); end + def empty?(*args, &block); end + def encoding(*args, &block); end + def eql?(*args, &block); end + def lines(*args, &block); end + def source_encoding; end + def split(regex_or_string); end + def to_s; end + def to_str; end + + private + + def detect_source_encoding(string); end + def matching_encoding(string); end + def remove_invalid_bytes(string); end + + def self.pick_encoding(source_a, source_b); end +end + +RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String) + +RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String) + +RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String) + +module RSpec::Support::FuzzyMatcher + def self.values_match?(expected, actual); end +end + +RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier + + private + + def split_args(*args); end +end + +class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher + def initialize(signature); end + + def has_kw_args_in?(args); end + def invalid_kw_args_from(_kw_args); end + def missing_kw_args_from(_kw_args); end + def non_kw_args_arity_description; end + def valid_non_kw_args?(*args); end +end + +class RSpec::Support::MethodSignature + def initialize(method); end + + def arbitrary_kw_args?; end + def classify_arity(arity = _); end + def classify_parameters; end + def could_contain_kw_args?(args); end + def description; end + def has_kw_args_in?(args); end + def invalid_kw_args_from(given_kw_args); end + def max_non_kw_args; end + def min_non_kw_args; end + def missing_kw_args_from(given_kw_args); end + def non_kw_args_arity_description; end + def optional_kw_args; end + def required_kw_args; end + def unlimited_args?; end + def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = _); end +end + +RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float) + +class RSpec::Support::MethodSignatureExpectation + def initialize; end + + def empty?; end + def expect_arbitrary_keywords; end + def expect_arbitrary_keywords=(_); end + def expect_unlimited_arguments; end + def expect_unlimited_arguments=(_); end + def keywords; end + def keywords=(values); end + def max_count; end + def max_count=(number); end + def min_count; end + def min_count=(number); end +end + +class RSpec::Support::MethodSignatureVerifier + def initialize(signature, args = _); end + + def error_message; end + def kw_args; end + def max_non_kw_args; end + def min_non_kw_args; end + def non_kw_args; end + def valid?; end + def with_expectation(expectation); end + + private + + def arbitrary_kw_args?; end + def invalid_kw_args; end + def missing_kw_args; end + def split_args(*args); end + def unlimited_args?; end + def valid_non_kw_args?; end +end + +class RSpec::Support::Mutex < ::Thread::Mutex + def self.new; end +end + +RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method) + +module RSpec::Support::OS + + private + + def windows?; end + def windows_file_path?; end + + def self.windows?; end + def self.windows_file_path?; end +end + +class RSpec::Support::ObjectFormatter + def initialize(max_formatted_output_length = _); end + + def format(object); end + def max_formatted_output_length; end + def max_formatted_output_length=(_); end + def prepare_array(array); end + def prepare_element(element); end + def prepare_for_inspection(object); end + def prepare_hash(input_hash); end + def recursive_structure?(object); end + def sort_hash_keys(input_hash); end + def with_entering_structure(structure); end + + private + + def truncate_string(str, start_index, end_index); end + + def self.default_instance; end + def self.format(object); end + def self.prepare_for_inspection(object); end +end + +class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct + def formatter; end + def formatter=(_); end + def inspect; end + def object; end + def object=(_); end + def pretty_print(pp); end + + def self.[](*_); end + def self.can_inspect?(_object); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String) + +class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String) + +RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array) + +class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct + def inspect; end + def pretty_print(pp); end + def text; end + def text=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + + def self.can_inspect?(object); end +end + +RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String) + +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + def inspect; end + def klass; end + def native_object_id; end + + def self.can_inspect?(object); end +end + +RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String) + +module RSpec::Support::RecursiveConstMethods + def const_defined_on?(mod, const_name); end + def constants_defined_on(mod); end + def get_const_defined_on(mod, const_name); end + def normalize_const_name(const_name); end + def recursive_const_defined?(const_name); end + def recursive_const_get(const_name); end +end + +class RSpec::Support::ReentrantMutex + def initialize; end + + def synchronize; end + + private + + def enter; end + def exit; end +end + +module RSpec::Support::Ruby + + private + + def jruby?; end + def jruby_9000?; end + def jruby_version; end + def mri?; end + def non_mri?; end + def rbx?; end + def truffleruby?; end + + def self.jruby?; end + def self.jruby_9000?; end + def self.jruby_version; end + def self.mri?; end + def self.non_mri?; end + def self.rbx?; end + def self.truffleruby?; end +end + +module RSpec::Support::RubyFeatures + + private + + def caller_locations_supported?; end + def fork_supported?; end + def kw_args_supported?; end + def module_prepends_supported?; end + def module_refinement_supported?; end + def optional_and_splat_args_supported?; end + def required_kw_args_supported?; end + def ripper_supported?; end + def supports_exception_cause?; end + def supports_rebinding_module_methods?; end + def supports_taint?; end + + def self.caller_locations_supported?; end + def self.fork_supported?; end + def self.kw_args_supported?; end + def self.module_prepends_supported?; end + def self.module_refinement_supported?; end + def self.optional_and_splat_args_supported?; end + def self.required_kw_args_supported?; end + def self.ripper_supported?; end + def self.supports_exception_cause?; end + def self.supports_rebinding_module_methods?; end + def self.supports_taint?; end +end + +RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier + +module RSpec::Support::Version +end + +RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String) + +module RSpec::Support::Warnings + def deprecate(deprecated, options = _); end + def warn_deprecation(message, options = _); end + def warn_with(message, options = _); end + def warning(text, options = _); end +end + +module RSpec::Support::WithKeywordsWhenNeeded + + private + + def class_exec(klass, *args, &block); end + + def self.class_exec(klass, *args, &block); end +end + +class RSpec::Support::HunkGenerator + def initialize(actual, expected); end + + def hunks; end + + private + + def actual_lines; end + def build_hunk(piece); end + def context_lines; end + def diffs; end + def expected_lines; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi new file mode 100644 index 0000000000..45d159360b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi @@ -0,0 +1,39 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RSpec + extend(::RSpec::Support::Warnings) + extend(::RSpec::Core::Warnings) + + def self.clear_examples; end + def self.configuration; end + def self.configuration=(_); end + def self.configure; end + def self.const_missing(name); end + def self.context(*args, &example_group_block); end + def self.current_example; end + def self.current_example=(example); end + def self.describe(*args, &example_group_block); end + def self.example_group(*args, &example_group_block); end + def self.fcontext(*args, &example_group_block); end + def self.fdescribe(*args, &example_group_block); end + def self.reset; end + def self.shared_context(name, *args, &block); end + def self.shared_examples(name, *args, &block); end + def self.shared_examples_for(name, *args, &block); end + def self.world; end + def self.world=(_); end + def self.xcontext(*args, &example_group_block); end + def self.xdescribe(*args, &example_group_block); end +end + +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Version +end + +RSpec::Version::STRING = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.0.3.rbi new file mode 100644 index 0000000000..b5fdd557fe --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@0.0.3.rbi @@ -0,0 +1,1142 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RuboCop +end + +module RuboCop::AST +end + +class RuboCop::AST::AliasNode < ::RuboCop::AST::Node + def new_identifier; end + def old_identifier; end +end + +class RuboCop::AST::AndNode < ::RuboCop::AST::Node + include(::RuboCop::AST::BinaryOperatorNode) + include(::RuboCop::AST::PredicateOperatorNode) + + def alternate_operator; end + def inverse_operator; end +end + +class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node + include(::RuboCop::AST::CollectionNode) + + def empty_and_without_delimiters?; end +end + +class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node + def bracketed?; end + def each_value(&block); end + def percent_literal?(type = _); end + def square_brackets?; end + def values; end +end + +RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash) + +module RuboCop::AST::BasicLiteralNode + def value; end +end + +module RuboCop::AST::BinaryOperatorNode + def conditions; end + def lhs; end + def rhs; end +end + +class RuboCop::AST::BlockNode < ::RuboCop::AST::Node + include(::RuboCop::AST::MethodIdentifierPredicates) + + def arguments; end + def arguments?; end + def body; end + def braces?; end + def closing_delimiter; end + def delimiters; end + def keywords?; end + def lambda?; end + def method_name; end + def multiline?; end + def opening_delimiter; end + def send_node; end + def single_line?; end + def void_context?; end +end + +RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array) + +class RuboCop::AST::BreakNode < ::RuboCop::AST::Node + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + include(::RuboCop::AST::ParameterizedNode) + + def arguments; end +end + +class RuboCop::AST::Builder < ::Parser::Builders::Default + def n(type, children, source_map); end + def string_value(token); end + + private + + def node_klass(type); end +end + +RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash) + +class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ConditionalNode) + + def each_in_pattern; end + def else?; end + def else_branch; end + def in_pattern_branches; end + def keyword; end +end + +class RuboCop::AST::CaseNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ConditionalNode) + + def each_when; end + def else?; end + def else_branch; end + def keyword; end + def when_branches; end +end + +class RuboCop::AST::ClassNode < ::RuboCop::AST::Node + def body; end + def identifier; end + def parent_class; end +end + +module RuboCop::AST::CollectionNode + extend(::Forwardable) + + def &(*args, &block); end + def *(*args, &block); end + def +(*args, &block); end + def -(*args, &block); end + def <<(*args, &block); end + def [](*args, &block); end + def []=(*args, &block); 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 chain(*args, &block); end + def chunk(*args, &block); end + def chunk_while(*args, &block); end + def clear(*args, &block); 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 difference(*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 empty?(*args, &block); end + def entries(*args, &block); end + def fetch(*args, &block); end + def fill(*args, &block); end + def filter(*args, &block); end + def filter!(*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 grep(*args, &block); end + def grep_v(*args, &block); end + def group_by(*args, &block); end + def include?(*args, &block); end + def index(*args, &block); end + def inject(*args, &block); end + def insert(*args, &block); end + def join(*args, &block); end + def keep_if(*args, &block); end + def last(*args, &block); end + def lazy(*args, &block); end + def length(*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(*args, &block); end + def permutation(*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 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 select(*args, &block); end + def select!(*args, &block); 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 sum(*args, &block); end + def take(*args, &block); end + def take_while(*args, &block); end + def to_ary(*args, &block); end + def to_h(*args, &block); end + def to_set(*args, &block); end + def transpose(*args, &block); end + def union(*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 zip(*args, &block); end + def |(*args, &block); end +end + +RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array) + +module RuboCop::AST::ConditionalNode + def body; end + def condition; end + def multiline_condition?; end + def single_line_condition?; end +end + +class RuboCop::AST::DefNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ParameterizedNode) + include(::RuboCop::AST::MethodIdentifierPredicates) + + def argument_forwarding?; end + def arguments; end + def body; end + def method_name; end + def node_parts; end + def receiver; end + def void_context?; end +end + +class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ParameterizedNode) + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + + def node_parts; end +end + +class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node + def body; end +end + +class RuboCop::AST::FloatNode < ::RuboCop::AST::Node + include(::RuboCop::AST::NumericNode) +end + +class RuboCop::AST::ForNode < ::RuboCop::AST::Node + def body; end + def collection; end + def do?; end + def keyword; end + def variable; end + def void_context?; end +end + +class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node + include(::RuboCop::AST::CollectionNode) + + def to_a; end +end + +module RuboCop::AST::HashElementNode + def delimiter_delta(other); end + def key; end + def key_delta(other, alignment = _); end + def same_line?(other); end + def value; end + def value_delta(other); end +end + +class RuboCop::AST::HashNode < ::RuboCop::AST::Node + def braces?; end + def each_key; end + def each_pair; end + def each_value; end + def empty?; end + def keys; end + def mixed_delimiters?; end + def pairs; end + def pairs_on_same_line?; end + def values; end +end + +class RuboCop::AST::IfNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ConditionalNode) + include(::RuboCop::AST::ModifierNode) + + def branches; end + def each_branch; end + def else?; end + def else_branch; end + def elsif?; end + def elsif_conditional?; end + def if?; end + def if_branch; end + def inverse_keyword; end + def keyword; end + def modifier_form?; end + def nested_conditional?; end + def node_parts; end + def ternary?; end + def unless?; end +end + +class RuboCop::AST::IntNode < ::RuboCop::AST::Node + include(::RuboCop::AST::NumericNode) +end + +class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node + include(::RuboCop::AST::HashElementNode) + + def colon?; end + def hash_rocket?; end + def node_parts; end + def operator; end +end + +RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String) + +module RuboCop::AST::MethodDispatchNode + include(::RuboCop::AST::MethodIdentifierPredicates) + extend(::RuboCop::AST::NodePattern::Macros) + + def access_modifier?; end + def adjacent_def_modifier?(node = _); end + def arguments; end + def arithmetic_operation?; end + def assignment?; end + def bare_access_modifier?; end + def bare_access_modifier_declaration?(node = _); end + def binary_operation?; end + def block_literal?; end + def block_node; end + def command?(name); end + def const_receiver?; end + def def_modifier?; end + def dot?; end + def double_colon?; end + def implicit_call?; end + def lambda?; end + def lambda_literal?; end + def macro?; end + def macro_scope?(node = _); end + def method_name; end + def non_bare_access_modifier?; end + def non_bare_access_modifier_declaration?(node = _); end + def receiver; end + def safe_navigation?; end + def self_receiver?; end + def setter_method?; end + def special_modifier?; end + def unary_operation?; end + + private + + def macro_kwbegin_wrapper?(parent); end + def root_node?(node); end +end + +RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array) + +module RuboCop::AST::MethodIdentifierPredicates + def assignment_method?; end + def bang_method?; end + def camel_case_method?; end + def comparison_method?; end + def const_receiver?; end + def enumerator_method?; end + def method?(name); end + def negation_method?; end + def operator_method?; end + def predicate_method?; end + def prefix_bang?; end + def prefix_not?; end + def self_receiver?; end +end + +RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Array) + +module RuboCop::AST::ModifierNode + def modifier_form?; end +end + +class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node + def body; end + def identifier; end +end + +class RuboCop::AST::Node < ::Parser::AST::Node + include(::RuboCop::AST::Sexp) + include(::RuboCop::RSpec::Node) + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(type, children = _, properties = _); end + + def __ENCODING___type?; end + def __FILE___type?; end + def __LINE___type?; end + def alias_type?; end + def ancestors; end + def and_asgn_type?; end + def and_type?; end + def arg_expr_type?; end + def arg_type?; end + def args_type?; end + def argument?; end + def array_pattern_type?; end + def array_pattern_with_tail_type?; end + def array_type?; end + def assignment?; end + def assignment_or_similar?(node = _); end + def back_ref_type?; end + def basic_conditional?; end + def basic_literal?; end + def begin_type?; end + def block_pass_type?; end + def block_type?; end + def blockarg_expr_type?; end + def blockarg_type?; end + def boolean_type?; end + def break_type?; end + def call_type?; end + def case_match_type?; end + def case_type?; end + def casgn_type?; end + def cbase_type?; end + def chained?; end + def child_nodes; end + def class_constructor?(node = _); end + def class_type?; end + def complete!; end + def complete?; end + def complex_type?; end + def conditional?; end + def const_name; end + def const_pattern_type?; end + def const_type?; end + def csend_type?; end + def cvar_type?; end + def cvasgn_type?; end + def def_e_type?; end + def def_type?; end + def defined_module; end + def defined_module_name; end + def defined_type?; end + def defs_e_type?; end + def defs_type?; end + def descendants; end + def dstr_type?; end + def dsym_type?; end + def each_ancestor(*types, &block); end + def each_child_node(*types); end + def each_descendant(*types, &block); end + def each_node(*types, &block); end + def eflipflop_type?; end + def empty_else_type?; end + def empty_source?; end + def ensure_type?; end + def equals_asgn?; end + def erange_type?; end + def false_type?; end + def falsey_literal?; end + def first_line; end + def float_type?; end + def for_type?; end + def forward_args_type?; end + def forwarded_args_type?; end + def guard_clause?; end + def gvar_type?; end + def gvasgn_type?; end + def hash_pattern_type?; end + def hash_type?; end + def ident_type?; end + def if_guard_type?; end + def if_type?; end + def iflipflop_type?; end + def immutable_literal?; end + def in_match_type?; end + def in_pattern_type?; end + def index_type?; end + def indexasgn_type?; end + def int_type?; end + def irange_type?; end + def ivar_type?; end + def ivasgn_type?; end + def keyword?; end + def kwarg_type?; end + def kwbegin_type?; end + def kwnilarg_type?; end + def kwoptarg_type?; end + def kwrestarg_type?; end + def kwsplat_type?; end + def lambda?(node = _); end + def lambda_or_proc?(node = _); end + def lambda_type?; end + def last_line; end + def line_count; end + def literal?; end + def lvar_type?; end + def lvasgn_type?; end + def masgn_type?; end + def match_alt_type?; end + def match_as_type?; end + def match_current_line_type?; end + def match_guard_clause?(node = _); end + def match_nil_pattern_type?; end + def match_rest_type?; end + def match_var_type?; end + def match_with_lvasgn_type?; end + def match_with_trailing_comma_type?; end + def mlhs_type?; end + def module_type?; end + def mrasgn_type?; end + def multiline?; end + def mutable_literal?; end + def new_class_or_module_block?(node = _); end + def next_type?; end + def nil_type?; end + def node_parts; end + def nonempty_line_count; end + def not_type?; end + def nth_ref_type?; end + def numargs_type?; end + def numblock_type?; end + def numeric_type?; end + def objc_kwarg_type?; end + def objc_restarg_type?; end + def objc_varargs_type?; end + def op_asgn_type?; end + def operator_keyword?; end + def optarg_type?; end + def or_asgn_type?; end + def or_type?; end + def pair_type?; end + def parent; end + def parent_module_name; end + def parenthesized_call?; end + def pin_type?; end + def postexe_type?; end + def preexe_type?; end + def proc?(node = _); end + def procarg0_type?; end + def pure?; end + def range_type?; end + def rasgn_type?; end + def rational_type?; end + def receiver(node = _); end + def recursive_basic_literal?; end + def recursive_literal?; end + def redo_type?; end + def reference?; end + def regexp_type?; end + def regopt_type?; end + def resbody_type?; end + def rescue_type?; end + def restarg_expr_type?; end + def restarg_type?; end + def retry_type?; end + def return_type?; end + def root_type?; end + def sclass_type?; end + def self_type?; end + def send_type?; end + def shadowarg_type?; end + def shorthand_asgn?; end + def sibling_index; end + def single_line?; end + def source; end + def source_length; end + def source_range; end + def special_keyword?; end + def splat_type?; end + def str_content(node = _); end + def str_type?; end + def super_type?; end + def sym_type?; end + def true_type?; end + def truthy_literal?; end + def undef_type?; end + def unless_guard_type?; end + def until_post_type?; end + def until_type?; end + def updated(type = _, children = _, properties = _); end + def value_used?; end + def variable?; end + def when_type?; end + def while_post_type?; end + def while_type?; end + def xstr_type?; end + def yield_type?; end + def zsuper_type?; end + + protected + + def parent=(node); end + def visit_descendants(types, &block); end + + private + + def begin_value_used?; end + def case_if_value_used?; end + def defined_module0(node = _); end + def for_value_used?; end + def parent_module_name_for_block(ancestor); end + def parent_module_name_for_sclass(sclass_node); end + def parent_module_name_part(node); end + def visit_ancestors(types); end + def while_until_value_used?; end +end + +RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Array) + +class RuboCop::AST::NodePattern + def initialize(str); end + + def ==(other); end + def eql?(other); end + def marshal_dump; end + def marshal_load(pattern); end + def match(*args); end + def pattern; end + def to_s; end + + def self.descend(element, &block); end +end + +class RuboCop::AST::NodePattern::Invalid < ::StandardError +end + +module RuboCop::AST::NodePattern::Macros + def def_node_matcher(method_name, pattern_str); end + def def_node_search(method_name, pattern_str); end + def node_search(method_name, compiler, on_match, prelude, called_from); end + def node_search_all(method_name, compiler, called_from); end + def node_search_body(method_name, trailing_params, prelude, match_code, on_match); end + def node_search_first(method_name, compiler, called_from); end +end + +module RuboCop::AST::NumericNode + def sign?; end +end + +RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp) + +class RuboCop::AST::OrNode < ::RuboCop::AST::Node + include(::RuboCop::AST::BinaryOperatorNode) + include(::RuboCop::AST::PredicateOperatorNode) + + def alternate_operator; end + def inverse_operator; end +end + +class RuboCop::AST::PairNode < ::RuboCop::AST::Node + include(::RuboCop::AST::HashElementNode) + + def colon?; end + def delimiter(with_spacing = _); end + def hash_rocket?; end + def inverse_delimiter(with_spacing = _); end + def value_on_new_line?; end +end + +RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String) + +RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String) + +RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String) + +RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String) + +module RuboCop::AST::ParameterizedNode + def arguments?; end + def block_argument?; end + def first_argument; end + def last_argument; end + def parenthesized?; end + def rest_argument?; end + def splat_argument?; end +end + +module RuboCop::AST::PredicateOperatorNode + def logical_operator?; end + def operator; end + def semantic_operator?; end +end + +RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String) + +RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String) + +RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String) + +RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String) + +class RuboCop::AST::ProcessedSource + include(::RuboCop::Ext::ProcessedSource) + + def initialize(source, ruby_version, path = _); end + + def [](*args); end + def ast; end + def ast_with_comments; end + def blank?; end + def buffer; end + def checksum; end + def commented?(source_range); end + def comments; end + def comments_before_line(line); end + def current_line(token); end + def diagnostics; end + def each_comment; end + def each_token; end + def file_path; end + def find_comment; end + def find_token; end + def following_line(token); end + def line_indentation(line_number); end + def lines; end + def parser_error; end + def path; end + def preceding_line(token); end + def raw_source; end + def ruby_version; end + def start_with?(string); end + def tokens; end + def valid_syntax?; end + + private + + def comment_lines; end + def create_parser(ruby_version); end + def parse(source, ruby_version); end + def parser_class(ruby_version); end + def tokenize(parser); end + + def self.from_file(path, ruby_version); end +end + +RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String) + +class RuboCop::AST::RangeNode < ::RuboCop::AST::Node + def begin; end + def end; end +end + +class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node + def content; end + def regopt; end + def to_regexp; end +end + +RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash) + +class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node + def body; end + def exception_variable; end +end + +class RuboCop::AST::RetryNode < ::RuboCop::AST::Node + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + include(::RuboCop::AST::ParameterizedNode) + + def arguments; end +end + +class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + include(::RuboCop::AST::ParameterizedNode) + + def arguments; end +end + +class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node + def body; end + def identifier; end +end + +class RuboCop::AST::SendNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ParameterizedNode) + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + + def attribute_accessor?(node = _); end +end + +module RuboCop::AST::Sexp + def s(type, *children); end +end + +class RuboCop::AST::StrNode < ::RuboCop::AST::Node + include(::RuboCop::AST::BasicLiteralNode) + + def heredoc?; end +end + +class RuboCop::AST::SuperNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ParameterizedNode) + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + + def node_parts; end +end + +class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node + include(::RuboCop::AST::BasicLiteralNode) +end + +class RuboCop::AST::Token + def initialize(pos, type, text); end + + def begin_pos; end + def column; end + def comma?; end + def comment?; end + def end?; end + def end_pos; end + def equal_sign?; end + def left_array_bracket?; end + def left_brace?; end + def left_bracket?; end + def left_curly_brace?; end + def left_parens?; end + def left_ref_bracket?; end + def line; end + def pos; end + def rescue_modifier?; end + def right_bracket?; end + def right_curly_brace?; end + def right_parens?; end + def semicolon?; end + def space_after?; end + def space_before?; end + def text; end + def to_s; end + def type; end + + def self.from_parser_token(parser_token); end +end + +module RuboCop::AST::Traversal + def on_alias(node); end + def on_and(node); end + def on_and_asgn(node); end + def on_arg(node); end + def on_arg_expr(node); end + def on_args(node); end + def on_array(node); end + def on_array_pattern(node); end + def on_array_pattern_with_tail(node); end + def on_back_ref(node); end + def on_begin(node); end + def on_block(node); end + def on_block_pass(node); end + def on_blockarg(node); end + def on_break(node); end + def on_case(node); end + def on_case_match(node); end + def on_casgn(node); end + def on_cbase(node); end + def on_class(node); end + def on_complex(node); end + def on_const(node); end + def on_const_pattern(node); end + def on_csend(node); end + def on_cvar(node); end + def on_cvasgn(node); end + def on_def(node); end + def on_defined?(node); end + def on_defs(node); end + def on_dstr(node); end + def on_dsym(node); end + def on_eflipflop(node); end + def on_empty_else(node); end + def on_ensure(node); end + def on_erange(node); end + def on_false(node); end + def on_float(node); end + def on_for(node); end + def on_forward_args(node); end + def on_forwarded_args(node); end + def on_gvar(node); end + def on_gvasgn(node); end + def on_hash(node); end + def on_hash_pattern(node); end + def on_if(node); end + def on_if_guard(node); end + def on_iflipflop(node); end + def on_in_match(node); end + def on_in_pattern(node); end + def on_int(node); end + def on_irange(node); end + def on_ivar(node); end + def on_ivasgn(node); end + def on_kwarg(node); end + def on_kwbegin(node); end + def on_kwoptarg(node); end + def on_kwrestarg(node); end + def on_kwsplat(node); end + def on_lambda(node); end + def on_lvar(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_match_alt(node); end + def on_match_as(node); end + def on_match_current_line(node); end + def on_match_nil_pattern(node); end + def on_match_rest(node); end + def on_match_var(node); end + def on_match_with_lvasgn(node); end + def on_match_with_trailing_comma(node); end + def on_mlhs(node); end + def on_module(node); end + def on_next(node); end + def on_nil(node); end + def on_not(node); end + def on_nth_ref(node); end + def on_numblock(node); end + def on_op_asgn(node); end + def on_optarg(node); end + def on_or(node); end + def on_or_asgn(node); end + def on_pair(node); end + def on_pin(node); end + def on_postexe(node); end + def on_preexe(node); end + def on_rational(node); end + def on_redo(node); end + def on_regexp(node); end + def on_regopt(node); end + def on_resbody(node); end + def on_rescue(node); end + def on_restarg(node); end + def on_retry(node); end + def on_return(node); end + def on_sclass(node); end + def on_self(node); end + def on_send(node); end + def on_shadowarg(node); end + def on_splat(node); end + def on_str(node); end + def on_super(node); end + def on_sym(node); end + def on_true(node); end + def on_undef(node); end + def on_unless_guard(node); end + def on_until(node); end + def on_until_post(node); end + def on_when(node); end + def on_while(node); end + def on_while_post(node); end + def on_xstr(node); end + def on_yield(node); end + def on_zsuper(node); end + def walk(node); end +end + +RuboCop::AST::Traversal::MANY_CHILD_NODES = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Traversal::ONE_CHILD_NODE = T.let(T.unsafe(nil), Array) + +RuboCop::AST::Traversal::SECOND_CHILD_ONLY = T.let(T.unsafe(nil), Array) + +class RuboCop::AST::UntilNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ConditionalNode) + include(::RuboCop::AST::ModifierNode) + + def do?; end + def inverse_keyword; end + def keyword; end +end + +module RuboCop::AST::Version +end + +RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String) + +class RuboCop::AST::WhenNode < ::RuboCop::AST::Node + def body; end + def branch_index; end + def conditions; end + def each_condition; end + def then?; end +end + +class RuboCop::AST::WhileNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ConditionalNode) + include(::RuboCop::AST::ModifierNode) + + def do?; end + def inverse_keyword; end + def keyword; end +end + +class RuboCop::AST::YieldNode < ::RuboCop::AST::Node + include(::RuboCop::AST::ParameterizedNode) + include(::RuboCop::AST::MethodIdentifierPredicates) + include(::RuboCop::AST::MethodDispatchNode) + + def node_parts; end +end + +RuboCop::NodePattern = RuboCop::AST::NodePattern + +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +RuboCop::Token = RuboCop::AST::Token + +RuboCop::AST::NodePattern::Compiler::ANY_ORDER_TEMPLATE = T.let(T.unsafe(nil), ERB) + +RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::CUR_NODE = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::CUR_PLACEHOLDER = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::FUNCALL = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::LITERAL = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::META = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::METHOD_NAME = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::NODE = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::NUMBER = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::PARAM = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::PARAM_NUMBER = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::PREDICATE = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::REPEATED_TEMPLATE = T.let(T.unsafe(nil), ERB) + +RuboCop::AST::NodePattern::Compiler::REST = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::SEPARATORS = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_GUARD = T.let(T.unsafe(nil), String) + +RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_INDEX = T.let(T.unsafe(nil), Integer) + +RuboCop::AST::NodePattern::Compiler::STRING = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::SYMBOL = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::TOKEN = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::TOKENS = T.let(T.unsafe(nil), Regexp) + +RuboCop::AST::NodePattern::Compiler::WILDCARD = T.let(T.unsafe(nil), Regexp) diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.6.1.rbi new file mode 100644 index 0000000000..d79fe302c6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.6.1.rbi @@ -0,0 +1,525 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RuboCop +end + +module RuboCop::Cop +end + +module RuboCop::Cop::Performance +end + +class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::TargetRubyVersion) + + def autocorrect(node); end + def bind_with_call_method?(node = _); end + def on_send(node); end + + private + + def build_call_args(call_args_node); end + def correction_range(receiver, node); end + def message(bind_arg, call_args); end +end + +RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Cop + def caller_with_scope_method?(node = _); end + def on_send(node); end + def slow_caller?(node = _); end + + private + + def int_value(node); end + def message(node); end +end + +RuboCop::Cop::Performance::Caller::MSG_BRACE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::Caller::MSG_FIRST = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::CaseWhenSplat < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(when_node); end + def on_case(case_node); end + + private + + def indent_for(node); end + def inline_fix_branch(corrector, when_node); end + def needs_reorder?(when_node); end + def new_branch_without_then(node, new_condition); end + def new_condition_with_then(node, new_condition); end + def non_splat?(condition); end + def reorder_condition(corrector, when_node); end + def reordering_correction(when_node); end + def replacement(conditions); end + def splat_offenses(when_conditions); end + def when_branch_range(when_node); end +end + +RuboCop::Cop::Performance::CaseWhenSplat::ARRAY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Cop + def autocorrect(node); end + def downcase_downcase(node = _); end + def downcase_eq(node = _); end + def eq_downcase(node = _); end + def on_send(node); end + + private + + def build_good_method(arg, variable); end + def correction(node, _receiver, method, arg, variable); end + def take_method_apart(node); end +end + +RuboCop::Cop::Performance::Casecmp::CASE_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def flat_map_candidate?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Performance::ChainArrayAllocation::ALWAYS_RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::ChainArrayAllocation::HAS_MUTATION_ALTERNATIVE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::ChainArrayAllocation::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::ChainArrayAllocation::RETURN_NEW_ARRAY_WHEN_ARGS = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def compare?(node = _); end + def on_block(node); end + def replaceable_body?(node = _, param1, param2); end + + private + + def compare_range(send, node); end + def message(send, method, var_a, var_b, args); end + def slow_compare?(method, args_a, args_b); end +end + +RuboCop::Cop::Performance::CompareWithBlock::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def count_candidate?(node = _); end + def on_send(node); end + + private + + def eligible_node?(node); end + def source_starting_at(node); end +end + +RuboCop::Cop::Performance::Count::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RegexpMetacharacter) + extend(::RuboCop::Cop::TargetRubyVersion) + + def autocorrect(node); end + def delete_prefix_candidate?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Performance::DeletePrefix::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::DeletePrefix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RegexpMetacharacter) + extend(::RuboCop::Cop::TargetRubyVersion) + + def autocorrect(node); end + def delete_suffix_candidate?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Performance::DeleteSuffix::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Cop + def autocorrect(node); end + def detect_candidate?(node = _); end + def on_send(node); end + + private + + def accept_first_call?(receiver, body); end + def lazy?(node); end + def preferred_method; end + def register_offense(node, receiver, second_method); end +end + +RuboCop::Cop::Performance::Detect::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Cop + def autocorrect(node); end + def check_with_active_support_aliases(node = _); end + def on_or(node); end + def two_start_end_with_calls(node = _); end + + private + + def add_offense_for_double_call(node, receiver, method, combined_args); end + def check_for_active_support_aliases?; end + def combine_args(first_call_args, second_call_args); end + def process_source(node); end +end + +RuboCop::Cop::Performance::DoubleStartEndWith::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RegexpMetacharacter) + + def autocorrect(node); end + def on_match_with_lvasgn(node); end + def on_send(node); end + def redundant_regex?(node = _); end +end + +RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Cop + def counter(node = _); end + def on_send(node); end + + private + + def allowed_argument?(arg); end + def allowed_parent?(node); end + def allowed_variable?(var); end + def contains_double_splat?(node); end + def contains_splat?(node); end + def non_string_argument?(node); end +end + +RuboCop::Cop::Performance::FixedSize::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def flat_map_candidate?(node = _); end + def on_send(node); end + + private + + def offense_for_levels(node, map_node, first_method, flatten); end + def offense_for_method(node, map_node, first_method, flatten); end + def register_offense(node, map_node, first_method, flatten, message); end +end + +RuboCop::Cop::Performance::FlatMap::FLATTEN_MULTIPLE_LEVELS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Cop + def autocorrect(node); end + def inefficient_include?(node = _); end + def on_send(node); end + + private + + def autocorrect_argument(node); end + def autocorrect_hash_expression(node); end + def autocorrect_method(node); end + def current_method(node); end + def message(node); end + def use_long_method; end +end + +class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Cop + def on_send(node); end + def open_struct(node = _); end +end + +RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def range_include(node = _); end +end + +RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Cop + def autocorrect(node); end + def blockarg_assigned?(node0, param1); end + def blockarg_calls(node0, param1); end + def blockarg_def(node = _); end + def on_def(node); end + + private + + def args_include_block_pass?(blockcall); end + def calls_to_report(argname, body); end +end + +RuboCop::Cop::Performance::RedundantBlockCall::CLOSE_PAREN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RedundantBlockCall::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RedundantBlockCall::OPEN_PAREN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RedundantBlockCall::SPACE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Cop + def autocorrect(node); end + def match_call?(node = _); end + def on_send(node); end + def only_truthiness_matters?(node = _); end +end + +RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Cop + def autocorrect(node); end + def modifier_flow_control?(node = _); end + def on_send(node); end + def redundant_merge_candidate(node = _); end + + private + + def correct_multiple_elements(node, parent, new_source); end + def correct_single_element(node, new_source); end + def each_redundant_merge(node); end + def indent_width; end + def kwsplat_used?(pairs); end + def leading_spaces(node); end + def max_key_value_pairs; end + def message(node); end + def non_redundant_merge?(node, receiver, pairs); end + def non_redundant_pairs?(receiver, pairs); end + def non_redundant_value_used?(receiver, node); end + def rewrite_with_modifier(node, parent, new_source); end + def to_assignments(receiver, pairs); end +end + +RuboCop::Cop::Performance::RedundantMerge::AREF_ASGN = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(node, receiver); end + + def each_with_object_node(node = _); end + def value_used?; end + + private + + def eligible_receiver?; end + def node; end + def receiver; end + def second_argument; end + def unwind(receiver); end +end + +RuboCop::Cop::Performance::RedundantMerge::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RedundantMerge::WITH_MODIFIER_CORRECTION = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop + def autocorrect(node); end + def last_matches(node0); end + def match_method?(node = _); end + def match_node?(node = _); end + def match_operator?(node = _); end + def match_threequals?(node = _); end + def match_with_int_arg_method?(node = _); end + def match_with_lvasgn?(node); end + def on_case(node); end + def on_if(node); end + def search_match_nodes(node0); end + + private + + def check_condition(cond); end + def correct_operator(corrector, recv, arg, oper = _); end + def correction_range(recv, arg); end + def find_last_match(body, range, scope_root); end + def last_match_used?(match_node); end + def match_gvar?(sym); end + def message(node); end + def modifier_form?(match_node); end + def next_match_pos(body, match_node_pos, scope_root); end + def range_to_search_for_last_matches(match_node, body, scope_root); end + def replace_with_match_predicate_method(corrector, recv, arg, op_range); end + def scope_body(node); end + def scope_root(node); end + def swap_receiver_and_arg(corrector, recv, arg); end +end + +RuboCop::Cop::Performance::RegexpMatch::MATCH_NODE_PATTERN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RegexpMatch::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::RegexpMatch::TYPES_IMPLEMENTING_MATCH = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def reverse_each?(node = _); end +end + +RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::ReverseEach::UNDERSCORE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + + private + + def allowed_parent?(node); end + def array?(node); end + def eligible_node?(node); end + def eligible_receiver?(node); end + def hash?(node); end +end + +RuboCop::Cop::Performance::Size::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RegexpMetacharacter) + + def autocorrect(node); end + def on_match_with_lvasgn(node); end + def on_send(node); end + def redundant_regex?(node = _); end +end + +RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def replace_method(node, first, second, first_param, replacement); end + def string_replacement?(node = _); end + + private + + def accept_first_param?(first_param); end + def accept_second_param?(second_param); end + def first_source(first_param); end + def message(node, first_source, second_source); end + def method_suffix(node); end + def offense(node, first_param, second_param); end + def range(node); end + def remove_second_param(corrector, node, first_param); end + def replacement_method(node, first_source, second_source); end + def source_from_regex_constructor(node); end + def source_from_regex_literal(node); end +end + +RuboCop::Cop::Performance::StringReplacement::BANG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::StringReplacement::DELETE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::StringReplacement::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Performance::StringReplacement::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::StringReplacement::TR = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_block(node); end + def on_send(node); end + def times_map_call(node = _); end + + private + + def check(node); end + def message(map_or_collect, count); end +end + +RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Cop + def dup_string?(node = _); end + def on_send(node); end + def string_new?(node = _); end +end + +RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def uri_parser_new?(node = _); end +end + +RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RegexpMetacharacter + + private + + def drop_end_metacharacter(regexp_string); end + def drop_start_metacharacter(regexp_string); end + def literal_at_end?(regexp); end + def literal_at_end_with_backslash_z?(regex_str); end + def literal_at_end_with_dollar?(regex_str); end + def literal_at_start?(regexp); end + def literal_at_start_with_backslash_a?(regex_str); end + def literal_at_start_with_caret?(regex_str); end + def safe_multiline?; end +end + +RuboCop::NodePattern = RuboCop::AST::NodePattern + +module RuboCop::Performance +end + +RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash) + +module RuboCop::Performance::Inject + def self.defaults!; end +end + +module RuboCop::Performance::Version +end + +RuboCop::Performance::Version::STRING = T.let(T.unsafe(nil), String) + +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +RuboCop::Token = RuboCop::AST::Token diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.40.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.40.0.rbi new file mode 100644 index 0000000000..7c248d3905 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@1.40.0.rbi @@ -0,0 +1,1669 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RuboCop +end + +module RuboCop::Cop +end + +module RuboCop::Cop::Layout +end + +class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::PrecedingFollowingAlignment) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def align_column(asgn_token); end + def align_equal_sign(corrector, token, align_to); end + def align_equal_signs(range, corrector); end + def aligned_comments?(comment_token); end + def aligned_tok?(token); end + def aligned_with_next_comment?(index); end + def aligned_with_previous_comment?(index); end + def all_relevant_assignment_lines(line_number); end + def allow_for_trailing_comments?; end + def check_assignment(token); end + def check_other(token1, token2, ast); end + def check_tokens(ast, token1, token2); end + def comment_column(index); end + def extra_space_range(token1, token2); end + def force_equal_sign_alignment?; end + def ignored_range?(ast, start_pos); end + def ignored_ranges(ast); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RSpec +end + +class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Cop + def autocorrect(let); end + def investigate(_processed_source); end + + private + + def token_aligner; end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Cop + def autocorrect(let); end + def investigate(_processed_source); end + + private + + def token_aligner; end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Cop + def disallowed_stub(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Cop + def find_arg_usage(node0); end + def hook(node = _); end + def on_block(node); end + + private + + def add_no_arg_offense(node); end + def check_for_unused_proxy(block, proxy); end +end + +RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Cop + def be_without_args(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def eql_type_with_identity(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Cop + def before_or_after_all(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RSpec::Capybara +end + +class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < ::RuboCop::Cop::RSpec::Cop + def as_is_matcher(node = _); end + def autocorrect(node); end + def expectation_set_on_current_path(node = _); end + def on_send(node); end + def regexp_str_matcher(node = _); end + + private + + def add_ignore_query_options(corrector, node); end + def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str); end + def rewrite_expectation(corrector, node, to_symbol, matcher_node); end +end + +RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def feature_method(node = _); end + def on_block(node); end + def spec?(node = _); end + + private + + def enabled?(method_name); end + def enabled_methods; end + def inside_spec?(node); end + def root_node?(node); end + def root_with_siblings?(node); end +end + +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MAP = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < ::RuboCop::Cop::RSpec::Cop + def on_send(node); end + def visible_false?(node = _); end + def visible_true?(node = _); end + + private + + def capybara_matcher?(method_name); end +end + +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::CAPYBARA_MATCHER_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_FALSE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def context_method(node = _); end + def on_block(node); end + + private + + def method_name?(description); end +end + +RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Cop + def context_wording(node = _); end + def on_block(node); end + + private + + def bad_prefix?(description); end + def joined_prefixes; end + def prefixes; end +end + +RuboCop::Cop::RSpec::ContextWording::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Cop < ::RuboCop::Cop::Cop + include(::RuboCop::RSpec::Language) + include(::RuboCop::RSpec::Language::NodePattern) + + def relevant_file?(file); end + + private + + def all_cops_config; end + def relevant_rubocop_rspec_file?(file); end + def rspec_pattern; end + def rspec_pattern_config; end + def rspec_pattern_config?; end + + def self.inherited(subclass); end +end + +RuboCop::Cop::RSpec::Cop::DEFAULT_CONFIGURATION = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::RSpec::Cop::DEFAULT_PATTERN_RE = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::TopLevelDescribe) + + def describe_with_rails_metadata?(node = _); end + def on_top_level_describe(node, _); end + def rails_metadata?(node = _); end + def shared_group?(node = _); end + def valid_describe?(node = _); end + + private + + def string_constant_describe?(described_value); end +end + +RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::TopLevelDescribe) + + def on_top_level_describe(_node, _); end +end + +RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Cop + def describe_symbol?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def common_instance_exec_closure?(node = _); end + def contains_described_class?(node0); end + def described_constant(node = _); end + def on_block(node); end + def rspec_block?(node = _); end + def scope_changing_syntax?(node = _); end + + private + + def collapse_namespace(namespace, const); end + def const_name(node); end + def find_usage(node, &block); end + def full_const_name(node); end + def message(offense); end + def namespace(node); end + def offensive?(node); end + def offensive_described_class?(node); end + def scope_change?(node); end + def skip_blocks?; end + def skippable_block?(node); end +end + +RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Cop + def find_rspec_blocks(node0); end + def on_module(node); end +end + +RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::MethodPreference) + + def autocorrect(node); end + def on_send(node); end + def rspec_method?(node = _); end + + private + + def message(node); end +end + +RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Cop + def contains_example?(node0); end + def on_block(node); end + + private + + def custom_include?(method_name); end + def custom_include_methods; end +end + +RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def empty_hook?(node = _); end + def on_block(node); end +end + +RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::BlankLineSeparation) + + def allow_consecutive_one_liners?; end + def allowed_one_liner?(node); end + def consecutive_one_liner?(node); end + def next_one_line_example?(node); end + def next_sibling(node); end + def on_block(node); end +end + +RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::BlankLineSeparation) + + def on_block(node); end +end + +RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::BlankLineSeparation) + + def on_block(node); end +end + +RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::BlankLineSeparation) + + def on_block(node); end +end + +RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::BlankLineSeparation) + + def on_block(node); end + + private + + def in_spec_block?(node); end +end + +RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + + def on_block(node); end + + private + + def code_length(node); end + def message(length); end +end + +RuboCop::Cop::RSpec::ExampleLength::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def example_description(node = _); end + def on_block(node); end + + private + + def check_example_without_description(node); end + def disallow_empty_description?(node); end +end + +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def it_description(node = _); end + def on_block(node); end + + private + + def add_wording_offense(node, message); end + def custom_transform; end + def docstring(node); end + def ignored_words; end + def replacement_text(node); end + def text(node); end +end + +RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def expect_literal(node = _); end + def on_send(node); end + + private + + def complex_literal?(node); end + def literal?(node); end + def simple_literal?(node); end + def swap(corrector, actual, expected); end +end + +RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::RSpec::ExpectActual::SUPPORTED_MATCHERS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def expect_change_with_arguments(node = _); end + def expect_change_with_block(node = _); end + def on_block(node); end + def on_send(node); end + + private + + def autocorrect_block_to_method_call(node); end + def autocorrect_method_call_to_block(node); end +end + +RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Cop + def expectation(node0); end + def on_block(node); end + + private + + def message(expect, hook); end +end + +RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Cop + def on_gvasgn(node); end + + private + + def inside_example_scope?(node); end +end + +RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RSpec::ExplicitHelper + include(::RuboCop::RSpec::Language) + extend(::RuboCop::AST::NodePattern::Macros) + + def predicate_matcher?(node = _); end + def predicate_matcher_block?(node = _); end + + private + + def allowed_explicit_matchers; end + def autocorrect_explicit(node); end + def autocorrect_explicit_block(node); end + def autocorrect_explicit_send(node); end + def check_explicit(node); end + def corrector_explicit(to_node, actual, matcher, block_child); end + def message_explicit(matcher); end + def move_predicate(corrector, actual, matcher, block_child); end + def predicate_matcher_name?(name); end + def replacement_matcher(node); end + def to_predicate_method(matcher); end +end + +RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RSpec::FactoryBot +end + +class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::RSpec::Cop + def association?(node = _); end + def autocorrect(node); end + def factory_attributes(node0); end + def on_block(node); end + def value_matcher(node = _); end + + private + + def attribute_defining_method?(method_name); end + def autocorrect_replacing_parens(node); end + def autocorrect_without_parens(node); end + def braces(node); end + def offensive_receiver?(receiver, node); end + def proc?(attribute); end + def receiver_matches_first_block_argument?(receiver, node); end + def reserved_method?(method_name); end + def value_hash_without_braces?(node); end +end + +RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::FactoryBot::CreateList < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def factory_call(node = _); end + def factory_list_call(node = _); end + def n_times_block_without_arg?(node = _); end + def on_block(node); end + def on_send(node); end + + private + + def contains_only_factory?(node); end +end + +class RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + + private + + def build_options_string(options); end + def format_method_call(node, method, arguments); end + def format_receiver(receiver); end +end + +class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector < ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + def initialize(node); end + + def call(corrector); end + + private + + def build_arguments(node, count); end + def call_replacement(node); end + def call_with_block_replacement(node); end + def format_block(node); end + def format_multiline_block(node); end + def format_singeline_block(node); end + def node; end +end + +RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_CREATE_LIST = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_N_TIMES = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector < ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + def initialize(node); end + + def call(corrector); end + + private + + def generate_n_times_block(node); end + def node; end +end + +class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def class_name(node = _); end + def on_send(node); end + + private + + def allowed?(const_name); end +end + +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::ALLOWED_CONSTANTS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::FilePath < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::TopLevelDescribe) + + def const_described?(node0); end + def on_top_level_describe(node, args); end + def routing_metadata?(node0); end + + private + + def camel_to_snake_case(string); end + def custom_transform; end + def expected_path(constant); end + def filename_ends_with?(glob); end + def glob_for(_); end + def glob_for_spec_suffix_only?; end + def ignore_methods?; end + def name_glob(name); end + def relevant_rubocop_rspec_file?(_file); end + def routing_spec?(args); end + def spec_suffix_only?; end +end + +RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Cop + def focused_block?(node = _); end + def metadata(node = _); end + def on_send(node); end + + private + + def focus_metadata(node, &block); end +end + +RuboCop::Cop::RSpec::Focus::FOCUSABLE_SELECTORS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_block(node); end + def scoped_hook(node = _); end + def unscoped_hook(node = _); end + + private + + def argument_range(send_node); end + def check_implicit(method_send); end + def explicit_message(scope); end + def hook(node, &block); end + def implicit_style?; end +end + +RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::HookArgument::HOOKS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def example_or_group?(node = _); end + def on_block(node); end + + private + + def check_hooks(node); end + def find_first_example(node); end + def multiline_block?(block); end +end + +RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Cop + def implicit_expect(node = _); end + def lambda?(node = _); end + def lambda_subject?(node = _); end + def on_send(node); end + + private + + def find_subject(block_node); end + def multi_statement_example_group?(node); end + def nearest_subject(node); end +end + +RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def implicit_expect(node = _); end + def on_send(node); end + + private + + def is_expected_range(source_map); end + def offending_expect(node); end + def offense_message(offending_source); end + def replacement_source(offending_source); end +end + +RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def implicit_subject?(node = _); end + def on_send(node); end + + private + + def allowed_by_style?(example); end + def valid_usage?(node); end +end + +RuboCop::Cop::RSpec::ImplicitSubject::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::RSpec::InflectedHelper + include(::RuboCop::RSpec::Language) + extend(::RuboCop::AST::NodePattern::Macros) + + def be_bool?(node = _); end + def be_boolthy?(node = _); end + def predicate_in_actual?(node = _); end + + private + + def autocorrect_inflected(node); end + def boolean_matcher?(node); end + def check_inflected(node); end + def message_inflected(predicate); end + def predicate?(sym); end + def remove_predicate(corrector, predicate); end + def rewrite_matcher(corrector, predicate, matcher); end + def to_predicate_matcher(name); end + def true?(to_symbol, matcher); end +end + +RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def have_received_usage(node0); end + def null_double(node0); end + def on_block(node); end +end + +RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Cop + def custom_matcher?(node = _); end + def dynamic_class?(node = _); end + def ivar_assigned?(node0, param1); end + def ivar_usage(node0); end + def on_block(node); end + def spec_group?(node = _); end + + private + + def assignment_only?; end + def valid_usage?(node); end +end + +RuboCop::Cop::RSpec::InstanceVariable::EXAMPLE_GROUP_METHODS = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::InvalidPredicateMatcher < ::RuboCop::Cop::RSpec::Cop + def invalid_predicate_matcher?(node = _); end + def on_send(node); end + + private + + def message(predicate); end + def predicate?(name); end +end + +RuboCop::Cop::RSpec::InvalidPredicateMatcher::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def example_inclusion_offense(node = _, param1); end + def on_send(node); end + + private + + def message(_node); end +end + +RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Cop + def each?(node = _); end + def expectation?(node = _, param1); end + def on_block(node); end + + private + + def only_expectations?(body, arg); end + def single_expectation?(body, arg); end +end + +RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def check_previous_nodes(node); end + def on_block(node); end + + private + + def find_first_offending_node(node); end + def in_spec_block?(node); end + def offending?(node); end +end + +RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Cop + def in_example_or_shared_group?(node = _); end + def on_casgn(node); end + def on_class(node); end + def on_module(node); end + + private + + def inside_describe_block?(node); end +end + +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def example_or_group?(node = _); end + def on_block(node); end + + private + + def check_let_declarations(node); end + def find_first_example(node); end + def multiline_block?(block); end +end + +RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Cop + def let_bang(node0); end + def method_called?(node0, param1); end + def on_block(node); end + + private + + def unused_let_bang(node); end +end + +RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Cop + def message(node); end + def message_chain(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def message_expectation(node = _); end + def on_send(node); end + def receive_message?(node0); end + + private + + def preferred_style?(expectation); end +end + +RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::MessageExpectation::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def message_expectation(node = _); end + def on_send(node); end + def receive_message(node0); end + + private + + def error_message(receiver); end + def preferred_style?(expectation); end + def receive_message_matcher(node); end +end + +RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::MessageSpies::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Cop + def on_block(node); end +end + +RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::RSpec::TopLevelDescribe) + + def on_top_level_describe(node, _args); end +end + +RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableMax) + + def aggregate_failures?(node = _); end + def aggregate_failures_block?(node = _); end + def aggregate_failures_present?(node = _); end + def expect?(node = _); end + def on_block(node); end + + private + + def example_with_aggregate_failures?(example_node); end + def find_aggregate_failures(example_node); end + def find_expectation(node, &block); end + def flag_example(node, expectation_count:); end + def max_expectations; end +end + +RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + + private + + def named_subject?(node); end + def remove_autocorrect(node); end + def rename_autocorrect(node); end +end + +RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Cop + def ignored_shared_example?(node); end + def on_block(node); end + def rspec_block?(node = _); end + def shared_example?(node = _); end + def subject_usage(node0); end +end + +RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::RSpec::TopLevelDescribe) + + def find_contexts(node0); end + def on_top_level_describe(node, _args); end + + private + + def find_nested_contexts(node, nesting: _, &block); end + def max_nesting; end + def max_nesting_config; end + def message(nesting); end +end + +RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def not_to_not_offense(node = _, param1); end + def on_send(node); end + + private + + def message(_node); end +end + +RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Cop + def first_argument_name(node = _); end + def on_block(node); end + def setup?(node = _); end + + private + + def common_setup?(node); end + def find_duplicates(node); end +end + +RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Cop + def on_send(node); end + def pending_block?(node = _); end + def skip_or_pending?(node = _); end + def skippable?(node = _); end + def skipped_in_metadata?(node = _); end + + private + + def skipped?(node); end +end + +RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::Pending::PENDING = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::Cop::RSpec::Pending::SKIPPABLE = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RSpec::InflectedHelper) + include(::RuboCop::Cop::RSpec::ExplicitHelper) + + def autocorrect(node); end + def on_block(node); end + def on_send(node); end + + private + + def args_loc(send_node); end + def block_loc(send_node); end +end + +class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def on_send(node); end + def receive_counts(node = _); end + def stub?(node0); end + + private + + def matcher_for(method, count); end + def message_for(node, source); end + def range(node, offending_node); end +end + +RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def method_on_stub?(node0); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Cop + def on_block(node); end + + private + + def example_signature(example); end + def repeated_descriptions(node); end +end + +RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Cop + def on_block(node); end + + private + + def example_signature(example); end + def repeated_examples(node); end +end + +RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Cop + def body(node = _); end + def const_arg(node = _); end + def metadata(node = _); end + def on_begin(node); end + def several_example_groups?(node = _); end + def skip_or_pending?(node = _); end + + private + + def add_repeated_lines(groups); end + def message(group, repeats); end + def repeated_group_bodies(node); end + def signature_keys(group); end +end + +RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Cop + def doc_string_and_metadata(node = _); end + def empty_description?(node = _); end + def on_begin(node); end + def several_example_groups?(node = _); end + def skip_or_pending?(node = _); end + + private + + def add_repeated_lines(groups); end + def message(group, repeats); end + def repeated_group_descriptions(node); end +end + +RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def and_return_value(node0); end + def autocorrect(node); end + def contains_stub?(node0); end + def on_block(node); end + def on_send(node); end + + private + + def check_and_return_call(node); end + def check_block_body(block); end + def dynamic?(node); end +end + +class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector + def initialize(node); end + + def call(corrector); end + + private + + def arg; end + def hash_without_braces?; end + def heredoc?; end + def node; end + def range; end + def receiver; end + def replacement; end +end + +class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector + def initialize(block); end + + def call(corrector); end + + private + + def block; end + def body; end + def heredoc?; end + def node; end +end + +RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped) + +RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def on_block(node); end + + private + + def check_let_declarations(body); end + def find_first_let(node); end +end + +RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Cop + def lines_msg(numbers); end + def on_block(node); end + def repeated_hooks(node); end +end + +RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def context?(node0); end + def examples?(node0); end + def on_block(node); end + def shared_context(node = _); end + def shared_example(node = _); end + + private + + def add_shared_item_offense(node, message); end + def context_with_only_examples(node); end + def examples_with_only_context(node); end +end + +RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def on_send(node); end + def shared_examples(node = _); end +end + +class RuboCop::Cop::RSpec::SharedExamples::Checker + def initialize(node); end + + def message; end + def node; end + def preferred_style; end + + private + + def symbol; end + def wrap_with_single_quotes(string); end +end + +RuboCop::Cop::RSpec::SharedExamples::Checker::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Cop + def autocorrect(node); end + def message_chain(node = _); end + def on_send(node); end + def single_key_hash?(node = _); end + + private + + def autocorrect_array_arg(corrector, arg); end + def autocorrect_hash_arg(corrector, arg); end + def key_to_arg(node); end + def message(node); end + def replacement(method); end + def single_element_array?(node); end + def valid_usage?(node); end +end + +RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Cop + def message_expectation?(node = _, param1); end + def message_expectation_matcher?(node0); end + def on_block(node); end + def subject(node = _); end + + private + + def find_all_explicit_subjects(node); end + def find_subject_expectations(node, subject_names = _, &block); end + def processed_example_groups; end +end + +RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Cop + def block_with_args?(node); end + def empty_exception_matcher?(node); end + def empty_raise_error_or_exception(node = _); end + def on_send(node); end +end + +RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::RSpec::Variable) + + def on_send(node); end + + private + + def string?(node); end + def style_violation?(variable); end + def symbol?(node); end +end + +RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) + include(::RuboCop::Cop::ConfigurableNaming) + include(::RuboCop::RSpec::Variable) + + def on_send(node); end + + private + + def message(style); end +end + +RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Cop + def on_send(node); end + def unverified_double(node = _); end + + private + + def symbol?(name); end +end + +RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Cop + def expect?(node = _); end + def expect_block?(node = _); end + def on_block(node); end + def on_send(node); end + + private + + def check_expect(node); end + def void?(expect); end +end + +RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def block_arg(node = _); end + def block_call?(node = _, param1); end + def method_on_stub?(node0); end + def on_block(node); end + + private + + def block_range(node); end + def calling_block?(node, block); end + def convert_block_to_yield(node); end + def generate_replacement(node); end +end + +RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String) + +RuboCop::NodePattern = RuboCop::AST::NodePattern + +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +module RuboCop::RSpec +end + +class RuboCop::RSpec::AlignLetBrace + include(::RuboCop::RSpec::Language::NodePattern) + + def initialize(root, token); end + + def indent_for(node); end + def offending_tokens; end + + private + + def adjacent_let_chunks; end + def let_group_for(let); end + def let_token(node); end + def root; end + def single_line_lets; end + def target_column_for(let); end + def token; end +end + +module RuboCop::RSpec::BlankLineSeparation + include(::RuboCop::RSpec::FinalEndLocation) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def last_child?(node); end + def missing_separating_line(node); end + def offending_loc(last_line); end +end + +RuboCop::RSpec::CONFIG = T.let(T.unsafe(nil), Hash) + +class RuboCop::RSpec::Concept + include(::RuboCop::RSpec::Language) + include(::RuboCop::RSpec::Language::NodePattern) + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(node); end + + def ==(other); end + def eql?(other); end + def hash; end + def to_node; end + + protected + + def node; end +end + +module RuboCop::RSpec::Corrector +end + +class RuboCop::RSpec::Corrector::MoveNode + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::RSpec::FinalEndLocation) + + def initialize(node, corrector, processed_source); end + + def corrector; end + def move_after(other); end + def move_before(other); end + def original; end + def processed_source; end + + private + + def node_range(node); end + def node_range_with_surrounding_space(node); end + def source(node); end +end + +class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept + def definition; end + def doc_string; end + def extract_doc_string(node = _); end + def extract_implementation(node = _); end + def extract_metadata(node = _); end + def implementation; end + def metadata; end +end + +class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept + def examples; end + def hooks; end + def scope_change?(node = _); end + def subjects; end + + private + + def examples_in_scope(node, &blk); end + def find_examples(node); end + def find_hooks(node); end + def find_subjects(node); end + def hooks_in_scope(node); end + def subjects_in_scope(node); end +end + +module RuboCop::RSpec::FactoryBot + def self.attribute_defining_methods; end + def self.reserved_methods; end +end + +module RuboCop::RSpec::FinalEndLocation + def final_end_location(start_node); end +end + +class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept + def example?; end + def extract_metadata(node = _); end + def knowable_scope?; end + def metadata; end + def name; end + def scope; end + + private + + def scope_argument; end + def scope_name; end + def transform_metadata(meta); end + def transform_true(node); end + def valid_scope?(node); end +end + +module RuboCop::RSpec::Inject + def self.defaults!; end +end + +module RuboCop::RSpec::Language +end + +RuboCop::RSpec::Language::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::ExampleGroups +end + +RuboCop::RSpec::Language::ExampleGroups::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::ExampleGroups::FOCUSED = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::ExampleGroups::GROUPS = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::ExampleGroups::SKIPPED = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Examples +end + +RuboCop::RSpec::Language::Examples::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Examples::EXAMPLES = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Examples::FOCUSED = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Examples::PENDING = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Examples::SKIPPED = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Expectations +end + +RuboCop::RSpec::Language::Expectations::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Helpers +end + +RuboCop::RSpec::Language::Helpers::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Hooks +end + +RuboCop::RSpec::Language::Hooks::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Hooks::Scopes +end + +RuboCop::RSpec::Language::Hooks::Scopes::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Includes +end + +RuboCop::RSpec::Language::Includes::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Includes::CONTEXT = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::Includes::EXAMPLES = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::NodePattern + extend(::RuboCop::AST::NodePattern::Macros) + + def example?(node = _); end + def example_group?(node = _); end + def example_group_with_body?(node = _); end + def hook?(node = _); end + def let?(node = _); end + def subject?(node = _); end +end + +RuboCop::RSpec::Language::RSPEC = T.let(T.unsafe(nil), String) + +module RuboCop::RSpec::Language::Runners +end + +RuboCop::RSpec::Language::Runners::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +class RuboCop::RSpec::Language::SelectorSet + def initialize(selectors); end + + def +(other); end + def ==(other); end + def block_or_block_pass_pattern; end + def block_pass_pattern; end + def block_pattern; end + def include?(selector); end + def node_pattern; end + def node_pattern_union; end + def send_pattern; end + + protected + + def selectors; end +end + +module RuboCop::RSpec::Language::SharedGroups +end + +RuboCop::RSpec::Language::SharedGroups::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::SharedGroups::CONTEXT = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +RuboCop::RSpec::Language::SharedGroups::EXAMPLES = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Language::Subject +end + +RuboCop::RSpec::Language::Subject::ALL = T.let(T.unsafe(nil), RuboCop::RSpec::Language::SelectorSet) + +module RuboCop::RSpec::Node + def recursive_literal_or_const?; end +end + +module RuboCop::RSpec::TopLevelDescribe + extend(::RuboCop::AST::NodePattern::Macros) + + def on_send(node); end + + private + + def describe_statement_children(node); end + def root_node; end + def single_top_level_describe?; end + def top_level_describe?(node); end + def top_level_nodes; end +end + +module RuboCop::RSpec::Variable + include(::RuboCop::RSpec::Language) + extend(::RuboCop::AST::NodePattern::Macros) + + def variable_definition?(node = _); end +end + +module RuboCop::RSpec::Version +end + +RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String) + +class RuboCop::RSpec::Wording + def initialize(text, ignore:, replace:); end + + def rewrite; end + + private + + def append_suffix(word, suffix); end + def ignored_word?(word); end + def ignores; end + def remove_should_and_pluralize; end + def replace_prefix(pattern, replacement); end + def replacements; end + def substitute(word); end + def text; end + def uppercase?(word); end +end + +RuboCop::Token = RuboCop::AST::Token diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@0.85.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.85.1.rbi new file mode 100644 index 0000000000..b9895aecaf --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@0.85.1.rbi @@ -0,0 +1,10471 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module RuboCop +end + +class RuboCop::CLI + def initialize; end + + def config_store; end + def options; end + def run(args = _); end + + private + + def act_on_options; end + def apply_default_formatter; end + def execute_runners; end + def handle_exiting_options; end + def run_command(name); end + def set_options_to_config_loader; end + def validate_options_vs_config; end +end + +module RuboCop::CLI::Command + def self.run(env, name); end +end + +class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base + def run; end + + private + + def add_formatter; end + def execute_runner; end + def line_length_cop(config); end + def line_length_enabled?(config); end + def max_line_length(config); end + def maybe_run_line_length_cop; end + def reset_config_and_auto_gen_file; end + def run_all_cops(line_length_contents); end + def run_line_length_cop; end + def same_max_line_length?(config1, config2); end + def skip_line_length_cop(reason); end +end + +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1 = T.let(T.unsafe(nil), String) + +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_DISABLED = T.let(T.unsafe(nil), String) + +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_OVERRIDDEN = T.let(T.unsafe(nil), String) + +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_2 = T.let(T.unsafe(nil), String) + +class RuboCop::CLI::Command::Base + def initialize(env); end + + def env; end + + def self.by_command_name(name); end + def self.command_name; end + def self.command_name=(_); end + def self.inherited(subclass); end +end + +class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base + include(::RuboCop::Formatter::TextUtil) + + def run; end + + private + + def display_error_summary(errors); end + def display_warning_summary(warnings); end + def execute_runner(paths); end + def maybe_print_corrected_source; end +end + +class RuboCop::CLI::Command::InitDotfile < ::RuboCop::CLI::Command::Base + def run; end +end + +RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String) + +class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base + def initialize(env); end + + def run; end + + private + + def config_lines(cop); end + def cops_of_department(cops, department); end + def print_available_cops; end + def print_cop_details(cops); end + def print_cops_of_department(registry, department, show_all); end + def selected_cops_of_department(cops, department); end +end + +class RuboCop::CLI::Command::Version < ::RuboCop::CLI::Command::Base + def run; end +end + +class RuboCop::CLI::Environment + def initialize(options, config_store, paths); end + + def config_store; end + def options; end + def paths; end + def run(name); end +end + +class RuboCop::CLI::Finished < ::RuntimeError +end + +RuboCop::CLI::STATUS_ERROR = T.let(T.unsafe(nil), Integer) + +RuboCop::CLI::STATUS_INTERRUPTED = T.let(T.unsafe(nil), Integer) + +RuboCop::CLI::STATUS_OFFENSES = T.let(T.unsafe(nil), Integer) + +RuboCop::CLI::STATUS_SUCCESS = T.let(T.unsafe(nil), Integer) + +class RuboCop::CachedData + def initialize(filename); end + + def from_json(text); end + def to_json(offenses); end + + private + + def deserialize_offenses(offenses); end + def message(offense); end + def serialize_offense(offense); end +end + +class RuboCop::CommentConfig + def initialize(processed_source); end + + def cop_disabled_line_ranges; end + def cop_enabled_at_line?(cop, line_number); end + def extra_enabled_comments; end + def processed_source; end + + private + + def all_cop_names; end + def analyze; end + def analyze_cop(analysis, disabled, line, single_line); end + def analyze_disabled(analysis, line); end + def analyze_rest(analysis, line); end + def analyze_single_line(analysis, line, disabled); end + def comment_only_line?(line_number); end + def cop_line_ranges(analysis); end + def directive_on_comment_line?(comment); end + def directive_parts(comment); end + def each_directive; end + def each_mentioned_cop; end + def enable_all?(comment); end + def extra_enabled_comments_with_names(extras, names); end + def handle_enable_all(names, extras, comment); end + def handle_switch(cop_names, names, disabled, extras, comment); end + def non_comment_token_line_numbers; end + def qualified_cop_name(cop_name); end +end + +RuboCop::CommentConfig::COMMENT_DIRECTIVE_REGEXP = T.let(T.unsafe(nil), Regexp) + +RuboCop::CommentConfig::COPS_PATTERN = T.let(T.unsafe(nil), String) + +RuboCop::CommentConfig::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String) + +RuboCop::CommentConfig::COP_NAME_PATTERN = T.let(T.unsafe(nil), String) + +class RuboCop::CommentConfig::CopAnalysis < ::Struct + def line_ranges; end + def line_ranges=(_); end + def start_line_number; end + def start_line_number=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +RuboCop::CommentConfig::REDUNDANT_DISABLE = T.let(T.unsafe(nil), String) + +class RuboCop::Config + include(::RuboCop::PathUtil) + include(::RuboCop::FileFinder) + extend(::Forwardable) + + def initialize(hash = _, loaded_path = _); end + + def [](*args, &block); end + def []=(*args, &block); end + def add_excludes_from_higher_level(highest_config); end + def allowed_camel_case_file?(file); end + def base_dir_for_path_parameters; end + def bundler_lock_file_path; end + def check; end + def delete(*args, &block); end + def deprecation_check; end + def disabled_new_cops?; end + def each(*args, &block); end + def each_key(*args, &block); end + def enabled_new_cops?; end + def file_to_exclude?(file); end + def file_to_include?(file); end + def for_all_cops; end + def for_cop(cop); end + def for_department(department_name); end + def internal?; end + def key?(*args, &block); end + def keys(*args, &block); end + def loaded_path; end + def make_excludes_absolute; end + def map(*args, &block); end + def merge(*args, &block); end + def path_relative_to_config(path); end + def patterns_to_exclude; end + def patterns_to_include; end + def pending_cops; end + def possibly_include_hidden?; end + def signature; end + def smart_loaded_path; end + def target_rails_version; end + def target_ruby_version(*args, &block); end + def to_h(*args, &block); end + def to_hash(*args, &block); end + def to_s; end + def transform_values(*args, &block); end + def validate(*args, &block); end + + private + + def department_of(qualified_cop_name); end + def enable_cop?(qualified_cop_name, cop_options); end + def read_rails_version_from_bundler_lock_file; end + def target_rails_version_from_bundler_lock_file; end + + def self.create(hash, path); end +end + +class RuboCop::Config::CopConfig < ::Struct + def metadata; end + def metadata=(_); end + def name; end + def name=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float) + +class RuboCop::ConfigLoader + extend(::RuboCop::FileFinder) + + def self.add_excludes_from_files(config, config_file); end + def self.add_inheritance_from_auto_generated_file; end + def self.add_missing_namespaces(path, hash); end + def self.auto_gen_config; end + def self.auto_gen_config=(_); end + def self.auto_gen_config?; end + def self.clear_options; end + def self.configuration_file_for(target_dir); end + def self.configuration_from_file(config_file); end + def self.debug; end + def self.debug=(_); end + def self.debug?; end + def self.default_configuration; end + def self.default_configuration=(_); end + def self.disable_pending_cops; end + def self.disable_pending_cops=(_); end + def self.enable_pending_cops; end + def self.enable_pending_cops=(_); end + def self.ignore_parent_exclusion; end + def self.ignore_parent_exclusion=(_); end + def self.ignore_parent_exclusion?; end + def self.load_file(file); end + def self.merge(base_hash, derived_hash); end + def self.merge_with_default(config, config_file, unset_nil: _); end + def self.options_config; end + def self.options_config=(_); end + def self.possible_new_cops?(config); end + def self.warn_on_pending_cops(pending_cops); end +end + +RuboCop::ConfigLoader::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String) + +RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String) + +RuboCop::ConfigLoader::DOTFILE = T.let(T.unsafe(nil), String) + +RuboCop::ConfigLoader::RUBOCOP_HOME = T.let(T.unsafe(nil), String) + +RuboCop::ConfigLoader::XDG_CONFIG = T.let(T.unsafe(nil), String) + +class RuboCop::ConfigLoaderResolver + def merge(base_hash, derived_hash, **opts); end + def merge_with_default(config, config_file, unset_nil:); end + def override_department_setting_for_cops(base_hash, derived_hash); end + def resolve_inheritance(path, hash, file, debug); end + def resolve_inheritance_from_gems(hash); end + def resolve_requires(path, hash); end + + private + + def base_configs(path, inherit_from, file); end + def determine_inherit_mode(hash, key); end + def disabled?(hash, department); end + def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end + def gem_config_path(gem_name, relative_config_path); end + def handle_disabled_by_default(config, new_default_configuration); end + def inherited_file(path, inherit_from, file); end + def remote_file?(uri); end + def should_union?(base_hash, key, inherit_mode); end + def transform(config); end + def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end +end + +class RuboCop::ConfigNotFoundError < ::RuboCop::Error +end + +class RuboCop::ConfigObsoletion + def initialize(config); end + + def reject_obsolete_cops_and_parameters; end + + private + + def obsolete_cops; end + def obsolete_enforced_style; end + def obsolete_enforced_style_message(cop, param, enforced_style, alternative); end + def obsolete_parameter_message(cops, parameters, alternative); end + def obsolete_parameters; end + def smart_loaded_path; end +end + +RuboCop::ConfigObsoletion::MOVED_COPS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::OBSOLETE_COPS = T.let(T.unsafe(nil), Hash) + +RuboCop::ConfigObsoletion::OBSOLETE_ENFORCED_STYLES = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::OBSOLETE_PARAMETERS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::REMOVED_COPS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::REMOVED_COPS_WITH_REASON = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::RENAMED_COPS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigObsoletion::SPLIT_COPS = T.let(T.unsafe(nil), Array) + +class RuboCop::ConfigStore + def initialize; end + + def for(file_or_dir); end + def for_dir(dir); end + def for_file(file); end + def force_default_config!; end + def options_config=(options_config); end +end + +class RuboCop::ConfigValidator + extend(::Forwardable) + + def initialize(config); end + + def for_all_cops(*args, &block); end + def smart_loaded_path(*args, &block); end + def target_ruby_version; end + def validate; end + def validate_section_presence(name); end + + private + + def alert_about_unrecognized_cops(invalid_cop_names); end + def check_cop_config_value(hash, parent = _); end + def check_target_ruby; end + def each_invalid_parameter(cop_name); end + def msg_not_boolean(parent, key, value); end + def reject_conflicting_safe_settings; end + def reject_mutually_exclusive_defaults; end + def target_ruby; end + def validate_enforced_styles(valid_cop_names); end + def validate_new_cops_parameter; end + def validate_parameter_names(valid_cop_names); end + def validate_support_and_has_list(name, formats, valid); end + def validate_syntax_cop; end +end + +RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array) + +RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop +end + +module RuboCop::Cop::Alignment + + private + + def check_alignment(items, base_column = _); end + def column_delta; end + def configured_indentation_width; end + def display_column(range); end + def each_bad_alignment(items, base_column); end + def end_of_line_comment(line); end + def indentation(node); end + def offset(node); end + def within?(inner, outer); end +end + +RuboCop::Cop::Alignment::SPACE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::AlignmentCorrector + extend(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::Alignment) + + def self.align_end(processed_source, node, align_to); end + def self.correct(processed_source, node, column_delta); end + def self.processed_source; end +end + +class RuboCop::Cop::AmbiguousCopName < ::RuboCop::Error + def initialize(name, origin, badges); end +end + +RuboCop::Cop::AmbiguousCopName::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::ArrayMinSize + + private + + def array_style_detected(style, ary_size); end + def below_array_length?(node); end + def largest_brackets_size(style, ary_size); end + def min_size_config; end + def smallest_percent_size(style, ary_size); end +end + +module RuboCop::Cop::ArraySyntax + + private + + def bracketed_array_of?(element_type, node); end +end + +module RuboCop::Cop::AutocorrectLogic + def autocorrect?; end + def autocorrect_enabled?; end + def autocorrect_requested?; end + def correctable?; end + def disable_offense(node); end + def disable_uncorrectable?; end + def safe_autocorrect?; end + def support_autocorrect?; end + + private + + def disable_offense_at_end_of_line(range, eol_comment); end + def disable_offense_before_and_after(range_by_lines); end + def max_line_length; end + def range_by_lines(range); end + def range_of_first_line(range); end +end + +class RuboCop::Cop::Badge + def initialize(department, cop_name); end + + def ==(other); end + def cop_name; end + def department; end + def eql?(other); end + def hash; end + def match?(other); end + def qualified?; end + def to_s; end + def with_department(department); end + + def self.for(class_name); end + def self.parse(identifier); end +end + +class RuboCop::Cop::Badge::InvalidBadge < ::RuboCop::Error + def initialize(token); end +end + +RuboCop::Cop::Badge::InvalidBadge::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Bundler +end + +class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def gem_declarations(node0); end + def investigate(processed_source); end + + private + + def duplicated_gem_nodes; end + def register_offense(node, gem_name, line_of_first_occurrence); end +end + +RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::DefNode) + + def gem_declaration?(node = _); end + def on_send(node); end + + private + + def checked_options_present?(node); end + def commented?(node); end + def contains_checked_options?(node); end + def gem_options(node); end + def ignored_gem?(node); end + def precede?(node1, node2); end + def preceding_comment?(node1, node2); end + def preceding_lines(node); end + def version_specified_gem?(node); end +end + +RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def insecure_protocol_source?(node = _); end + def on_send(node); end + + private + + def range(node); end +end + +RuboCop::Cop::Bundler::InsecureProtocolSource::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::OrderedGemNode) + + def autocorrect(node); end + def gem_declarations(node0); end + def investigate(processed_source); end + + private + + def previous_declaration(node); end +end + +RuboCop::Cop::Bundler::OrderedGems::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::CheckAssignment + def on_and_asgn(node); end + def on_casgn(node); end + def on_cvasgn(node); end + def on_gvasgn(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_op_asgn(node); end + def on_or_asgn(node); end + def on_send(node); end + + private + + def extract_rhs(node); end + + def self.extract_rhs(node); end +end + +module RuboCop::Cop::CheckLineBreakable + def extract_breakable_node(node, max); end + + private + + def all_on_same_line?(nodes); end + def already_on_multiple_lines?(node); end + def breakable_collection?(node, elements); end + def children_could_be_broken_up?(children); end + def contained_by_breakable_collection_on_same_line?(node); end + def contained_by_multiline_collection_that_could_be_broken_up?(node); end + def extract_breakable_node_from_elements(node, elements, max); end + def extract_first_element_over_column_limit(node, elements, max); end + def process_args(args); end + def safe_to_ignore?(node); end + def within_column_limit?(element, max, line); end +end + +module RuboCop::Cop::ClassishLength + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + + + private + + def code_length(node); end + def line_numbers_of_inner_nodes(node, *types); end +end + +module RuboCop::Cop::CodeLength + include(::RuboCop::Cop::ConfigurableMax) + + + private + + def check_code_length(node); end + def count_comments?; end + def irrelevant_line(source_line); end + def max_length; end +end + +class RuboCop::Cop::Commissioner + include(::RuboCop::AST::Traversal) + + def initialize(cops, forces = _, options = _); end + + def errors; end + def investigate(processed_source); end + def on_alias(node); end + def on_and(node); end + def on_and_asgn(node); end + def on_arg(node); end + def on_arg_expr(node); end + def on_args(node); end + def on_array(node); end + def on_array_pattern(node); end + def on_array_pattern_with_tail(node); end + def on_back_ref(node); end + def on_begin(node); end + def on_block(node); end + def on_block_pass(node); end + def on_blockarg(node); end + def on_break(node); end + def on_case(node); end + def on_case_match(node); end + def on_casgn(node); end + def on_cbase(node); end + def on_class(node); end + def on_complex(node); end + def on_const(node); end + def on_const_pattern(node); end + def on_csend(node); end + def on_cvar(node); end + def on_cvasgn(node); end + def on_def(node); end + def on_defined?(node); end + def on_defs(node); end + def on_dstr(node); end + def on_dsym(node); end + def on_eflipflop(node); end + def on_empty_else(node); end + def on_ensure(node); end + def on_erange(node); end + def on_false(node); end + def on_float(node); end + def on_for(node); end + def on_forward_args(node); end + def on_forwarded_args(node); end + def on_gvar(node); end + def on_gvasgn(node); end + def on_hash(node); end + def on_hash_pattern(node); end + def on_if(node); end + def on_if_guard(node); end + def on_iflipflop(node); end + def on_in_match(node); end + def on_in_pattern(node); end + def on_int(node); end + def on_irange(node); end + def on_ivar(node); end + def on_ivasgn(node); end + def on_kwarg(node); end + def on_kwbegin(node); end + def on_kwoptarg(node); end + def on_kwrestarg(node); end + def on_kwsplat(node); end + def on_lambda(node); end + def on_lvar(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_match_alt(node); end + def on_match_as(node); end + def on_match_current_line(node); end + def on_match_nil_pattern(node); end + def on_match_rest(node); end + def on_match_var(node); end + def on_match_with_lvasgn(node); end + def on_match_with_trailing_comma(node); end + def on_mlhs(node); end + def on_module(node); end + def on_next(node); end + def on_nil(node); end + def on_not(node); end + def on_nth_ref(node); end + def on_numblock(node); end + def on_op_asgn(node); end + def on_optarg(node); end + def on_or(node); end + def on_or_asgn(node); end + def on_pair(node); end + def on_pin(node); end + def on_postexe(node); end + def on_preexe(node); end + def on_rational(node); end + def on_redo(node); end + def on_regexp(node); end + def on_regopt(node); end + def on_resbody(node); end + def on_rescue(node); end + def on_restarg(node); end + def on_retry(node); end + def on_return(node); end + def on_sclass(node); end + def on_self(node); end + def on_send(node); end + def on_shadowarg(node); end + def on_splat(node); end + def on_str(node); end + def on_super(node); end + def on_sym(node); end + def on_true(node); end + def on_undef(node); end + def on_unless_guard(node); end + def on_until(node); end + def on_until_post(node); end + def on_when(node); end + def on_while(node); end + def on_while_post(node); end + def on_xstr(node); end + def on_yield(node); end + def on_zsuper(node); end + + private + + def invoke_custom_post_walk_processing(cops, processed_source); end + def invoke_custom_processing(cops_or_forces, processed_source); end + def prepare(processed_source); end + def reset_callbacks; end + def reset_errors; end + def trigger_responding_cops(callback, node); end + def with_cop_error_handling(cop, node = _); end +end + +class RuboCop::Cop::ConditionCorrector + def self.correct_negative_condition(node); end +end + +module RuboCop::Cop::ConfigurableEnforcedStyle + def alternative_style; end + def alternative_styles; end + def ambiguous_style_detected(*possibilities); end + def conflicting_styles_detected; end + def correct_style_detected; end + def detected_style; end + def detected_style=(style); end + def no_acceptable_style!; end + def no_acceptable_style?; end + def opposite_style_detected; end + def style; end + def style_configured?; end + def style_detected(detected); end + def style_parameter_name; end + def supported_styles; end + def unexpected_style_detected(unexpected); end + def unrecognized_style_detected; end +end + +module RuboCop::Cop::ConfigurableFormatting + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def check_name(node, name, name_range); end + def class_emitter_method?(node, name); end + def report_opposing_styles(node, name); end + def valid_name?(node, name, given_style = _); end +end + +module RuboCop::Cop::ConfigurableMax + + private + + def max=(value); end + def max_parameter_name; end +end + +module RuboCop::Cop::ConfigurableNaming + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) +end + +RuboCop::Cop::ConfigurableNaming::FORMATS = T.let(T.unsafe(nil), Hash) + +module RuboCop::Cop::ConfigurableNumbering + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) +end + +RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Cop + include(::RuboCop::AST::Sexp) + include(::RuboCop::PathUtil) + include(::RuboCop::Cop::Util) + include(::RuboCop::Cop::IgnoredNode) + include(::RuboCop::Cop::AutocorrectLogic) + extend(::RuboCop::AST::Sexp) + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(config = _, options = _); end + + def add_offense(node, location: _, message: _, severity: _); end + def config; end + def config_to_allow_offenses; end + def config_to_allow_offenses=(hash); end + def cop_config; end + def cop_name; end + def correct(node); end + def corrections; end + def disable_uncorrectable(node); end + def duplicate_location?(location); end + def excluded_file?(file); end + def external_dependency_checksum; end + def find_location(node, loc); end + def join_force?(_force_class); end + def message(_node = _); end + def name; end + def offenses; end + def parse(source, path = _); end + def processed_source; end + def processed_source=(_); end + def reason_to_not_correct(node); end + def relevant_file?(file); end + def target_rails_version; end + def target_ruby_version; end + + private + + def annotate(message); end + def custom_severity; end + def default_severity; end + def enabled_line?(line_number); end + def file_name_matches_any?(file, parameter, default_result); end + def find_message(node, message); end + def find_severity(_node, severity); end + + def self.all; end + def self.autocorrect_incompatible_with; end + def self.badge; end + def self.cop_name; end + def self.department; end + def self.exclude_from_registry; end + def self.inherited(subclass); end + def self.lint?; end + def self.match?(given_names); end + def self.qualified_cop_name(name, origin); end + def self.registry; end +end + +class RuboCop::Cop::Cop::Correction < ::Struct + def call(corrector); end + def cop; end + def cop=(_); end + def lambda; end + def lambda=(_); end + def node; end + def node=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RuboCop::Cop::Corrector + def initialize(source_buffer, corrections = _); end + + def corrections; end + def diagnostics; end + def insert_after(node_or_range, content); end + def insert_before(node_or_range, content); end + def remove(node_or_range); end + def remove_leading(node_or_range, size); end + def remove_preceding(node_or_range, size); end + def remove_trailing(node_or_range, size); end + def replace(node_or_range, content); end + def rewrite; end + def wrap(node_or_range, before, after); end + + private + + def to_range(node_or_range); end + def validate_buffer(buffer); end +end + +module RuboCop::Cop::DefNode + extend(::RuboCop::AST::NodePattern::Macros) + + def non_public_modifier?(node = _); end + + private + + def non_public?(node); end + def preceding_non_public_modifier?(node); end + def stripped_source_upto(index); end +end + +RuboCop::Cop::DefNode::NON_PUBLIC_MODIFIERS = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::DocumentationComment + include(::RuboCop::Cop::Style::AnnotationComment) + extend(::RuboCop::AST::NodePattern::Macros) + + + private + + def documentation_comment?(node); end + def interpreter_directive_comment?(comment); end + def precede?(node1, node2); end + def preceding_comment?(node1, node2); end + def preceding_lines(node); end + def rubocop_directive_comment?(comment); end +end + +module RuboCop::Cop::Duplication + + private + + def consecutive_duplicates(collection); end + def duplicates(collection); end + def duplicates?(collection); end + def grouped_duplicates(collection); end +end + +class RuboCop::Cop::EachToForCorrector + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(block_node); end + + def call(corrector); end + + private + + def argument_node; end + def block_node; end + def collection_node; end + def correction; end + def offending_range; end + def replacement_range(end_pos); end +end + +RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::EmptyLineCorrector + def self.correct(node); end + def self.insert_before(node); end +end + +module RuboCop::Cop::EmptyParameter + extend(::RuboCop::AST::NodePattern::Macros) + + def empty_arguments?(node = _); end + + private + + def check(node); end +end + +module RuboCop::Cop::EndKeywordAlignment + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + + private + + def accept_end_kw_alignment?(end_loc); end + def add_offense_for_misalignment(node, align_with); end + def check_end_kw_alignment(node, align_ranges); end + def check_end_kw_in_node(node); end + def line_break_before_keyword?(whole_expression, rhs); end + def matching_ranges(end_loc, align_ranges); end + def style_parameter_name; end + def variable_alignment?(whole_expression, rhs, end_alignment_style); end +end + +RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::EnforceSuperclass + def on_class(node); end + def on_send(node); end + + def self.included(base); end +end + +module RuboCop::Cop::FirstElementLineBreak + + private + + def check_children_line_break(node, children, start = _); end + def check_method_line_break(node, children); end + def first_by_line(nodes); end + def last_by_line(nodes); end + def method_uses_parens?(node, limit); end +end + +class RuboCop::Cop::ForToEachCorrector + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(for_node); end + + def call(corrector); end + + private + + def collection_end; end + def collection_node; end + def collection_source; end + def correction; end + def end_position; end + def for_node; end + def keyword_begin; end + def offending_range; end + def replacement_range(end_pos); end + def requires_parentheses?; end + def variable_node; end +end + +RuboCop::Cop::ForToEachCorrector::CORRECTION = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Force + def initialize(cops); end + + def cops; end + def investigate(_processed_source); end + def name; end + def run_hook(method_name, *args); end + + def self.all; end + def self.force_name; end + def self.inherited(subclass); end +end + +module RuboCop::Cop::FrozenStringLiteral + + private + + def frozen_string_literal_comment_exists?; end + def frozen_string_literal_specified?; end + def frozen_string_literals_enabled?; end + def leading_comment_lines; end + + def self.frozen_string_literal_comment_exists?; end +end + +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_ENABLED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::Gemspec +end + +class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def assignment_method_declarations(node0); end + def gem_specification(node0); end + def investigate(processed_source); end + + private + + def assignment_method?(method_name); end + def duplicated_assignment_method_nodes; end + def match_block_variable_name?(receiver_name); end + def register_offense(node, assignment, line_of_first_occurrence); end +end + +RuboCop::Cop::Gemspec::DuplicatedAssignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::OrderedGemNode) + + def autocorrect(node); end + def dependency_declarations(node0); end + def investigate(processed_source); end + + private + + def get_dependency_name(node); end + def previous_declaration(node); end +end + +RuboCop::Cop::Gemspec::OrderedDependencies::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Cop + def investigate(processed_source); end + def required_ruby_version(node0); end + + private + + def extract_ruby_version(required_ruby_version); end + def message(required_ruby_version, target_ruby_version); end +end + +RuboCop::Cop::Gemspec::RequiredRubyVersion::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Cop + def gem_specification?(node0); end + def on_const(node); end + def ruby_version?(node = _); end + + private + + def gem_spec_with_ruby_version?(node); end +end + +RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Generator + def initialize(name, github_user, output: _); end + + def inject_config(config_file_path: _, version_added: _); end + def inject_require(root_file_path: _); end + def todo; end + def write_source; end + def write_spec; end + + private + + def badge; end + def bump_minor_version; end + def generate(template); end + def generated_source; end + def generated_spec; end + def github_user; end + def output; end + def snake_case(camel_case_string); end + def source_path; end + def spec_path; end + def write_unless_file_exists(path, contents); end +end + +RuboCop::Cop::Generator::CONFIGURATION_ADDED_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Generator::ConfigurationInjector + def initialize(configuration_file_path:, badge:, version_added:); end + + def inject; end + + private + + def badge; end + def configuration_entries; end + def configuration_file_path; end + def cop_name_line?(yaml); end + def find_target_line; end + def new_configuration_entry; end + def output; end + def version_added; end +end + +RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Generator::RequireFileInjector + def initialize(source_path:, root_file_path:, output: _); end + + def inject; end + + private + + def injectable_require_directive; end + def output; end + def require_entries; end + def require_exists?; end + def require_path; end + def require_path_fragments(require_directove); end + def root_file_path; end + def source_path; end + def target_line; end + def updated_directives; end +end + +RuboCop::Cop::Generator::RequireFileInjector::REQUIRE_PATH = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Generator::SOURCE_TEMPLATE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Generator::SPEC_TEMPLATE = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::HashAlignmentStyles +end + +class RuboCop::Cop::HashAlignmentStyles::KeyAlignment + def checkable_layout?(_node); end + def deltas(first_pair, current_pair); end + def deltas_for_first_pair(first_pair, _node); end + + private + + def separator_delta(pair); end + def value_delta(pair); end +end + +class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment + include(::RuboCop::Cop::HashAlignmentStyles::ValueAlignment) + + def deltas_for_first_pair(*_nodes); end + + private + + def hash_rocket_delta(first_pair, current_pair); end + def key_delta(first_pair, current_pair); end + def value_delta(first_pair, current_pair); end +end + +class RuboCop::Cop::HashAlignmentStyles::TableAlignment + include(::RuboCop::Cop::HashAlignmentStyles::ValueAlignment) + + def initialize; end + + def deltas_for_first_pair(first_pair, node); end + + private + + def hash_rocket_delta(first_pair, current_pair); end + def key_delta(first_pair, current_pair); end + def max_key_width; end + def max_key_width=(_); end + def value_delta(first_pair, current_pair); end +end + +module RuboCop::Cop::HashAlignmentStyles::ValueAlignment + def checkable_layout?(node); end + def deltas(first_pair, current_pair); end + + private + + def separator_delta(first_pair, current_pair, key_delta); end +end + +module RuboCop::Cop::HashTransformMethod + def autocorrect(node); end + def on_block(node); end + def on_csend(node); end + def on_send(node); end + + private + + def execute_correction(corrector, node, correction); end + def extract_captures(_match); end + def handle_possible_offense(node, match, match_desc); end + def new_method_name; end + def on_bad_each_with_object(_node); end + def on_bad_hash_brackets_map(_node); end + def on_bad_map_to_h(_node); end + def prepare_correction(node); end +end + +class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct + def block_node; end + def block_node=(_); end + def leading; end + def leading=(_); end + def match; end + def match=(_); end + def set_new_arg_name(transformed_argname, corrector); end + def set_new_body_expression(transforming_body_expr, corrector); end + def set_new_method_name(new_method_name, corrector); end + def strip_prefix_and_suffix(node, corrector); end + def trailing; end + def trailing=(_); end + + def self.[](*_); end + def self.from_each_with_object(node, match); end + def self.from_hash_brackets_map(node, match); end + def self.from_map_to_h(node, match); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RuboCop::Cop::HashTransformMethod::Captures < ::Struct + def noop_transformation?; end + def transformation_uses_both_args?; end + def transformed_argname; end + def transformed_argname=(_); end + def transforming_body_expr; end + def transforming_body_expr=(_); end + def unchanged_body_expr; end + def unchanged_body_expr=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RuboCop::Cop::Heredoc + def on_dstr(node); end + def on_heredoc(_node); end + def on_str(node); end + def on_xstr(node); end + + private + + def delimiter_string(node); end + def heredoc_type(node); end +end + +RuboCop::Cop::Heredoc::OPENING_DELIMITER = T.let(T.unsafe(nil), Regexp) + +module RuboCop::Cop::IgnoredMethods + + private + + def ignored_method?(name); end + def ignored_methods; end +end + +module RuboCop::Cop::IgnoredNode + def ignore_node(node); end + def ignored_node?(node); end + def part_of_ignored_node?(node); end + + private + + def ignored_nodes; end +end + +module RuboCop::Cop::IgnoredPattern + + private + + def ignored_line?(line); end + def ignored_patterns; end + def matches_ignored_pattern?(line); end +end + +module RuboCop::Cop::IntegerNode + + private + + def integer_part(node); end +end + +module RuboCop::Cop::Interpolation + def on_dstr(node); end + def on_dsym(node); end + def on_node_with_interpolations(node); end + def on_regexp(node); end + def on_xstr(node); end +end + +class RuboCop::Cop::LambdaLiteralToMethodCorrector + def initialize(block_node); end + + def call(corrector); end + + private + + def arg_to_unparenthesized_call?; end + def arguments; end + def arguments_begin_pos; end + def arguments_end_pos; end + def block_begin; end + def block_end; end + def block_node; end + def insert_arguments(corrector); end + def insert_separating_space(corrector); end + def lambda_arg_string; end + def method; end + def needs_separating_space?; end + def remove_arguments(corrector); end + def remove_leading_whitespace(corrector); end + def remove_trailing_whitespace(corrector); end + def remove_unparenthesized_whitespace(corrector); end + def replace_delimiters(corrector); end + def replace_selector(corrector); end + def selector_end; end + def separating_space?; end +end + +module RuboCop::Cop::Layout +end + +class RuboCop::Cop::Layout::AccessModifierIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + def on_class(node); end + def on_module(node); end + def on_sclass(node); end + + private + + def check_body(body, node); end + def check_modifier(send_node, end_range); end + def expected_indent_offset; end + def message(node); end + def unexpected_indent_offset; end +end + +RuboCop::Cop::Layout::AccessModifierIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ArgumentAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def base_column(node, args); end + def fixed_indentation?; end + def message(_node); end + def target_method_lineno(node); end +end + +RuboCop::Cop::Layout::ArgumentAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ArgumentAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ArrayAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_array(node); end + + private + + def base_column(node, args); end + def fixed_indentation?; end + def message(_node); end + def target_method_lineno(node); end +end + +RuboCop::Cop::Layout::ArrayAlignment::ALIGN_ELEMENTS_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ArrayAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::AssignmentIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::CheckAssignment) + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def check_assignment(node, rhs); end + def leftmost_multiple_assignment(node); end +end + +RuboCop::Cop::Layout::AssignmentIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def block_end_align_target?(node = _, param1); end + def on_block(node); end + def style_parameter_name; end + + private + + def add_space_before(loc, delta); end + def alt_start_msg(start_loc, source_line_column); end + def block_end_align_target(node); end + def check_block_alignment(start_node, block_node); end + def compute_do_source_line_column(node, end_loc); end + def compute_start_col(ancestor_node, node); end + def disqualified_parent?(parent, node); end + def end_align_target?(node, parent); end + def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end + def format_source_line_column(source_line_column); end + def loc_to_source_line_column(loc); end + def register_offense(block_node, start_loc, end_loc, do_source_line_column); end + def remove_space_before(end_pos, delta); end + def start_for_block_node(block_node); end +end + +RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::BlockEndNewline < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_block(node); end + + private + + def delimiter_range(node); end + def message(node); end +end + +RuboCop::Cop::Layout::BlockEndNewline::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_case(case_node); end + + private + + def base_column(case_node, base); end + def check_when(when_node); end + def incorrect_style(when_node); end + def indent_one_step?; end + def indentation_width; end + def message(base); end + def replacement(node); end + def whitespace_range(node); end +end + +RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_class(class_node); end + def visibility_block?(node = _); end + + private + + def begin_pos_with_comment(node); end + def buffer; end + def categories; end + def class_elements(class_node); end + def classify(node); end + def end_position_for(node); end + def expected_order; end + def find_category(node); end + def find_visibility_end(node); end + def find_visibility_start(node); end + def humanize_node(node); end + def ignore?(classification); end + def left_siblings_of(node); end + def node_visibility(node); end + def right_siblings_of(node); end + def siblings_of(node); end + def source_range_with_comment(node); end + def start_line_position(node); end + def walk_over_nested_class_definition(class_node); end +end + +RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ClassStructure::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Heredoc) + + def autocorrect(node); end + def on_heredoc(node); end + + private + + def argument_indentation_correct?(node); end + def closing_indentation(node); end + def find_node_used_heredoc_argument(node); end + def heredoc_closing(node); end + def heredoc_opening(node); end + def indent_level(source_line); end + def indented_end(node); end + def message(node); end + def opening_indentation(node); end +end + +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ClosingParenthesisIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_begin(node); end + def on_csend(node); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end + + private + + def all_elements_aligned?(elements); end + def check(node, elements); end + def check_for_elements(node, elements); end + def check_for_no_elements(node); end + def correct_column_candidates(node, left_paren); end + def expected_column(left_paren, elements); end + def first_argument_line(elements); end + def indentation_width; end + def line_break_after_left_paren?(left_paren, elements); end + def message(correct_column, left_paren, right_paren); end +end + +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_INDENT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::CommentIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(comment); end + def investigate(processed_source); end + + private + + def autocorrect_one(comment); end + def autocorrect_preceding_comments(comment); end + def check(comment); end + def correct_indentation(next_line); end + def less_indented?(line); end + def line_after_comment(comment); end + def message(column, correct_comment_indentation); end + def own_line_comment?(comment); end + def should_correct?(preceding_comment, reference_comment); end + def two_alternatives?(line); end +end + +RuboCop::Cop::Layout::CommentIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ConditionPosition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_if(node); end + def on_until(node); end + def on_while(node); end + + private + + def check(node); end + def message(node); end +end + +RuboCop::Cop::Layout::ConditionPosition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::EndKeywordAlignment) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end +end + +RuboCop::Cop::Layout::DefEndAlignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::DotPosition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def ampersand_dot?(node); end + def correct_dot_position_style?(dot_line, selector_line); end + def line_between?(first_line, second_line); end + def message(node); end + def proper_dot_position?(node); end + def selector_range(node); end +end + +class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::EndKeywordAlignment) + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::CheckAssignment) + + def autocorrect(node); end + def on_case(node); end + def on_case_match(node); end + def on_if(node, base = _); end + def on_rescue(node); end + + private + + def base_for_method_definition(node); end + def base_range_of_if(node, base); end + def base_range_of_rescue(node); end + def check_alignment(base_range, else_range); end + def check_assignment(node, rhs); end + def check_nested(node, base); end +end + +RuboCop::Cop::Layout::ElseAlignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyComment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def investigate(processed_source); end + + private + + def allow_border_comment?; end + def allow_margin_comment?; end + def comment_text(comment); end + def concat_consecutive_comments(comments); end + def current_token(comment); end + def empty_comment_only?(comment_text); end + def previous_token(node); end +end + +RuboCop::Cop::Layout::EmptyComment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_if(node); end + + private + + def contains_guard_clause?(node); end + def correct_style?(node); end + def heredoc?(node); end + def heredoc_line(node, heredoc_node); end + def last_argument_is_heredoc?(node); end + def last_heredoc_argument(node); end + def next_line_empty?(line); end + def next_line_rescue_or_ensure?(node); end + def next_sibling_empty_or_guard_clause?(node); end + def next_sibling_parent_empty_or_else?(node); end + def offense_location(node); end +end + +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::END_OF_HEREDOC_LINE = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(token); end + def investigate(source); end + + private + + def last_magic_comment(source); end +end + +RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def check_defs(nodes); end + def on_begin(node); end + + private + + def autocorrect_insert_lines(newline_pos, count); end + def autocorrect_remove_lines(newline_pos, count); end + def blank_lines_between?(first_def_node, second_def_node); end + def blank_lines_count_between(first_def_node, second_def_node); end + def def_end(node); end + def def_node?(node); end + def def_start(node); end + def lines_between_defs(first_def_node, second_def_node); end + def maximum_empty_lines; end + def minimum_empty_lines; end + def multiple_blank_lines_groups?(first_def_node, second_def_node); end + def prev_node(node); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def each_extra_empty_line(lines); end + def exceeds_line_offset?(line_diff); end + def previous_and_current_lines_empty?(line); end +end + +RuboCop::Cop::Layout::EmptyLines::LINE_OFFSET = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Layout::EmptyLines::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def initialize(config = _, options = _); end + + def autocorrect(node); end + def on_block(node); end + def on_class(node); end + def on_module(node); end + def on_sclass(node); end + def on_send(node); end + + private + + def allowed_only_before_style?(node); end + def block_start?(line); end + def body_end?(line); end + def class_def?(line); end + def correct_next_line_if_denied_style(corrector, node, line); end + def empty_lines_around?(node); end + def message(node); end + def message_for_around_style(node); end + def message_for_only_before_style(node); end + def next_empty_line_range(node); end + def next_line_empty?(last_send_line); end + def previous_line_empty?(send_line); end + def previous_line_ignoring_comments(processed_source, send_line); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundArguments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def empty_lines(node); end + def extra_lines(node); end + def inner_lines(node); end + def line_numbers(node); end + def outer_lines(node); end + def processed_lines(node); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundArguments::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + + private + + def allow_alias?(node); end + def allow_alias_syntax?; end + def allowed_method?(name); end + def allowed_methods; end + def attribute_or_allowed_method?(node); end + def next_line_empty?(line); end + def next_line_node(node); end + def require_empty_line?(node); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_kwbegin(node); end + + private + + def style; end +end + +RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::KIND = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_block(node); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::KIND = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Layout::EmptyLinesAroundBody + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::AST::NodePattern::Macros) + + def constant_definition?(node = _); end + def empty_line_required?(node = _); end + + private + + def check(node, body, adjusted_first_line: _); end + def check_beginning(style, first_line); end + def check_both(style, first_line, last_line); end + def check_deferred_empty_line(body); end + def check_empty_lines_except_namespace(body, first_line, last_line); end + def check_empty_lines_special(body, first_line, last_line); end + def check_ending(style, last_line); end + def check_line(style, line, msg); end + def check_source(style, line_no, desc); end + def deferred_message(node); end + def first_child_requires_empty_line?(body); end + def first_empty_line_required_child(body); end + def message(type, desc); end + def namespace?(body, with_one_child: _); end + def previous_line_ignoring_comments(send_line); end + def valid_body_style?(body); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_EXTRA = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_MISSING = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_class(node); end + def on_sclass(node); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundClassBody::KIND = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + def on_kwbegin(node); end + + private + + def check_body(node); end + def keyword_locations(node); end + def keyword_locations_in_ensure(node); end + def keyword_locations_in_rescue(node); end + def message(location, keyword); end + def style; end +end + +RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def style; end +end + +RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::KIND = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::Layout::EmptyLinesAroundBody) + + def autocorrect(node); end + def on_module(node); end +end + +RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::KIND = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::CheckAssignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::EndKeywordAlignment) + + def autocorrect(node); end + def on_case(node); end + def on_class(node); end + def on_if(node); end + def on_module(node); end + def on_until(node); end + def on_while(node); end + + private + + def alignment_node(node); end + def alignment_node_for_variable_style(node); end + def asgn_variable_align_with(outer_node, inner_node); end + def check_asgn_alignment(outer_node, inner_node); end + def check_assignment(node, rhs); end + def check_other_alignment(node); end + def start_line_range(node); end +end + +class RuboCop::Cop::Layout::EndOfLine < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + def offense_message(line); end + def unimportant_missing_cr?(index, last_line, line); end + + private + + def last_line(processed_source); end +end + +RuboCop::Cop::Layout::EndOfLine::MSG_DETECTED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::EndOfLine::MSG_MISSING = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::PrecedingFollowingAlignment) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def align_column(asgn_token); end + def align_equal_sign(corrector, token, align_to); end + def align_equal_signs(range, corrector); end + def aligned_comments?(comment_token); end + def aligned_tok?(token); end + def aligned_with_next_comment?(index); end + def aligned_with_previous_comment?(index); end + def all_relevant_assignment_lines(line_number); end + def allow_for_trailing_comments?; end + def check_assignment(token); end + def check_other(token1, token2, ast); end + def check_tokens(ast, token1, token2); end + def comment_column(index); end + def extra_space_range(token1, token2); end + def force_equal_sign_alignment?; end + def ignored_range?(ast, start_pos); end + def ignored_ranges(ast); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def eligible_method_call?(node = _); end + def on_csend(node); end + def on_send(node); end + + private + + def base_indentation(node); end + def base_range(send_node, arg_node); end + def column_of(range); end + def comment_lines; end + def message(arg_node); end + def previous_code_line(line_number); end + def special_inner_call_indentation?(node); end +end + +RuboCop::Cop::Layout::FirstArgumentIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstArrayElementIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineElementIndentation) + + def autocorrect(node); end + def on_array(node); end + def on_csend(node); end + def on_send(node); end + + private + + def base_description(left_parenthesis); end + def brace_alignment_style; end + def check(array_node, left_parenthesis); end + def check_right_bracket(right_bracket, left_bracket, left_parenthesis); end + def message(base_description); end + def msg(left_parenthesis); end +end + +RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FirstElementLineBreak) + + def autocorrect(node); end + def on_array(node); end + + private + + def assignment_on_same_line?(node); end +end + +RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineElementIndentation) + + def autocorrect(node); end + def on_csend(node); end + def on_hash(node); end + def on_send(node); end + + private + + def base_description(left_parenthesis); end + def brace_alignment_style; end + def check(hash_node, left_parenthesis); end + def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end + def check_right_brace(right_brace, left_brace, left_parenthesis); end + def message(base_description); end + def separator_style?(first_pair); end +end + +RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FirstElementLineBreak) + + def autocorrect(node); end + def on_hash(node); end +end + +RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FirstElementLineBreak) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + def on_super(node); end +end + +RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FirstElementLineBreak) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::FirstParameterIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineElementIndentation) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def base_description(_); end + def brace_alignment_style; end + def check(def_node); end + def message(base_description); end +end + +RuboCop::Cop::Layout::FirstParameterIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::HashAlignmentStyles) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def column_deltas; end + def column_deltas=(_); end + def offences_by; end + def offences_by=(_); end + def on_hash(node); end + def on_send(node); end + def on_super(node); end + def on_yield(node); end + + private + + def add_offences; end + def adjust(corrector, delta, range); end + def alignment_for(pair); end + def alignment_for_colons; end + def alignment_for_hash_rockets; end + def check_delta(delta, node:, alignment:); end + def check_pairs(node); end + def correct_key_value(delta, key, value, separator); end + def correct_no_value(key_delta, key); end + def correct_node(node, delta); end + def double_splat?(node); end + def good_alignment?(column_deltas); end + def ignore_hash_argument?(node); end + def new_alignment(key); end + def reset!; end +end + +RuboCop::Cop::Layout::HashAlignment::MESSAGES = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + + private + + def add_correct_closing_paren(node, corrector); end + def add_correct_external_trailing_comma(node, corrector); end + def external_trailing_comma?(node); end + def external_trailing_comma_offset_from_loc_end(node); end + def extract_heredoc(node); end + def extract_heredoc_argument(node); end + def fix_closing_parenthesis(node, corrector); end + def fix_external_trailing_comma(node, corrector); end + def heredoc_node?(node); end + def incorrect_parenthesis_removal_begin(node); end + def incorrect_parenthesis_removal_end(node); end + def internal_trailing_comma?(node); end + def internal_trailing_comma_offset_from_last_arg(node); end + def outermost_send_on_same_line(heredoc); end + def remove_incorrect_closing_paren(node, corrector); end + def remove_incorrect_external_trailing_comma(node, corrector); end + def remove_internal_trailing_comma(node, corrector); end + def safe_to_remove_line_containing_closing_paren?(node); end + def send_missing_closing_parens?(parent, child, heredoc); end + def single_line_send_with_heredoc_receiver?(node); end + def space?(pos); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Heredoc) + + def autocorrect(node); end + def on_heredoc(node); end + + private + + def adjust_minus(corrector, node); end + def adjust_squiggly(corrector, node); end + def base_indent_level(node); end + def heredoc_body(node); end + def heredoc_end(node); end + def heredoc_indent_type(node); end + def indent_level(str); end + def indentation_width; end + def indented_body(node); end + def indented_end(node); end + def line_too_long?(node); end + def longest_line(lines); end + def max_line_length; end + def message(node); end + def type_message(indentation_width, current_indent_type); end + def unlimited_heredoc_length?; end + def width_message(indentation_width); end +end + +RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::IndentationConsistency < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_begin(node); end + def on_kwbegin(node); end + + private + + def bare_access_modifier?(node); end + def base_column_for_normal_style(node); end + def check(node); end + def check_indented_internal_methods_style(node); end + def check_normal_style(node); end +end + +RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def autocorrect_lambda_for_spaces(range); end + def autocorrect_lambda_for_tabs(range); end + def find_offence(line); end + def in_string_literal?(ranges, tabs_range); end + def message(_node); end + def string_literal_ranges(ast); end +end + +RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::EndKeywordAlignment) + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::CheckAssignment) + include(::RuboCop::Cop::IgnoredPattern) + + def access_modifier?(node = _); end + def autocorrect(node); end + def on_block(node); end + def on_case(case_node); end + def on_class(node); end + def on_csend(node); end + def on_def(node); end + def on_defs(node); end + def on_ensure(node); end + def on_for(node); end + def on_if(node, base = _); end + def on_kwbegin(node); end + def on_module(node); end + def on_resbody(node); end + def on_rescue(node); end + def on_sclass(node); end + def on_send(node); end + def on_until(node, base = _); end + def on_while(node, base = _); end + + private + + def access_modifier_indentation_style; end + def check_assignment(node, rhs); end + def check_if(node, body, else_clause, base_loc); end + def check_indentation(base_loc, body_node, style = _); end + def check_members(base, members); end + def check_members_for_indented_internal_methods_style(members); end + def check_members_for_normal_style(base, members); end + def configured_indentation_width; end + def each_member(members); end + def indentation_consistency_style; end + def indentation_to_check?(base_loc, body_node); end + def indented_internal_methods_style?; end + def leftmost_modifier_of(node); end + def message(configured_indentation_width, indentation, name); end + def offending_range(body_node, indentation); end + def offense(body_node, indentation, style); end + def other_offense_in_same_range?(node); end + def select_check_member(member); end + def skip_check?(base_loc, body_node); end + def special_modifier?(node); end + def starts_with_access_modifier?(body_node); end +end + +RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::InitialIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(_processed_source); end + + private + + def first_token; end + def space_before(token); end +end + +RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(comment); end + def investigate(processed_source); end + + private + + def allow_doxygen_comment?; end + def allow_gemfile_ruby_comment?; end + def allowed_on_first_line?(comment); end + def doxygen_comment_style?(comment); end + def gemfile?; end + def gemfile_ruby_comment?(comment); end + def rackup_config_file?; end + def rackup_options?(comment); end + def ruby_comment_in_gemfile?(comment); end + def shebang?(comment); end +end + +RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::LeadingEmptyLines < ::RuboCop::Cop::Cop + def autocorrect(node); end + def investigate(processed_source); end +end + +RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::CheckLineBreakable) + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IgnoredPattern) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::LineLengthHelp) + + def autocorrect(range); end + def investigate(processed_source); end + def investigate_post_walk(processed_source); end + def on_array(node); end + def on_block(node); end + def on_hash(node); end + def on_potential_breakable_node(node); end + def on_send(node); end + + private + + def allow_heredoc?; end + def allowed_heredoc; end + def breakable_block_range(block_node); end + def breakable_range_after_semicolon(semicolon_token); end + def breakable_range_by_line_index; end + def check_directive_line(line, line_index); end + def check_for_breakable_block(block_node); end + def check_for_breakable_node(node); end + def check_for_breakable_semicolons(processed_source); end + def check_line(line, line_index); end + def check_uri_line(line, line_index); end + def excess_range(uri_range, line, line_index); end + def extract_heredocs(ast); end + def heredocs; end + def highlight_start(line); end + def ignored_line?(line, line_index); end + def line_in_heredoc?(line_number); end + def line_in_permitted_heredoc?(line_number); end + def max; end + def register_offense(loc, line, line_index); end + def shebang?(line, line_index); end +end + +RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineLiteralBraceLayout) + + def autocorrect(node); end + def on_array(node); end +end + +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineArrayBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MultilineElementLineBreaks) + + def autocorrect(node); end + def on_array(node); end +end + +RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineAssignmentLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::CheckAssignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def check_assignment(node, rhs); end + def check_by_enforced_style(node, rhs); end + def check_new_line_offense(node, rhs); end + def check_same_line_offense(node, rhs); end + + private + + def supported_types; end +end + +RuboCop::Cop::Layout::MultilineAssignmentLayout::NEW_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineAssignmentLayout::SAME_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + + private + + def add_offense_for_expression(node, expr, msg); end + def args_on_beginning_line?(node); end + def autocorrect_arguments(corrector, node); end + def autocorrect_body(corrector, node, block_body); end + def block_arg_string(node, args); end + def include_trailing_comma?(args); end + def line_break_necessary_in_args?(node); end +end + +RuboCop::Cop::Layout::MultilineBlockLayout::ARG_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineBlockLayout::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineBlockLayout::PIPE_SIZE = T.let(T.unsafe(nil), Integer) + +class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineLiteralBraceLayout) + + def autocorrect(node); end + def on_hash(node); end +end + +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineHashBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MultilineElementLineBreaks) + + def autocorrect(node); end + def on_hash(node); end + + private + + def starts_with_curly_brace?(node); end +end + +RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MultilineElementLineBreaks) + + def autocorrect(node); end + def on_send(node); end +end + +RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineLiteralBraceLayout) + + def autocorrect(node); end + def on_send(node); end + + private + + def children(node); end + def ignored_literal?(node); end + def single_line_ignoring_receiver?(node); end +end + +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::MultilineExpressionIndentation) + + def autocorrect(node); end + def validate_config; end + + private + + def align_with_base_message(rhs); end + def alignment_base(node, rhs, given_style); end + def base_source; end + def extra_indentation(given_style); end + def message(node, lhs, rhs); end + def no_base_message(lhs, rhs, node); end + def offending_range(node, lhs, rhs, given_style); end + def operation_rhs(node); end + def operator_rhs?(node, receiver); end + def receiver_alignment_base(node); end + def relative_to_receiver_message(rhs); end + def relevant_node?(send_node); end + def semantic_alignment_base(node, rhs); end + def semantic_alignment_node(node); end + def should_align_with_base?; end + def should_indent_relative_to_receiver?; end + def syntactic_alignment_base(lhs, rhs); end +end + +class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineLiteralBraceLayout) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::MultilineOperationIndentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::MultilineExpressionIndentation) + + def autocorrect(node); end + def on_and(node); end + def on_or(node); end + def validate_config; end + + private + + def check_and_or(node); end + def message(node, lhs, rhs); end + def offending_range(node, lhs, rhs, given_style); end + def relevant_node?(node); end + def should_align?(node, rhs, given_style); end +end + +class RuboCop::Cop::Layout::ParameterAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def base_column(node, args); end + def fixed_indentation?; end + def message(_node); end + def target_method_lineno(node); end +end + +RuboCop::Cop::Layout::ParameterAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def investigate(processed_source); end + def on_ensure(node); end + def on_resbody(node); end + + private + + def access_modifier?(node); end + def access_modifier_node(node); end + def alignment_node(node); end + def alignment_source(node, starting_loc); end + def ancestor_node(node); end + def assignment_node(node); end + def check(node); end + def format_message(alignment_node, alignment_loc, kw_loc); end + def modifier?(node); end + def whitespace_range(node); end +end + +RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::RescueEnsureAlignment::RUBY_2_5_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Layout::SpaceAfterColon < ::RuboCop::Cop::Cop + def autocorrect(range); end + def on_kwoptarg(node); end + def on_pair(node); end + + private + + def followed_by_space?(colon); end +end + +RuboCop::Cop::Layout::SpaceAfterColon::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::SpaceAfterPunctuation) + + def autocorrect(comma); end + def kind(token); end + def space_style_before_rcurly; end +end + +class RuboCop::Cop::Layout::SpaceAfterMethodName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(pos_before_left_paren); end + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Layout::SpaceAfterMethodName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def whitespace_after_operator?(node); end +end + +RuboCop::Cop::Layout::SpaceAfterNot::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAfterSemicolon < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::SpaceAfterPunctuation) + + def autocorrect(semicolon); end + def kind(token); end + def space_style_before_rcurly; end +end + +class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(target); end + def on_block(node); end + + private + + def check_after_closing_pipe(arguments); end + def check_arg(arg); end + def check_closing_pipe_space(args, closing_pipe); end + def check_each_arg(args); end + def check_inside_pipes(arguments); end + def check_no_space(space_begin_pos, space_end_pos, msg); end + def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe); end + def check_opening_pipe_space(args, opening_pipe); end + def check_space(space_begin_pos, space_end_pos, range, msg, node = _); end + def check_space_style_inside_pipes(args, opening_pipe, closing_pipe); end + def last_end_pos_inside_pipes(pos); end + def pipes(arguments); end + def pipes?(arguments); end + def style_parameter_name; end +end + +class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(range); end + def on_optarg(node); end + + private + + def check_optarg(arg, equals, value); end + def incorrect_style_detected(arg, value, space_on_both_sides, no_surrounding_space); end + def message(_node); end + def no_surrounding_space?(arg, equals); end + def space_on_both_sides?(arg, equals); end +end + +RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Cop + def autocorrect(range); end + def on_and(node); end + def on_block(node); end + def on_break(node); end + def on_case(node); end + def on_defined?(node); end + def on_ensure(node); end + def on_for(node); end + def on_if(node); end + def on_kwbegin(node); end + def on_next(node); end + def on_or(node); end + def on_postexe(node); end + def on_preexe(node); end + def on_resbody(node); end + def on_rescue(node); end + def on_return(node); end + def on_send(node); end + def on_super(node); end + def on_until(node); end + def on_when(node); end + def on_while(node); end + def on_yield(node); end + def on_zsuper(node); end + + private + + def accept_left_parenthesis?(range); end + def accept_left_square_bracket?(range); end + def accept_namespace_operator?(range); end + def accepted_opening_delimiter?(range, char); end + def check(node, locations, begin_keyword = _); end + def check_begin(node, range, begin_keyword); end + def check_end(node, range, begin_keyword); end + def check_keyword(node, range); end + def do?(node); end + def namespace_operator?(range, pos); end + def offense(range, msg); end + def preceded_by_operator?(node, _range); end + def safe_navigation_call?(range, pos); end + def space_after_missing?(range); end + def space_before_missing?(range); end +end + +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_PAREN = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_SQUARE_BRACKET = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundKeyword::DO = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_AFTER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_BEFORE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundKeyword::NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundKeyword::SAFE_NAVIGATION = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + + def autocorrect(node); end + def on_const(node); end + def on_csend(node); end + def on_send(node); end + + private + + def check_and_add_offense(node, add_left_offense = _); end + def dot_or_safe_navigation_operator?(node); end + def left_token_for_auto_correction(node, operator); end + def next_token(current_token); end + def operator_token(node); end + def previous_token(current_token); end + def right_token_for_auto_correction(operator); end + def valid_left_token?(left, operator); end + def valid_right_token?(right, operator); end +end + +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::PrecedingFollowingAlignment) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::RationalLiteral) + + def autocorrect(range); end + def on_and(node); end + def on_and_asgn(node); end + def on_assignment(node); end + def on_binary(node); end + def on_casgn(node); end + def on_class(node); end + def on_cvasgn(node); end + def on_gvasgn(node); end + def on_if(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_op_asgn(node); end + def on_or(node); end + def on_or_asgn(node); end + def on_pair(node); end + def on_resbody(node); end + def on_send(node); end + def on_special_asgn(node); end + + private + + def align_hash_cop_config; end + def check_operator(type, operator, right_operand); end + def enclose_operator_with_space(corrector, range); end + def excess_leading_space?(type, operator, with_space); end + def excess_trailing_space?(right_operand, with_space); end + def force_equal_sign_alignment?; end + def hash_table_style?; end + def offense(type, operator, with_space, right_operand); end + def offense_message(type, operator, with_space, right_operand); end + def operator_with_regular_syntax?(send_node); end + def regular_operator?(send_node); end + def should_not_have_surrounding_space?(operator); end + def space_around_exponent_operator?; end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceAroundOperators::IRREGULAR_METHODS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def on_block(node); end + + private + + def block_delimiters_style; end + def check_empty(left_brace, space_plus_brace, used_style); end + def check_non_empty(left_brace, space_plus_brace, used_style); end + def conflict_with_block_delimiters?(node); end + def empty_braces?(loc); end + def space_detected(left_brace, space_plus_brace); end + def space_missing(left_brace); end + def style_for_empty_braces; end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SpaceBeforePunctuation) + + def autocorrect(space); end + def kind(token); end +end + +class RuboCop::Cop::Layout::SpaceBeforeComment < ::RuboCop::Cop::Cop + def autocorrect(range); end + def investigate(processed_source); end +end + +RuboCop::Cop::Layout::SpaceBeforeComment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::PrecedingFollowingAlignment) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def on_csend(node); end + def on_send(node); end + + private + + def expect_params_after_method_name?(node); end + def no_space_between_method_name_and_first_argument?(node); end + def regular_method_call_with_arguments?(node); end +end + +RuboCop::Cop::Layout::SpaceBeforeFirstArg::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceBeforeSemicolon < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SpaceBeforePunctuation) + + def autocorrect(space); end + def kind(token); end +end + +class RuboCop::Cop::Layout::SpaceInLambdaLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(lambda_node); end + def on_send(node); end + + private + + def arrow_lambda_with_args?(node); end + def range_of_offense(node); end + def space_after_arrow(lambda_node); end + def space_after_arrow?(lambda_node); end +end + +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_NO_SPACE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_SPACE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_array(node); end + + private + + def array_brackets(node); end + def compact(corrector, bracket, side); end + def compact_corrections(corrector, node, left, right); end + def compact_offense(node, token, side: _); end + def compact_offenses(node, left, right, start_ok, end_ok); end + def empty_config; end + def end_has_own_line?(token); end + def index_for(node, token); end + def issue_offenses(node, left, right, start_ok, end_ok); end + def left_array_bracket(node); end + def line_and_column_for(token); end + def multi_dimensional_array?(node, token, side: _); end + def next_to_bracket?(token, side: _); end + def next_to_comment?(node, token); end + def next_to_newline?(node, token); end + def qualifies_for_compact?(node, token, side: _); end + def right_array_bracket(node); end +end + +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::MatchRange) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_array(node); end + def on_percent_literal(node); end + + private + + def each_unnecessary_space_match(node, &blk); end +end + +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + + def autocorrect(range); end + def on_block(node); end + + private + + def adjacent_braces(left_brace, right_brace); end + def aligned_braces?(left_brace, right_brace); end + def braces_with_contents_inside(node, inner); end + def check_inside(node, left_brace, right_brace); end + def check_left_brace(inner, left_brace, args_delimiter); end + def check_right_brace(inner, left_brace, right_brace, single_line); end + def multiline_block?(left_brace, right_brace); end + def no_space(begin_pos, end_pos, msg); end + def no_space_inside_left_brace(left_brace, args_delimiter); end + def offense(begin_pos, end_pos, msg, &block); end + def pipe?(args_delimiter); end + def space(begin_pos, end_pos, msg); end + def space_inside_left_brace(left_brace, args_delimiter); end + def space_inside_right_brace(right_brace); end + def style_for_empty_braces; end +end + +class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(range); end + def on_hash(node); end + + private + + def ambiguous_or_unexpected_style_detected(style, is_match); end + def check(token1, token2); end + def expect_space?(token1, token2); end + def hash_literal_with_braces(node); end + def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end + def message(brace, is_empty_braces, expect_space); end + def offense?(token1, expect_space); end + def range_of_space_to_the_left(range); end + def range_of_space_to_the_right(range); end + def space_range(token_range); end +end + +RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def can_be_ignored?(token1, token2); end + def each_extraneous_space(tokens); end + def each_missing_space(tokens); end + def parens?(token1, token2); end + def same_line?(token1, token2); end +end + +RuboCop::Cop::Layout::SpaceInsideParens::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInsideParens::MSG_SPACE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::MatchRange) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_array(node); end + def on_percent_literal(node); end + def on_xstr(node); end + + private + + def add_offenses_for_unnecessary_spaces(node); end + def regex_matches(node, &blk); end +end + +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BEGIN_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::END_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_erange(node); end + def on_irange(node); end + + private + + def check(node); end +end + +RuboCop::Cop::Layout::SpaceInsideRangeLiteral::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_send(node); end + + private + + def bracket_method?(node); end + def closing_bracket(tokens, opening_bracket); end + def empty_config; end + def left_ref_bracket(node, tokens); end + def previous_token(current_token); end + def reference_brackets(node); end +end + +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::BRACKET_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Interpolation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(begin_node); end + def on_interpolation(begin_node); end + + private + + def delimiters(begin_node); end +end + +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Layout::TrailingEmptyLines < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def ends_in_end?(processed_source); end + def message(wanted_blank_lines, blank_lines); end + def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end +end + +class RuboCop::Cop::Layout::TrailingWhitespace < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def extract_heredoc_ranges(ast); end + def inside_heredoc?(heredoc_ranges, line_number); end + def skip_heredoc?; end +end + +RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::LineBreakCorrector + extend(::RuboCop::Cop::Alignment) + extend(::RuboCop::Cop::TrailingBody) + extend(::RuboCop::PathUtil) + extend(::RuboCop::Cop::Util) + + def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: _); end + def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end + def self.move_comment(eol_comment:, node:, corrector:); end + def self.processed_source; end +end + +module RuboCop::Cop::LineLengthHelp + + private + + def allow_uri?; end + def allowed_uri_position?(line, uri_range); end + def directive_on_source_line?(line_index); end + def find_excessive_uri_range(line); end + def ignore_cop_directives?; end + def indentation_difference(line); end + def line_length(line); end + def line_length_without_directive(line); end + def match_uris(string); end + def tab_indentation_width; end + def uri_regexp; end + def valid_uri?(uri_ish_string); end +end + +module RuboCop::Cop::Lint +end + +class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Cop + def on_csend(node); end + def on_send(node); end + + private + + def allowed_method?(node); end + def ambiguous_block_association?(send_node); end + def message(send_node); end +end + +RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::AmbiguousOperator < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ParserDiagnostic) + + def autocorrect(node); end + + private + + def alternative_message(diagnostic); end + def find_offense_node_by(diagnostic); end + def offense_node(node); end + def offense_position?(node, diagnostic); end + def relevant_diagnostic?(diagnostic); end + def unary_operator?(node, diagnostic); end +end + +RuboCop::Cop::Lint::AmbiguousOperator::AMBIGUITIES = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Lint::AmbiguousOperator::MSG_FORMAT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ParserDiagnostic) + + def autocorrect(node); end + + private + + def alternative_message(_diagnostic); end + def find_offense_node_by(diagnostic); end + def relevant_diagnostic?(diagnostic); end +end + +RuboCop::Cop::Lint::AmbiguousRegexpLiteral::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::AssignmentInCondition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::SafeAssignment) + + def on_if(node); end + def on_until(node); end + def on_while(node); end + + private + + def allowed_construct?(asgn_node); end + def conditional_assignment?(asgn_node); end + def message(_node); end + def skip_children?(asgn_node); end + def traverse_node(node, types, &block); end +end + +RuboCop::Cop::Lint::AssignmentInCondition::ASGN_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Cop + def autocorrect(node); end + def big_decimal_new(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Cop + def autocorrect(node); end + def boolean_symbol?(node = _); end + def on_sym(node); end +end + +RuboCop::Cop::Lint::BooleanSymbol::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::CircularArgumentReference < ::RuboCop::Cop::Cop + def on_kwoptarg(node); end + def on_optarg(node); end + + private + + def check_for_circular_argument_references(arg_name, arg_value); end +end + +RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Cop + def binding_irb_call?(node = _); end + def debugger_call?(node = _); end + def kernel?(node = _); end + def on_send(node); end + + private + + def binding_irb?(node); end + def message(node); end +end + +RuboCop::Cop::Lint::Debugger::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DeprecatedClassMethods < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + + private + + def check(node); end + def deprecated_method(data); end + def method_call(class_constant, method); end + def replacement_method(data); end +end + +RuboCop::Cop::Lint::DeprecatedClassMethods::DEPRECATED_METHODS_OBJECT = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod + include(::RuboCop::AST::Sexp) + + def initialize(deprecated:, replacement:, class_constant: _); end + + def class_constant; end + def class_nodes; end + def deprecated_method; end + def replacement_method; end +end + +RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def algorithm_const(node = _); end + def autocorrect(node); end + def on_send(node); end + + private + + def algorithm_name(node); end + def build_cipher_arguments(node, algorithm_name); end + def correction_range(node); end + def message(node); end + def openssl_class(node); end + def replacement_args(node); end + def sanitize_arguments(arguments); end +end + +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < ::RuboCop::Cop::Cop + def on_def(node); end + + private + + def check(node); end + def check_body(body); end + def check_body_lines(lines); end + def check_disjunctive_assignment(node); end +end + +RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DuplicateCaseCondition < ::RuboCop::Cop::Cop + def on_case(case_node); end + + private + + def repeated_condition?(previous, condition); end +end + +RuboCop::Cop::Lint::DuplicateCaseCondition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Duplication) + + def on_hash(node); end +end + +RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Cop + def initialize(config = _, options = _); end + + def alias_method?(node = _); end + def method_alias?(node = _); end + def on_alias(node); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end + def sym_name(node = _); end + + private + + def check_const_receiver(node, name, const_name); end + def check_self_receiver(node, name); end + def found_attr(node, args, readable: _, writable: _); end + def found_instance_method(node, name); end + def found_method(node, method_name); end + def lookup_constant(node, const_name); end + def message_for_dup(node, method_name); end + def on_attr(node, attr_name, args); end + def possible_dsl?(node); end + def qualified_name(enclosing, namespace, mod_name); end + def source_location(node); end +end + +RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Cop + def each_with_object?(node = _); end + def on_csend(node); end + def on_send(node); end +end + +RuboCop::Cop::Lint::EachWithObjectArgument::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ElseLayout < ::RuboCop::Cop::Cop + def on_if(node); end + + private + + def check(node); end + def check_else(node); end +end + +RuboCop::Cop::Lint::ElseLayout::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EmptyEnsure < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_ensure(node); end +end + +RuboCop::Cop::Lint::EmptyEnsure::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EmptyExpression < ::RuboCop::Cop::Cop + def on_begin(node); end + + private + + def empty_expression?(begin_node); end +end + +RuboCop::Cop::Lint::EmptyExpression::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EmptyInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Interpolation) + + def autocorrect(node); end + def on_interpolation(begin_node); end +end + +RuboCop::Cop::Lint::EmptyInterpolation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EmptyWhen < ::RuboCop::Cop::Cop + def on_case(node); end +end + +RuboCop::Cop::Lint::EmptyWhen::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::EnsureReturn < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_ensure(node); end +end + +RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::TargetRubyVersion) + + def autocorrect(node); end + def erb_new_with_non_keyword_arguments(node = _); end + def on_send(node); end + + private + + def arguments_range(node); end + def build_kwargs(node); end + def correct_arguments?(arguments); end + def override_by_legacy_args(kwargs, node); end +end + +RuboCop::Cop::Lint::ErbNewArguments::MESSAGES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::FlipFlop < ::RuboCop::Cop::Cop + def on_eflipflop(node); end + def on_iflipflop(node); end +end + +RuboCop::Cop::Lint::FlipFlop::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::FloatOutOfRange < ::RuboCop::Cop::Cop + def on_float(node); end +end + +RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Cop + def called_on_string?(node = _); end + def on_send(node); end + + private + + def count_format_matches(node); end + def count_matches(node); end + def count_percent_matches(node); end + def countable_format?(node); end + def countable_percent?(node); end + def expected_fields_count(node); end + def format?(node); end + def format_method?(name, node); end + def format_string?(node); end + def heredoc?(node); end + def invalid_format_string?(node); end + def matched_arguments_count?(expected, passed); end + def message(node); end + def method_with_format_args?(node); end + def offending_node?(node); end + def percent?(node); end + def splat_args?(node); end + def sprintf?(node); end +end + +RuboCop::Cop::Lint::FormatParameterMismatch::KERNEL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::FormatParameterMismatch::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::FormatParameterMismatch::MSG_INVALID = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::FormatParameterMismatch::SHOVEL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::FormatParameterMismatch::STRING_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::HeredocMethodCallPosition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def all_on_same_line?(nodes); end + def call_after_heredoc_range(heredoc); end + def call_end_pos(node); end + def call_line_range(node); end + def call_range_to_safely_reposition(node, heredoc); end + def calls_on_multiple_lines?(node, _heredoc); end + def correctly_positioned?(node, heredoc); end + def heredoc_begin_line_range(heredoc); end + def heredoc_end_pos(heredoc); end + def heredoc_node?(node); end + def heredoc_node_descendent_receiver(node); end + def send_node?(node); end + def trailing_comma?(call_source, call_line_source); end +end + +RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ImplicitStringConcatenation < ::RuboCop::Cop::Cop + def on_dstr(node); end + + private + + def display_str(node); end + def each_bad_cons(node); end + def ending_delimiter(str); end + def str_content(node); end + def string_literal?(node); end + def string_literals?(node1, node2); end +end + +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_ARRAY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Cop + def on_class(node); end + def on_module(node); end + def private_class_methods(node0); end + + private + + def access_modifier?(node); end + def check_node(node); end + def correct_visibility?(node, modifier, ignored_methods); end + def format_message(modifier); end + def ineffective_modifier(node, ignored_methods, modifier = _, &block); end + def private_class_method_names(node); end +end + +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PRIVATE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PROTECTED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def class_new_call?(node = _); end + def on_class(node); end + def on_send(node); end + + private + + def illegal_class_name?(class_node); end + def message(node); end + def preferred_base_class; end +end + +RuboCop::Cop::Lint::InheritException::ILLEGAL_CLASSES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Lint::InterpolationCheck < ::RuboCop::Cop::Cop + def heredoc?(node); end + def on_str(node); end +end + +RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Cop + def message(node); end + def on_case(case_node); end + def on_if(node); end + def on_send(node); end + def on_until(node); end + def on_until_post(node); end + def on_while(node); end + def on_while_post(node); end + + private + + def basic_literal?(node); end + def check_case(case_node); end + def check_for_literal(node); end + def check_node(node); end + def condition(node); end + def handle_node(node); end + def primitive_array?(node); end +end + +RuboCop::Cop::Lint::LiteralAsCondition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Interpolation) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_interpolation(begin_node); end + + private + + def autocorrected_value(node); end + def autocorrected_value_for_array(node); end + def autocorrected_value_for_string(node); end + def autocorrected_value_for_symbol(node); end + def prints_as_self?(node); end + def special_keyword?(node); end +end + +RuboCop::Cop::Lint::LiteralInInterpolation::COMPOSITE = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Cop + def on_until_post(node); end + def on_while_post(node); end + + private + + def register_offense(node); end +end + +RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + + private + + def message(max_range:, cop:); end +end + +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < ::RuboCop::Cop::Cop + def on_regexp(node); end + + private + + def contain_non_literal?(node); end + def named_capture?(tree); end + def numbered_capture?(tree); end +end + +RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Cop + def autocorrect(node); end + def multiple_compare?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Cop + def class_or_module_or_struct_new_call?(node = _); end + def eval_call?(node = _); end + def exec_call?(node = _); end + def on_def(node); end + def on_defs(node); end + + private + + def find_nested_defs(node, &block); end + def scoping_method_call?(child); end +end + +RuboCop::Cop::Lint::NestedMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::NestedPercentLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def on_array(node); end + def on_percent_literal(node); end + + private + + def contains_percent_literals?(node); end +end + +RuboCop::Cop::Lint::NestedPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::NestedPercentLiteral::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Cop + def on_block(node); end + def on_body_of_reduce(node = _); end + + private + + def parent_block_node(node); end +end + +RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Cop + def autocorrect(node); end + def loop_variable(node = _); end + def on_block(node); end + def unsorted_dir_block?(node = _); end + def unsorted_dir_each?(node = _); end + def var_is_required?(node0, param1); end + + private + + def unsorted_dir_loop?(node); end +end + +RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Cop + def chained_send?(node = _); end + def define_method?(node = _); end + def on_return(return_node); end + + private + + def return_value?(return_node); end + def scoped_node?(node); end +end + +RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Cop + def autocorrect(node); end + def datetime?(node = _); end + def on_send(node); end + def to_method(node = _); end + + private + + def correct_method(node, receiver); end + def date_time_object?(node); end +end + +RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FrozenStringLiteral) + + def autocorrect(_node); end + def investigate(processed_source); end + + private + + def magic_comment_lines; end + def magic_comments; end +end + +RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def first_argument_starts_with_left_parenthesis?(node); end + def grouped_parentheses?(node); end + def space_range(expr, space_length); end + def spaces_before_left_parenthesis(node); end + def valid_context?(node); end +end + +RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::PercentStringArray < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_array(node); end + def on_percent_literal(node); end + + private + + def contains_quotes_or_commas?(node); end +end + +RuboCop::Cop::Lint::PercentStringArray::LEADING_QUOTE = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Lint::PercentStringArray::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::PercentStringArray::QUOTES_AND_COMMAS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::PercentStringArray::TRAILING_QUOTE = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Lint::PercentSymbolArray < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_array(node); end + def on_percent_literal(node); end + + private + + def contains_colons_or_commas?(node); end + def non_alphanumeric_literal?(literal); end +end + +RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Cop + def exception?(node = _); end + def exception_new_with_message?(node = _); end + def on_send(node); end + + private + + def allow_implicit_namespaces; end + def check(node); end + def implicit_namespace?(node); end +end + +RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Cop + def on_send(node); end + def rand_one?(node = _); end + + private + + def message(node); end +end + +RuboCop::Cop::Lint::RandOne::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(args); end + def check(offenses, cop_disabled_line_ranges, comments); end + + private + + def add_offense_for_entire_comment(comment, cops); end + def add_offense_for_some_cops(comment, cops); end + def add_offenses(redundant_cops); end + def all_cop_names; end + def all_disabled?(comment); end + def comment_range_with_surrounding_space(range); end + def cop_range(comment, cop); end + def describe(cop); end + def directive_count(comment); end + def directive_range_in_list(range, ranges); end + def each_already_disabled(line_ranges, disabled_ranges, comments); end + def each_line_range(line_ranges, disabled_ranges, offenses, comments, cop); end + def each_redundant_disable(cop_disabled_line_ranges, offenses, comments, &block); end + def ends_its_line?(range); end + def find_redundant(comment, offenses, cop, line_range, next_line_range); end + def ignore_offense?(disabled_ranges, line_range); end + def matching_range(haystack, needle); end + def trailing_range?(ranges, range); end +end + +RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + + def autocorrect(comment_and_name); end + def investigate(processed_source); end + + private + + def all_or_name(name); end + def comment_start(comment); end + def cop_name_indention(comment, name); end + def range_of_offense(comment, name); end + def range_to_remove(begin_pos, end_pos, comma_pos, comment); end + def range_with_comma(comment, name); end +end + +RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def unnecessary_require_statement?(node = _); end +end + +RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Cop + def array_new?(node = _); end + def autocorrect(node); end + def literal_expansion(node = _); end + def on_splat(node); end + + private + + def array_new_inside_array_literal?(array_new_node); end + def array_splat?(node); end + def method_argument?(node); end + def part_of_an_array?(node); end + def redundant_brackets?(node); end + def redundant_splat_expansion(node); end + def remove_brackets(array); end + def replacement_range_and_content(node); end +end + +RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantSplatExpansion::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::RedundantSplatExpansion::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_I = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_W = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Interpolation) + + def autocorrect(node); end + def on_interpolation(begin_node); end + def to_s_without_args?(node = _); end + + private + + def message(node); end +end + +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + def redundant_with_index?(node = _); end + + private + + def message(node); end + def with_index_range(send); end +end + +RuboCop::Cop::Lint::RedundantWithIndex::MSG_EACH_WITH_INDEX = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantWithIndex::MSG_WITH_INDEX = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + def redundant_with_object?(node = _); end + + private + + def message(node); end + def with_object_range(send); end +end + +RuboCop::Cop::Lint::RedundantWithObject::MSG_EACH_WITH_OBJECT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::RedundantWithObject::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RegexpAsCondition < ::RuboCop::Cop::Cop + def on_match_current_line(node); end +end + +RuboCop::Cop::Lint::RegexpAsCondition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RequireParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def on_csend(node); end + def on_send(node); end + + private + + def check_predicate(predicate, node); end + def check_ternary(ternary, node); end +end + +RuboCop::Cop::Lint::RequireParentheses::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RescueException < ::RuboCop::Cop::Cop + def on_resbody(node); end + def targets_exception?(rescue_arg_node); end +end + +RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RescueNode) + + def autocorrect(node); end + def on_resbody(node); end + + private + + def correction(*exceptions); end + def invalid_exceptions(exceptions); end + def valid_exceptions(exceptions); end +end + +RuboCop::Cop::Lint::RescueType::INVALID_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::RescueType::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ReturnInVoidContext < ::RuboCop::Cop::Cop + def on_return(return_node); end + + private + + def method_name(context_node); end + def non_void_context(return_node); end + def setter_method?(method_name); end + def void_context_method?(method_name); end +end + +RuboCop::Cop::Lint::ReturnInVoidContext::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::NilMethods) + + def bad_method?(node = _); end + def on_send(node); end + + private + + def method_chain(node); end +end + +RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::SafeNavigationConsistency < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::NilMethods) + + def autocorrect(node); end + def check(node); end + def on_csend(node); end + + private + + def top_conditional_ancestor(node); end + def unsafe_method_calls(method_calls, safe_nav_receiver); end +end + +RuboCop::Cop::Lint::SafeNavigationConsistency::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Cop + def on_if(node); end + def safe_navigation_empty_in_conditional?(node = _); end +end + +RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ScriptPermission < ::RuboCop::Cop::Cop + def autocorrect(node); end + def investigate(processed_source); end + + private + + def executable?(processed_source); end + def format_message_from(processed_source); end +end + +RuboCop::Cop::Lint::ScriptPermission::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::ScriptPermission::SHEBANG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def send_with_mixin_argument?(node = _); end + + private + + def bad_location(node); end + def message(method, module_name, bad_method); end + def mixin_method?(node); end +end + +RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Cop + def after_leaving_scope(scope, _variable_table); end + def join_force?(force_class); end + def uses_var?(node0, param1); end + + private + + def argument_references(argument); end + def assignment_without_argument_usage(argument); end + def check_argument(argument); end + def ignore_implicit_references?; end + def node_within_block_or_conditional?(node, stop_search_node); end + def reference_pos(node); end + def shadowing_assignment(argument); end +end + +RuboCop::Cop::Lint::ShadowedArgument::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RescueNode) + include(::RuboCop::Cop::RangeHelp) + + def on_rescue(node); end + + private + + def compare_exceptions(exception, other_exception); end + def contains_multiple_levels_of_exceptions?(group); end + def evaluate_exceptions(rescue_group); end + def find_shadowing_rescue(rescues); end + def offense_range(rescues); end + def rescued_exceptions(rescue_group); end + def rescued_groups_for(rescues); end + def silence_warnings; end + def sorted?(rescued_groups); end + def system_call_err?(error); end +end + +RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Cop + def before_declaring_variable(variable, variable_table); end + def join_force?(force_class); end +end + +RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Cop + def on_send(node); end + def struct_new(node = _); end +end + +RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::SuppressedException < ::RuboCop::Cop::Cop + def on_resbody(node); end + + private + + def comment_between_rescue_and_end?(node); end +end + +RuboCop::Cop::Lint::SuppressedException::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::Syntax < ::RuboCop::Cop::Cop + def add_offense_from_diagnostic(diagnostic, ruby_version); end + def add_offense_from_error(error); end + + private + + def beautify_message(message); end + + def self.offenses_from_processed_source(processed_source, config, options); end +end + +RuboCop::Cop::Lint::Syntax::ERROR_SOURCE_RANGE = T.let(T.unsafe(nil), RuboCop::Cop::Lint::Syntax::PseudoSourceRange) + +class RuboCop::Cop::Lint::Syntax::PseudoSourceRange < ::Struct + def begin_pos; end + def begin_pos=(_); end + def column; end + def column=(_); end + def end_pos; end + def end_pos=(_); end + def line; end + def line=(_); end + def source_line; end + def source_line=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_def(node); end +end + +RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UnderscorePrefixedVariableName < ::RuboCop::Cop::Cop + def after_leaving_scope(scope, _variable_table); end + def check_variable(variable); end + def join_force?(force_class); end + + private + + def allowed_keyword_block_argument?(variable); end +end + +RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Cop + def autocorrect(node); end + def fixnum_or_bignum_const(node = _); end + def on_const(node); end +end + +RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Cop + def flow_command?(node = _); end + def on_begin(node); end + def on_kwbegin(node); end + + private + + def check_case(node); end + def check_if(node); end + def flow_expression?(node); end +end + +RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Lint::UnusedArgument + extend(::RuboCop::AST::NodePattern::Macros) + + def after_leaving_scope(scope, _variable_table); end + def join_force?(force_class); end + + private + + def check_argument(variable); end +end + +class RuboCop::Cop::Lint::UnusedBlockArgument < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Lint::UnusedArgument) + + def autocorrect(node); end + + private + + def allow_unused_keyword_arguments?; end + def allowed_block?(variable); end + def allowed_keyword_argument?(variable); end + def augment_message(message, variable); end + def check_argument(variable); end + def define_method_call?(variable); end + def empty_block?(variable); end + def ignore_empty_blocks?; end + def message(variable); end + def message_for_lambda(variable, all_arguments); end + def message_for_normal_block(variable, all_arguments); end + def message_for_underscore_prefix(variable); end + def variable_type(variable); end +end + +class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Lint::UnusedArgument) + + def autocorrect(node); end + def not_implemented?(node = _); end + + private + + def check_argument(variable); end + def ignored_method?(body); end + def message(variable); end +end + +class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Cop + def on_send(node); end + def uri_escape_unescape?(node = _); end +end + +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_UNESCAPE = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def uri_regexp_with_argument?(node = _); end + def uri_regexp_without_argument?(node = _); end + + private + + def register_offense(node, top_level: _, arg: _); end +end + +RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def class_or_instance_eval?(node = _); end + def class_or_module_or_struct_new_call?(node = _); end + def dynamic_method_definition?(node = _); end + def on_block(node); end + def on_class(node); end + def on_module(node); end + def on_sclass(node); end + def static_method_definition?(node = _); end + + private + + def access_modifier?(node); end + def any_context_creating_methods?(child); end + def any_method_definition?(child); end + def check_child_nodes(node, unused, cur_vis); end + def check_new_visibility(node, unused, new_vis, cur_vis); end + def check_node(node); end + def check_scope(node); end + def check_send_node(node, cur_vis, unused); end + def eval_call?(child); end + def method_definition?(child); end + def start_of_new_scope?(child); end +end + +RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Cop + def after_leaving_scope(scope, _variable_table); end + def check_for_unused_assignments(variable); end + def collect_variable_like_names(scope); end + def join_force?(force_class); end + def message_for_useless_assignment(assignment); end + def message_specification(assignment, variable); end + def multiple_assignment_message(variable_name); end + def operator_assignment_message(scope, assignment); end + def return_value_node_of_scope(scope); end + def similar_name_message(variable); end + def variable_like_method_invocation?(node); end +end + +RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UselessComparison < ::RuboCop::Cop::Cop + def on_send(node); end + def useless_comparison?(node = _); end +end + +RuboCop::Cop::Lint::UselessComparison::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::UselessComparison::OPS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Lint::UselessElseWithoutRescue < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ParserDiagnostic) + + + private + + def alternative_message(_diagnostic); end + def find_offense_node_by(diagnostic); end + def relevant_diagnostic?(diagnostic); end +end + +RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Cop + def on_def(node); end + def on_defs(node); end + def setter_call_to_local_variable?(node = _); end + + private + + def last_expression(body); end +end + +RuboCop::Cop::Lint::UselessSetterCall::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::UselessSetterCall::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker + def initialize(body_node); end + + def constructor?(node); end + def contain_local_object?(variable_name); end + def process_assignment(asgn_node, rhs_node); end + def process_assignment_node(node); end + def process_binary_operator_assignment(op_asgn_node); end + def process_logical_operator_assignment(asgn_node); end + def process_multiple_assignment(masgn_node); end + def scan(node, &block); end +end + +class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Cop + def on_begin(node); end + def on_block(node); end + def on_kwbegin(node); end + + private + + def check_begin(node); end + def check_defined(node); end + def check_expression(expr); end + def check_literal(node); end + def check_nonmutating(node); end + def check_self(node); end + def check_var(node); end + def check_void_op(node); end + def in_void_context?(node); end +end + +RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::Void::DEFINED_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Lint::Void::VOID_CONTEXT_TYPES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::MatchRange + include(::RuboCop::Cop::RangeHelp) + + + private + + def each_match_range(range, regex); end + def match_range(range, match); end +end + +class RuboCop::Cop::MessageAnnotator + def initialize(config, cop_name, cop_config, options); end + + def annotate(message); end + def config; end + def cop_config; end + def cop_name; end + def options; end + def urls; end + + private + + def debug?; end + def details; end + def display_cop_names?; end + def display_style_guide?; end + def extra_details?; end + def reference_urls; end + def style_guide_base_url; end + def style_guide_url; end + + def self.style_guide_urls; end +end + +module RuboCop::Cop::MethodComplexity + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IgnoredMethods) + extend(::RuboCop::AST::NodePattern::Macros) + + def define_method?(node = _); end + def on_block(node); end + def on_def(node); end + def on_defs(node); end + + private + + def check_complexity(node, method_name); end + def complexity(body); end +end + +module RuboCop::Cop::MethodPreference + + private + + def default_cop_config; end + def preferred_method(method); end + def preferred_methods; end +end + +module RuboCop::Cop::Metrics +end + +class RuboCop::Cop::Metrics::AbcSize < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IgnoredMethods) + include(::RuboCop::Cop::MethodComplexity) + + + private + + def complexity(node); end +end + +RuboCop::Cop::Metrics::AbcSize::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Metrics::BlockLength < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + include(::RuboCop::Cop::TooManyLines) + + def on_block(node); end + + private + + def cop_label; end + def excluded_method?(node); end + def excluded_methods; end +end + +RuboCop::Cop::Metrics::BlockLength::LABEL = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Metrics::BlockNesting < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + + def investigate(processed_source); end + + private + + def check_nesting_level(node, max, current_level); end + def consider_node?(node); end + def count_blocks?; end + def message(max); end +end + +RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + include(::RuboCop::Cop::ClassishLength) + + def class_definition?(node = _); end + def on_casgn(node); end + def on_class(node); end + + private + + def message(length, max_length); end +end + +class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IgnoredMethods) + include(::RuboCop::Cop::MethodComplexity) + + + private + + def complexity_score_for(_node); end +end + +RuboCop::Cop::Metrics::CyclomaticComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Metrics::CyclomaticComplexity::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Metrics::MethodLength < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + include(::RuboCop::Cop::TooManyLines) + + def on_block(node); end + def on_def(node); end + def on_defs(node); end + + private + + def cop_label; end +end + +RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + include(::RuboCop::Cop::ClassishLength) + + def module_definition?(node = _); end + def on_casgn(node); end + def on_module(node); end + + private + + def message(length, max_length); end +end + +class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + + def argument_to_lambda_or_proc?(node = _); end + def on_args(node); end + + private + + def args_count(node); end + def count_keyword_args?; end + def max_params; end + def message(node); end +end + +RuboCop::Cop::Metrics::ParameterLists::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Metrics::PerceivedComplexity < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IgnoredMethods) + include(::RuboCop::Cop::MethodComplexity) + + + private + + def complexity_score_for(node); end +end + +RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Metrics::Utils +end + +class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + def initialize(node); end + + def calculate; end + def else_branch?(node); end + def evaluate_branch_nodes(node); end + def evaluate_condition_node(node); end + + private + + def branch?(node); end + def condition?(node); end + + def self.calculate(node); end +end + +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::CONDITION_NODES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::Migration +end + +class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def check_cop_name(name, comment, offset); end + def contain_unexpected_character_for_department_name?(name); end + def disable_comment_offset; end + def qualified_legacy_cop_name(cop_name); end + def valid_content_token?(content_token); end +end + +RuboCop::Cop::Migration::DepartmentName::DISABLE_COMMENT_FORMAT = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Migration::DepartmentName::DISABLING_COPS_CONTENT_TOKEN = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Migration::DepartmentName::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::MinBodyLength + + private + + def min_body_length; end + def min_body_length?(node); end +end + +module RuboCop::Cop::MultilineElementIndentation + + private + + def base_column(left_brace, left_parenthesis); end + def check_expected_style(styles); end + def check_first(first, left_brace, left_parenthesis, offset); end + def detected_styles(actual_column, offset, left_parenthesis, left_brace); end + def detected_styles_for_column(column, left_parenthesis, left_brace); end + def each_argument_node(node, type); end + def incorrect_style_detected(styles, first, left_parenthesis); end +end + +module RuboCop::Cop::MultilineElementLineBreaks + + private + + def all_on_same_line?(nodes); end + def check_line_breaks(_node, children); end +end + +module RuboCop::Cop::MultilineExpressionIndentation + def on_send(node); end + + private + + def argument_in_method_call(node, kind); end + def assignment_rhs(node); end + def check(range, node, lhs, rhs); end + def correct_indentation(node); end + def disqualified_rhs?(candidate, ancestor); end + def grouped_expression?(node); end + def incorrect_style_detected(range, node, lhs, rhs); end + def indentation(node); end + def indented_keyword_expression(node); end + def inside_arg_list_parentheses?(node, ancestor); end + def keyword_message_tail(node); end + def kw_node_with_special_indentation(node); end + def left_hand_side(lhs); end + def not_for_this_cop?(node); end + def operation_description(node, rhs); end + def part_of_assignment_rhs(node, candidate); end + def part_of_block_body?(candidate, block_node); end + def postfix_conditional?(node); end + def regular_method_right_hand_side(send_node); end + def right_hand_side(send_node); end + def valid_method_rhs_candidate?(candidate, node); end + def valid_rhs?(candidate, ancestor); end + def valid_rhs_candidate?(candidate, node); end + def within_node?(inner, outer); end +end + +RuboCop::Cop::MultilineExpressionIndentation::ASSIGNMENT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::MultilineExpressionIndentation::DEFAULT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::MultilineExpressionIndentation::UNALIGNED_RHS_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::MultilineLiteralBraceCorrector + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MultilineLiteralBraceLayout) + include(::RuboCop::Cop::RangeHelp) + + def initialize(node, processed_source); end + + def call(corrector); end + + private + + def correct_next_line_brace(corrector); end + def correct_same_line_brace(corrector); end + def last_element_range_with_trailing_comma(node); end + def last_element_trailing_comma_range(node); end + def node; end + def processed_source; end +end + +module RuboCop::Cop::MultilineLiteralBraceLayout + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + + private + + def check(node); end + def check_brace_layout(node); end + def check_new_line(node); end + def check_same_line(node); end + def check_symmetrical(node); end + def children(node); end + def closing_brace_on_same_line?(node); end + def empty_literal?(node); end + def ignored_literal?(node); end + def implicit_literal?(node); end + def last_line_heredoc?(node, parent = _); end + def new_line_needed_before_closing_brace?(node); end + def opening_brace_on_same_line?(node); end +end + +module RuboCop::Cop::Naming +end + +class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Cop + def on_def(node); end + def on_defs(node); end + + private + + def bad_reader_name?(node); end + def bad_writer_name?(node); end + def message(node); end +end + +RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::AsciiIdentifiers < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + + private + + def first_non_ascii_chars(string); end + def first_offense_range(identifier); end +end + +RuboCop::Cop::Naming::AsciiIdentifiers::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Cop + def on_def(node); end + def op_method_candidate?(node = _); end + + private + + def op_method?(name); end +end + +RuboCop::Cop::Naming::BinaryOperatorParameterName::BLACKLISTED = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Naming::BinaryOperatorParameterName::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::BinaryOperatorParameterName::OP_LIKE_METHODS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Naming::BlockParameterName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::UncommunicativeName) + + def on_block(node); end +end + +class RuboCop::Cop::Naming::ClassAndModuleCamelCase < ::RuboCop::Cop::Cop + def on_class(node); end + def on_module(node); end +end + +RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Cop + def class_or_struct_return_method?(node = _); end + def literal_receiver?(node = _); end + def on_casgn(node); end + + private + + def allowed_assignment?(value); end + def allowed_conditional_expression_on_rhs?(node); end + def allowed_method_call_on_rhs?(node); end + def contains_contant?(node); end +end + +RuboCop::Cop::Naming::ConstantName::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::ConstantName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Naming::FileName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + + private + + def allowed_acronyms; end + def bad_filename_allowed?; end + def check_definition_path_hierarchy?; end + def expect_matching_definition?; end + def filename_good?(basename); end + def find_class_or_module(node, namespace); end + def for_bad_filename(file_path); end + def ignore_executable_scripts?; end + def match?(expected); end + def match_acronym?(expected, name); end + def match_namespace(node, namespace, expected); end + def matching_class?(file_name); end + def matching_definition?(file_path); end + def no_definition_message(basename, file_path); end + def other_message(basename); end + def partial_matcher!(expected); end + def perform_class_and_module_naming_checks(file_path, basename); end + def regex; end + def to_module_name(basename); end + def to_namespace(path); end +end + +RuboCop::Cop::Naming::FileName::MSG_NO_DEFINITION = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::FileName::MSG_REGEX = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::FileName::MSG_SNAKE_CASE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::FileName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Heredoc) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def on_heredoc(node); end + + private + + def correct_case_delimiters?(node); end + def correct_delimiters(node); end + def message(_node); end +end + +RuboCop::Cop::Naming::HeredocDelimiterCase::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Heredoc) + + def on_heredoc(node); end + + private + + def forbidden_delimiters; end + def meaningful_delimiters?(node); end +end + +RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def memoized?(node = _); end + def on_def(node); end + def on_defs(node); end + + private + + def matches?(method_name, ivar_assign); end + def message(variable); end + def style_parameter_name; end + def suggested_var(method_name); end + def variable_name_candidates(method_name); end +end + +RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) + include(::RuboCop::Cop::ConfigurableNaming) + include(::RuboCop::Cop::IgnoredPattern) + include(::RuboCop::Cop::RangeHelp) + + def on_def(node); end + def on_defs(node); end + def on_send(node); end + def str_name(node = _); end + def sym_name(node = _); end + + private + + def attr_name(name_item); end + def message(style); end + def range_position(node); end +end + +RuboCop::Cop::Naming::MethodName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::MethodParameterName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::UncommunicativeName) + + def on_def(node); end + def on_defs(node); end +end + +class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Cop + def dynamic_method_define(node = _); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end + + private + + def allowed_method_name?(method_name, prefix); end + def allowed_methods; end + def expected_name(method_name, prefix); end + def forbidden_prefixes; end + def message(method_name, new_name); end + def method_definition_macros(macro_name); end + def predicate_prefixes; end +end + +class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_resbody(node); end + + private + + def message(node); end + def offense_range(resbody); end + def preferred_name(variable_name); end + def variable_name(node); end +end + +RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) + include(::RuboCop::Cop::ConfigurableNaming) + + def on_arg(node); end + def on_blockarg(node); end + def on_cvasgn(node); end + def on_ivasgn(node); end + def on_kwarg(node); end + def on_kwoptarg(node); end + def on_kwrestarg(node); end + def on_lvar(node); end + def on_lvasgn(node); end + def on_optarg(node); end + def on_restarg(node); end + + private + + def message(style); end +end + +RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::ConfigurableFormatting) + include(::RuboCop::Cop::ConfigurableNumbering) + + def on_arg(node); end + def on_cvasgn(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + + private + + def message(style); end +end + +RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::NegativeConditional + extend(::RuboCop::AST::NodePattern::Macros) + + def empty_condition?(node = _); end + def single_negative?(node = _); end + + private + + def check_negative_conditional(node); end +end + +RuboCop::Cop::NegativeConditional::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::NilMethods + + private + + def allowed_methods; end + def nil_methods; end + def other_stdlib_methods; end +end + +class RuboCop::Cop::Offense + include(::Comparable) + + def initialize(severity, location, message, cop_name, status = _); end + + def <=>(other); end + def ==(other); end + def column; end + def column_length; end + def column_range; end + def cop_name; end + def correctable?; end + def corrected?; end + def corrected_with_todo?; end + def disabled?; end + def eql?(other); end + def first_line; end + def hash; end + def highlighted_area; end + def last_column; end + def last_line; end + def line; end + def location; end + def message; end + def real_column; end + def severity; end + def source_line; end + def status; end + def to_s; end +end + +RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::OnNormalIfUnless + def on_if(node); end +end + +class RuboCop::Cop::OrderedGemCorrector + extend(::RuboCop::Cop::OrderedGemNode) + + def self.comments_as_separators; end + def self.correct(processed_source, node, previous_declaration, comments_as_separators); end + def self.processed_source; end +end + +module RuboCop::Cop::OrderedGemNode + + private + + def case_insensitive_out_of_order?(string_a, string_b); end + def consecutive_lines(previous, current); end + def find_gem_name(gem_node); end + def gem_name(declaration_node); end + def get_source_range(node, comments_as_separators); end + def register_offense(previous, current); end + def treat_comments_as_separators; end +end + +module RuboCop::Cop::Parentheses + + private + + def parens_required?(node); end +end + +class RuboCop::Cop::ParenthesesCorrector + def self.correct(node); end +end + +module RuboCop::Cop::ParserDiagnostic + def investigate(processed_source); end +end + +module RuboCop::Cop::PercentArray + + private + + def allowed_bracket_array?(node); end + def check_bracketed_array(node); end + def check_percent_array(node); end + def comments_in_array?(node); end + def invalid_percent_array_context?(node); end + def message(_node); end +end + +module RuboCop::Cop::PercentLiteral + include(::RuboCop::Cop::RangeHelp) + + + private + + def begin_source(node); end + def contents_range(node); end + def percent_literal?(node); end + def process(node, *types); end + def type(node); end +end + +class RuboCop::Cop::PercentLiteralCorrector + include(::RuboCop::PathUtil) + include(::RuboCop::Cop::Util) + + def initialize(config, preferred_delimiters); end + + def config; end + def correct(node, char); end + def preferred_delimiters; end + + private + + def autocorrect_multiline_words(node, escape, delimiters); end + def autocorrect_words(node, escape, delimiters); end + def delimiters_for(type); end + def end_content(source); end + def escape_words?(node); end + def first_line?(node, previous_line_num); end + def fix_escaped_content(word_node, escape, delimiters); end + def line_breaks(node, source, previous_line_num, base_line_num, node_indx); end + def new_contents(node, escape, delimiters); end + def process_lines(node, previous_line_num, base_line_num, source_in_lines); end + def process_multiline_words(node, escape, delimiters); end + def substitute_escaped_delimiters(content, delimiters); end + def wrap_contents(node, contents, char, delimiters); end +end + +module RuboCop::Cop::PrecedingFollowingAlignment + + private + + def aligned_assignment?(range, line); end + def aligned_char?(range, line); end + def aligned_comment_lines; end + def aligned_identical?(range, line); end + def aligned_operator?(range, line); end + def aligned_token?(range, line); end + def aligned_with_adjacent_line?(range, predicate); end + def aligned_with_any_line?(line_ranges, range, indent = _, &predicate); end + def aligned_with_any_line_range?(line_ranges, range, &predicate); end + def aligned_with_assignment(token, line_range); end + def aligned_with_line?(line_nos, range, indent = _); end + def aligned_with_operator?(range); end + def aligned_with_preceding_assignment(token); end + def aligned_with_something?(range); end + def aligned_with_subsequent_assignment(token); end + def aligned_words?(range, line); end + def allow_for_alignment?; end + def assignment_lines; end + def assignment_tokens; end + def relevant_assignment_lines(line_range); end + def remove_optarg_equals(asgn_tokens, processed_source); end +end + +class RuboCop::Cop::PreferredDelimiters + def initialize(type, config, preferred_delimiters); end + + def config; end + def delimiters; end + def type; end + + private + + def ensure_valid_preferred_delimiters; end + def preferred_delimiters; end + def preferred_delimiters_config; end +end + +RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::PunctuationCorrector + def self.add_space(token); end + def self.remove_space(space_before); end + def self.swap_comma(range); end +end + +module RuboCop::Cop::RangeHelp + + private + + def column_offset_between(base_range, range); end + def directions(side); end + def effective_column(range); end + def final_pos(src, pos, increment, newlines, whitespace); end + def move_pos(src, pos, step, condition, regexp); end + def range_between(start_pos, end_pos); end + def range_by_whole_lines(range, include_final_newline: _); end + def range_with_surrounding_comma(range, side = _); end + def range_with_surrounding_space(range:, side: _, newlines: _, whitespace: _); end + def source_range(source_buffer, line_number, column, length = _); end +end + +RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer) + +module RuboCop::Cop::RationalLiteral + extend(::RuboCop::AST::NodePattern::Macros) + + def rational_literal?(node = _); end +end + +module RuboCop::Cop::RegexpLiteralHelp + + private + + def freespace_mode_regexp?(node); end +end + +class RuboCop::Cop::Registry + include(::Enumerable) + + def initialize(cops = _, options = _); end + + def ==(other); end + def contains_cop_matching?(names); end + def cops; end + def department_missing?(badge, name); end + def departments; end + def dismiss(cop); end + def each(&block); end + def enabled(config, only = _, only_safe = _); end + def enabled?(cop, config, only_safe); end + def enabled_pending_cop?(cop_cfg, config); end + def enlist(cop); end + def find_by_cop_name(cop_name); end + def length; end + def names; end + def options; end + def print_warning(name, path); end + def qualified_cop_name(name, path, shall_warn = _); end + def select(&block); end + def sort!; end + def to_h; end + def unqualified_cop_names; end + def with_department(department); end + def without_department(department); end + + private + + def clear_enrollment_queue; end + def initialize_copy(reg); end + def qualify_badge(badge); end + def registered?(badge); end + def resolve_badge(given_badge, real_badge, source_path); end + def with(cops); end + + def self.all; end + def self.global; end + def self.qualified_cop_name(name, origin); end + def self.with_temporary_global(temp_global = _); end +end + +module RuboCop::Cop::RescueNode + def investigate(processed_source); end + + private + + def rescue_modifier?(node); end +end + +module RuboCop::Cop::SafeAssignment + extend(::RuboCop::AST::NodePattern::Macros) + + def empty_condition?(node = _); end + def safe_assignment?(node = _); end + def setter_method?(node = _); end + + private + + def safe_assignment_allowed?; end +end + +module RuboCop::Cop::Security +end + +class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Cop + def eval?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Cop + def autocorrect(node); end + def json_load(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Cop + def marshal_load(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Cop + def on_send(node); end + def open?(node = _); end + + private + + def composite_string?(node); end + def concatenated_string?(node); end + def interpolated_string?(node); end + def safe?(node); end + def safe_argument?(argument); end + def simple_string?(node); end +end + +RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def yaml_load(node = _); end +end + +RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Severity + include(::Comparable) + + def initialize(name_or_code); end + + def <=>(other); end + def ==(other); end + def code; end + def hash; end + def level; end + def name; end + def to_s; end + + def self.name_from_code(code); end +end + +RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Severity::NAMES = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::SpaceAfterPunctuation + def investigate(processed_source); end + + private + + def allowed_type?(token); end + def each_missing_space(tokens); end + def offset; end + def space_forbidden_before_rcurly?; end + def space_missing?(token1, token2); end + def space_required_before?(token); end +end + +RuboCop::Cop::SpaceAfterPunctuation::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::SpaceBeforePunctuation + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + + private + + def each_missing_space(tokens); end + def space_missing?(token1, token2); end + def space_required_after?(token); end + def space_required_after_lcurly?; end +end + +RuboCop::Cop::SpaceBeforePunctuation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::SpaceCorrector + extend(::RuboCop::Cop::RangeHelp) + extend(::RuboCop::Cop::SurroundingSpace) + + def self.add_space(processed_source, corrector, left_token, right_token); end + def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end + def self.processed_source; end + def self.remove_space(processed_source, corrector, left_token, right_token); end +end + +module RuboCop::Cop::StatementModifier + include(::RuboCop::Cop::LineLengthHelp) + + + private + + def length_in_modifier_form(node, cond); end + def max_line_length; end + def modifier_fits_on_single_line?(node); end + def non_eligible_body?(body); end + def non_eligible_condition?(condition); end + def non_eligible_node?(node); end + def single_line_as_modifier?(node); end +end + +module RuboCop::Cop::StringHelp + def on_regexp(node); end + def on_str(node); end + + private + + def inside_interpolation?(node); end +end + +class RuboCop::Cop::StringLiteralCorrector + extend(::RuboCop::PathUtil) + extend(::RuboCop::Cop::Util) + + def self.correct(node, style); end +end + +module RuboCop::Cop::StringLiteralsHelp + include(::RuboCop::Cop::StringHelp) + + + private + + def wrong_quotes?(node); end +end + +module RuboCop::Cop::Style +end + +class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def access_modifier_with_symbol?(node = _); end + def on_send(node); end + + private + + def access_modifier_is_inlined?(node); end + def access_modifier_is_not_inlined?(node); end + def group_style?; end + def inline_style?; end + def message(node); end + def offense?(node); end +end + +RuboCop::Cop::Style::AccessModifierDeclarations::GROUP_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::AccessModifierDeclarations::INLINE_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def identifier(node = _); end + def on_alias(node); end + def on_send(node); end + + private + + def add_offense_for_args(node); end + def alias_keyword_possible?(node); end + def alias_method_possible?(node); end + def bareword?(sym_node); end + def correct_alias_method_to_alias(send_node); end + def correct_alias_to_alias_method(node); end + def correct_alias_with_symbol_args(node); end + def lexical_scope_type(node); end + def scope_type(node); end +end + +RuboCop::Cop::Style::Alias::MSG_ALIAS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Alias::MSG_ALIAS_METHOD = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Alias::MSG_SYMBOL_ARGS = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_and(node); end + def on_if(node); end + def on_or(node); end + def on_until(node); end + def on_until_post(node); end + def on_while(node); end + def on_while_post(node); end + + private + + def correct_not(node, receiver, corrector); end + def correct_other(node, corrector); end + def correct_send(node, corrector); end + def correct_setter(node, corrector); end + def correctable_send?(node); end + def message(node); end + def on_conditionals(node); end + def process_logical_operator(node); end + def whitespace_before_arg(node); end +end + +RuboCop::Cop::Style::AndOr::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Style::AnnotationComment + + private + + def annotation?(comment); end + def just_first_word_of_sentence?(first_word, colon, space, note); end + def keyword?(word); end + def keyword_appearance?(first_word, colon, space); end + def split_comment(comment); end +end + +class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Cop + def autocorrect(node); end + def join_candidate?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Style::ArrayJoin::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::AsciiComments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def investigate(processed_source); end + + private + + def allowed_non_ascii_chars; end + def first_non_ascii_chars(string); end + def first_offense_range(comment); end + def only_allowed_non_ascii_chars?(string); end +end + +RuboCop::Cop::Style::AsciiComments::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def class_eval?(node = _); end + def on_send(node); end + + private + + def message(node); end + def replacement_method(node); end +end + +RuboCop::Cop::Style::Attr::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::AutoResourceCleanup < ::RuboCop::Cop::Cop + def on_send(node); end + + private + + def cleanup?(node); end +end + +RuboCop::Cop::Style::AutoResourceCleanup::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::AutoResourceCleanup::TARGET_METHODS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::BarePercentLiterals < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_dstr(node); end + def on_str(node); end + + private + + def add_offense_for_wrong_style(node, good, bad); end + def check(node); end + def requires_bare_percent?(source); end + def requires_percent_q?(source); end +end + +RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Cop + def on_preexe(node); end +end + +RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::BlockComments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(comment); end + def investigate(processed_source); end + + private + + def eq_end_part(comment, expr); end + def parts(comment); end +end + +RuboCop::Cop::Style::BlockComments::BEGIN_LENGTH = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Style::BlockComments::END_LENGTH = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Style::BlockComments::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::IgnoredMethods) + + def autocorrect(node); end + def on_block(node); end + def on_send(node); end + + private + + def array_or_range?(node); end + def braces_for_chaining_message(node); end + def braces_for_chaining_style?(node); end + def braces_required_message(node); end + def braces_required_method?(method_name); end + def braces_required_methods; end + def braces_style?(node); end + def conditional?(node); end + def correction_would_break_code?(node); end + def functional_block?(node); end + def functional_method?(method_name); end + def get_blocks(node, &block); end + def line_count_based_block_style?(node); end + def line_count_based_message(node); end + def message(node); end + def procedural_method?(method_name); end + def procedural_oneliners_may_have_braces?; end + def proper_block_style?(node); end + def replace_braces_with_do_end(loc); end + def replace_do_end_with_braces(loc); end + def return_value_of_scope?(node); end + def return_value_used?(node); end + def semantic_block_style?(node); end + def semantic_message(node); end + def special_method?(method_name); end + def special_method_proper_block_style?(node); end + def whitespace_after?(range, length = _); end + def whitespace_before?(range); end +end + +RuboCop::Cop::Style::BlockDelimiters::ALWAYS_BRACES_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CaseCorrector + extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper) + extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper) + + def self.correct(cop, node); end + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Cop + def case_equality?(node = _); end + def on_send(node); end + + private + + def const?(node); end +end + +RuboCop::Cop::Style::CaseEquality::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::StringHelp) + + def autocorrect(node); end + def correct_style_detected; end + def offense?(node); end + def opposite_style_detected; end +end + +RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_class(node); end + def on_module(node); end + + private + + def add_trailing_end(corrector, node, padding); end + def check_compact_style(node, body); end + def check_nested_style(node); end + def check_style(node, body); end + def compact_definition(corrector, node); end + def compact_identifier_name(node); end + def compact_node(corrector, node); end + def compact_node_name?(node); end + def indent_width; end + def leading_spaces(node); end + def nest_definition(corrector, node); end + def nest_or_compact(corrector, node); end + def one_child?(body); end + def remove_end(corrector, body); end + def replace_keyword_with_module(corrector, node); end + def split_on_double_colon(corrector, node, padding); end +end + +RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def class_check?(node = _); end + def message(node); end + def on_send(node); end +end + +RuboCop::Cop::Style::ClassCheck::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ClassMethods < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_class(node); end + def on_module(node); end + + private + + def check_defs(name, node); end + def message(node); end +end + +RuboCop::Cop::Style::ClassMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ClassVars < ::RuboCop::Cop::Cop + def message(node); end + def on_cvasgn(node); end +end + +RuboCop::Cop::Style::ClassVars::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MethodPreference) + + def autocorrect(node); end + def on_block(node); end + def on_send(node); end + + private + + def check_method_node(node); end + def message(node); end +end + +RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Cop + def autocorrect(node); end + def java_type_node?(node = _); end + def on_send(node); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ColonMethodDefinition < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_defs(node); end +end + +RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CommandLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_xstr(node); end + + private + + def allow_inner_backticks?; end + def allowed_backtick_literal?(node); end + def allowed_percent_x_literal?(node); end + def backtick_literal?(node); end + def check_backtick_literal(node); end + def check_percent_x_literal(node); end + def command_delimiter; end + def contains_backtick?(node); end + def contains_disallowed_backtick?(node); end + def default_delimiter; end + def message(node); end + def node_body(node); end + def preferred_delimiter; end + def preferred_delimiters_config; end +end + +RuboCop::Cop::Style::CommandLiteral::MSG_USE_BACKTICKS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::CommandLiteral::MSG_USE_PERCENT_X = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CommentAnnotation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Style::AnnotationComment) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(comment); end + def investigate(processed_source); end + + private + + def annotation_range(comment, margin, first_word, colon, space); end + def concat_length(*args); end + def correct_annotation?(first_word, colon, space, note); end + def first_comment_line?(comments, index); end + def inline_comment?(comment); end +end + +RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::CommentAnnotation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Cop + def investigate(processed_source); end + + private + + def line(comment); end + def message(comment); end + def offensive?(comment); end +end + +RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::CommentedKeyword::KEYWORDS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::CommentedKeyword::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Style::ConditionalAssignmentHelper) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def assignment_type?(node = _); end + def autocorrect(node); end + def candidate_condition?(node = _); end + def on_and_asgn(node); end + def on_case(node); end + def on_casgn(node); end + def on_cvasgn(node); end + def on_gvasgn(node); end + def on_if(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_op_asgn(node); end + def on_or_asgn(node); end + def on_send(node); end + + private + + def allowed_single_line?(branches); end + def allowed_statements?(branches); end + def allowed_ternary?(assignment); end + def assignment_node(node); end + def assignment_types_match?(*nodes); end + def candidate_node?(node); end + def check_assignment_to_condition(node); end + def check_node(node, branches); end + def correction_exceeds_line_limit?(node, branches); end + def include_ternary?; end + def indentation_width; end + def lhs_all_match?(branches); end + def line_length_cop_enabled?; end + def longest_line(node, assignment); end + def longest_line_exceeds_line_limit?(node, assignment); end + def max_line_length; end + def move_assignment_inside_condition(node); end + def move_assignment_outside_condition(node); end + def single_line_conditions_only?; end + def ternary_condition?(node); end +end + +RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::INDENTATION_WIDTH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::LINE_LENGTH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::MAX = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::ConditionalAssignment::WIDTH = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Style::ConditionalAssignmentHelper + extend(::RuboCop::AST::NodePattern::Macros) + + def end_with_eq?(sym); end + def expand_elses(branch); end + def expand_when_branches(when_branches); end + def indent(cop, source); end + def lhs(node); end + def tail(branch); end + + private + + def assignment_rhs_exist?(node); end + def expand_elsif(node, elsif_branches = _); end + def lhs_for_send(node); end + def setter_method?(method_name); end +end + +RuboCop::Cop::Style::ConditionalAssignmentHelper::ALIGN_WITH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignmentHelper::END_ALIGNMENT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignmentHelper::EQUAL = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Style::ConditionalCorrectorHelper + def assignment(node); end + def correct_branches(corrector, branches); end + def correct_if_branches(corrector, cop, node); end + def remove_whitespace_in_branches(corrector, branch, condition, column); end + def replace_branch_assignment(corrector, branch); end + def white_space_range(node, column); end +end + +class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Cop + def on_casgn(node); end + def visibility_declaration_for?(node = _, param1); end + + private + + def class_or_module_scope?(node); end + def match_name?(name, constant_name); end + def message(node); end + def visibility_declaration?(node); end +end + +RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(token); end + def investigate(processed_source); end + + private + + def autocorrect_notice; end + def encoding_token?(processed_source, token_index); end + def insert_notice_before(processed_source); end + def notice; end + def notice_found?(processed_source); end + def shebang_token?(processed_source, token_index); end + def verify_autocorrect_notice!; end +end + +RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Cop + def date_time?(node = _); end + def historic_date?(node = _); end + def on_send(node); end + def to_datetime?(node = _); end + + private + + def disallow_coercion?; end +end + +RuboCop::Cop::Style::DateTime::CLASS_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::DateTime::COERCION_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DefWithParentheses < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Cop + def autocorrect(node); end + def dir_replacement?(node = _); end + def on_send(node); end + + private + + def file_keyword?(node); end +end + +RuboCop::Cop::Style::Dir::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Cop + def autocorrect(comment); end + def investigate(processed_source); end + + private + + def rubocop_directive_comment?(comment); end +end + +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Style::AnnotationComment) + include(::RuboCop::Cop::DocumentationComment) + + def constant_definition?(node = _); end + def constant_visibility_declaration?(node = _); end + def on_class(node); end + def on_module(node); end + def outer_module(node0); end + + private + + def check(node, body, type); end + def compact_namespace?(node); end + def constant_declaration?(node); end + def namespace?(node); end + def nodoc(node); end + def nodoc?(comment, require_all = _); end + def nodoc_comment?(node, require_all = _); end +end + +RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Style::AnnotationComment) + include(::RuboCop::Cop::DocumentationComment) + include(::RuboCop::Cop::DefNode) + + def module_function_node?(node = _); end + def on_def(node); end + def on_defs(node); end + + private + + def check(node); end + def require_for_non_public_methods?; end +end + +RuboCop::Cop::Style::DocumentationMethod::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DoubleCopDisableDirective < ::RuboCop::Cop::Cop + def autocorrect(comment); end + def investigate(processed_source); end +end + +RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def double_negative?(node = _); end + def on_send(node); end + + private + + def allowed_in_returns?(node); end + def end_of_method_definition?(node); end + def find_def_node_from_ascendant(node); end +end + +RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Cop + def autocorrect(node); end + def offending_each_range(node = _); end + def on_block(node); end +end + +RuboCop::Cop::Style::EachForSimpleLoop::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def each_with_object_candidate?(node = _); end + def on_block(node); end + + private + + def accumulator_param_assigned_to?(body, args); end + def first_argument_returned?(args, return_value); end + def return_value(body); end + def return_value_occupies_whole_line?(node); end + def simple_method_arg?(method_arg); end + def whole_line_expression(node); end +end + +RuboCop::Cop::Style::EachWithObject::METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::EachWithObject::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyBlockParameter < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::EmptyParameter) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end +end + +RuboCop::Cop::Style::EmptyBlockParameter::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyCaseCondition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(case_node); end + def on_case(case_node); end + + private + + def correct_case_when(corrector, case_node, when_nodes); end + def correct_when_conditions(corrector, when_nodes); end + def keep_first_when_comment(case_node, first_when_node, corrector); end +end + +RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyElse < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::OnNormalIfUnless) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_case(node); end + def on_normal_if_unless(node); end + + private + + def autocorrect_forbidden?(type); end + def base_node(node); end + def check(node); end + def comment_in_else?(node); end + def else_line_range(loc); end + def empty_check(node); end + def empty_style?; end + def missing_else_style; end + def nil_check(node); end + def nil_style?; end +end + +RuboCop::Cop::Style::EmptyElse::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyLambdaParameter < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::EmptyParameter) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end +end + +RuboCop::Cop::Style::EmptyLambdaParameter::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FrozenStringLiteral) + include(::RuboCop::Cop::RangeHelp) + + def array_node(node = _); end + def array_with_block(node = _); end + def autocorrect(node); end + def hash_node(node = _); end + def hash_with_block(node = _); end + def on_send(node); end + def str_node(node = _); end + + private + + def correction(node); end + def enforce_double_quotes?; end + def first_argument_unparenthesized?(node); end + def offense_array_node?(node); end + def offense_hash_node?(node); end + def preferred_string_literal; end + def replacement_range(node); end + def string_literals_config; end +end + +RuboCop::Cop::Style::EmptyLiteral::ARR_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::EmptyLiteral::HASH_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::EmptyLiteral::STR_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def compact?(node); end + def compact_style?; end + def correct_style?(node); end + def corrected(node); end + def expanded?(node); end + def expanded_style?; end + def joint(node); end + def message(_node); end +end + +RuboCop::Cop::Style::EmptyMethod::MSG_COMPACT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::EmptyMethod::MSG_EXPANDED = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Encoding < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + + private + + def encoding_line_number(processed_source); end + def encoding_omitable?(line); end + def offense(processed_source, line_number); end +end + +RuboCop::Cop::Style::Encoding::ENCODING_PATTERN = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::Encoding::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Encoding::SHEBANG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EndBlock < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_postexe(node); end +end + +RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Cop + def eval_without_location?(node = _); end + def line_with_offset?(node = _, param1, param2); end + def on_send(node); end + + private + + def add_offense_for_different_line(node, line_node, line_diff); end + def add_offense_for_same_line(node, line_node); end + def message_incorrect_line(actual, sign, line_diff); end + def on_with_lineno(node, code); end + def special_file_keyword?(node); end + def special_line_keyword?(node); end + def string_first_line(str_node); end + def with_lineno?(node); end +end + +RuboCop::Cop::Style::EvalWithLocation::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Cop + def autocorrect(node); end + def even_odd_candidate?(node = _); end + def on_send(node); end + + private + + def replacement_method(arg, method); end +end + +RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def file_expand_path(node = _); end + def on_send(node); end + def pathname_new_parent_expand_path(node = _); end + def pathname_parent_expand_path(node = _); end + + private + + def arguments_range(node); end + def autocorrect_expand_path(corrector, current_path, default_dir); end + def depth(current_path); end + def inspect_offense_for_expand_path(node, current_path, default_dir); end + def parent_path(current_path); end + def remove_parent_method(corrector, default_dir); end + def strip_surrounded_quotes!(path_string); end + def unrecommended_argument?(default_dir); end +end + +RuboCop::Cop::Style::ExpandPathArguments::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_NEW_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ExponentialNotation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def on_float(node); end + + private + + def engineering?(node); end + def integral(node); end + def message(_node); end + def offense?(node); end + def scientific?(node); end +end + +class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def any_coerce?(node = _); end + def both_coerce?(node = _); end + def left_coerce?(node = _); end + def on_send(node); end + def right_coerce?(node = _); end + + private + + def message(_node); end + def offense_condition?(node); end +end + +class RuboCop::Cop::Style::For < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + def on_for(node); end + + private + + def suspect_enumerable?(node); end +end + +RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::For::PREFER_FOR = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def formatter(node = _); end + def message(detected_style); end + def method_name(style_name); end + def on_send(node); end + def variable_argument?(node = _); end + + private + + def autocorrect_from_percent(corrector, node); end + def autocorrect_to_percent(corrector, node); end +end + +RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def format_string_in_typical_context?(node = _); end + def on_str(node); end + + private + + def message(detected_style); end + def message_text(style); end + def str_contents(source_map); end + def token_ranges(contents); end + def tokens(str_node, &block); end + def unannotated_format?(node, detected_style); end +end + +class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::FrozenStringLiteral) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def investigate(processed_source); end + + private + + def disabled_offense(processed_source); end + def enable_comment(corrector); end + def ensure_comment(processed_source); end + def ensure_enabled_comment(processed_source); end + def ensure_no_comment(processed_source); end + def following_comment; end + def frozen_string_literal_comment(processed_source); end + def insert_comment(corrector); end + def last_special_comment(processed_source); end + def line_range(line); end + def missing_offense(processed_source); end + def missing_true_offense(processed_source); end + def preceding_comment; end + def remove_comment(corrector, node); end + def unnecessary_comment_offense(processed_source); end +end + +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_DISABLED = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING_TRUE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::GlobalVars < ::RuboCop::Cop::Cop + def allowed_var?(global_var); end + def check(node); end + def on_gvar(node); end + def on_gvasgn(node); end + def user_vars; end +end + +RuboCop::Cop::Style::GlobalVars::BUILT_IN_VARS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::GlobalVars::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MinBodyLength) + include(::RuboCop::Cop::LineLengthHelp) + include(::RuboCop::Cop::StatementModifier) + + def on_def(node); end + def on_defs(node); end + def on_if(node); end + + private + + def accepted_form?(node, ending = _); end + def accepted_if?(node, ending); end + def check_ending_if(node); end + def guard_clause_source(guard_clause); end + def opposite_keyword(node); end + def register_offense(node, scope_exiting_keyword, conditional_keyword); end + def too_long_for_single_line?(node, example); end +end + +RuboCop::Cop::Style::GuardClause::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Lint::UnusedArgument) + + def autocorrect(node); end + def kv_each(node = _); end + def on_block(node); end + + private + + def check_argument(variable); end + def correct_args(node, corrector); end + def correct_implicit(node, corrector, method_name); end + def correct_key_value_each(node, corrector); end + def kv_range(outer_node); end + def register_kv_offense(node); end + def used?(arg); end +end + +RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def alternative_style; end + def autocorrect(node); end + def hash_rockets_check(pairs); end + def no_mixed_keys_check(pairs); end + def on_hash(node); end + def ruby19_check(pairs); end + def ruby19_no_mixed_keys_check(pairs); end + + private + + def acceptable_19_syntax_symbol?(sym_name); end + def argument_without_space?(node); end + def autocorrect_hash_rockets(corrector, pair_node); end + def autocorrect_no_mixed_keys(corrector, pair_node); end + def autocorrect_ruby19(corrector, pair_node); end + def check(pairs, delim, msg); end + def force_hash_rockets?(pairs); end + def range_for_autocorrect_ruby19(pair_node); end + def sym_indices?(pairs); end + def word_symbol_pair?(pair); end +end + +RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::HashTransformMethod) + extend(::RuboCop::Cop::TargetRubyVersion) + + def on_bad_each_with_object(node = _); end + def on_bad_hash_brackets_map(node = _); end + def on_bad_map_to_h(node = _); end + + private + + def extract_captures(match); end + def new_method_name; end +end + +class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::HashTransformMethod) + + def on_bad_each_with_object(node = _); end + def on_bad_hash_brackets_map(node = _); end + def on_bad_map_to_h(node = _); end + + private + + def extract_captures(match); end + def new_method_name; end +end + +class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Cop + def on_case(node); end + def on_if(node); end + + private + + def check_branches(branches); end + def check_expressions(expressions); end + def expand_elses(branch); end + def head(node); end + def message(node); end + def tail(node); end +end + +RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::IfCorrector + extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper) + extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper) + + def self.correct(cop, node); end + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Cop + def on_if(node); end + + private + + def allow_if_modifier?; end + def allow_if_modifier_in_else_branch?(else_branch); end +end + +RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::LineLengthHelp) + include(::RuboCop::Cop::StatementModifier) + include(::RuboCop::Cop::IgnoredPattern) + + def autocorrect(node); end + def on_if(node); end + + private + + def another_statement_on_same_line?(node); end + def eligible_node?(node); end + def first_line_comment(node); end + def ignored_patterns; end + def line_length_enabled_at_line?(line); end + def named_capture_in_condition?(node); end + def non_eligible_if?(node); end + def parenthesize?(node); end + def to_modifier_form(node); end + def to_normal_form(node); end + def too_long_due_to_modifier?(node); end + def too_long_line_based_on_allow_uri?(line); end + def too_long_line_based_on_config?(range, line); end + def too_long_line_based_on_ignore_cop_directives?(range, line); end + def too_long_single_line?(node); end +end + +RuboCop::Cop::Style::IfUnlessModifier::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::LineLengthHelp) + include(::RuboCop::Cop::StatementModifier) + + def on_if(node); end +end + +RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::OnNormalIfUnless) + + def autocorrect(node); end + def on_normal_if_unless(node); end + + private + + def correct_to_ternary(node); end +end + +RuboCop::Cop::Style::IfWithSemicolon::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Cop + def implicit_runtime_error_raise_or_fail(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Style::ImplicitRuntimeError::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::InfiniteLoop < ::RuboCop::Cop::Cop + def after_leaving_scope(scope, _variable_table); end + def autocorrect(node); end + def join_force?(force_class); end + def on_until(node); end + def on_until_post(node); end + def on_while(node); end + def on_while_post(node); end + + private + + def assigned_before_loop?(var, range); end + def assigned_inside_loop?(var, range); end + def configured_indent; end + def modifier_replacement(node); end + def non_modifier_range(node); end + def referenced_after_loop?(var, range); end + def replace_begin_end_with_modifier(node); end + def replace_source(range, replacement); end + def while_or_until(node); end +end + +RuboCop::Cop::Style::InfiniteLoop::LEADING_SPACE = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::InfiniteLoop::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::InlineComment < ::RuboCop::Cop::Cop + def investigate(processed_source); end +end + +RuboCop::Cop::Style::InlineComment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def correct_inverse_block(node); end + def correct_inverse_method(node); end + def correct_inverse_selector(block, corrector); end + def inverse_block?(node = _); end + def inverse_candidate?(node = _); end + def on_block(node); end + def on_send(node); end + + private + + def camel_case_constant?(node); end + def dot_range(loc); end + def end_parentheses(node, method_call); end + def inverse_blocks; end + def inverse_methods; end + def negated?(node); end + def not_to_receiver(node, method_call); end + def possible_class_hierarchy_check?(lhs, rhs, method); end + def remove_end_parenthesis(corrector, node, method, method_call); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::InverseMethods::CLASS_COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::InverseMethods::EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::StringHelp) + + def correct_style_detected; end + def offense?(node); end + def opposite_style_detected; end + + private + + def allowed_addresses; end + def could_be_ip?(str); end + def starts_with_hex_or_colon?(str); end + def too_long?(str); end +end + +RuboCop::Cop::Style::IpAddresses::IPV6_MAX_SIZE = T.let(T.unsafe(nil), Integer) + +RuboCop::Cop::Style::IpAddresses::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_block(node); end + def on_numblock(node); end + + private + + def arguments_with_whitespace(node); end + def autocorrect_method_to_literal(corrector, node); end + def lambda_arg_string(args); end + def message(node, selector); end + def message_line_modifier(node); end + def offending_selector?(node, selector); end +end + +RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_send(node); end + + private + + def explicit_style?; end + def implicit_style?; end + def message(_node); end + def offense?(node); end +end + +class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(operator_range); end + def investigate(processed_source); end + + private + + def check_token_set(index); end + def eligible_next_successor?(next_successor); end + def eligible_operator?(operator); end + def eligible_predecessor?(predecessor); end + def eligible_successor?(successor); end + def eligible_token_set?(predecessor, operator, successor); end + def standard_string_literal?(token); end + def token_after_last_string(successor, base_index); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol) + +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_END_TOKEN = T.let(T.unsafe(nil), Symbol) + +RuboCop::Cop::Style::LineEndConcatenation::CONCAT_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::LineEndConcatenation::HIGH_PRECEDENCE_OP_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::LineEndConcatenation::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::LineEndConcatenation::QUOTE_DELIMITERS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::LineEndConcatenation::SIMPLE_STRING_TOKEN_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::IgnoredMethods) + include(::RuboCop::Cop::IgnoredPattern) + + def initialize(*_); end + + def autocorrect(_node); end + + private + + def args_begin(node); end + def args_end(node); end + def args_parenthesized?(node); end +end + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + def autocorrect(node); end + def message(_node = _); end + def on_csend(node); end + def on_send(node); end + def on_super(node); end + def on_yield(node); end + + private + + def allowed_camel_case_method_call?(node); end + def allowed_chained_call_with_parentheses?(node); end + def allowed_multiline_call_with_parentheses?(node); end + def ambigious_literal?(node); end + def assigned_before?(node, target); end + def call_as_argument_or_chain?(node); end + def call_in_literals?(node); end + def call_in_logical_operators?(node); end + def call_in_optional_arguments?(node); end + def call_with_ambiguous_arguments?(node); end + def call_with_braced_block?(node); end + def hash_literal?(node); end + def hash_literal_in_arguments?(node); end + def legitimate_call_with_parentheses?(node); end + def logical_operator?(node); end + def parentheses_at_the_end_of_multiline_call?(node); end + def regexp_slash_literal?(node); end + def splat?(node); end + def super_call_without_arguments?(node); end + def ternary_if?(node); end + def unary_literal?(node); end +end + +RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp) + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + def autocorrect(node); end + def message(_node = _); end + def on_csend(node); end + def on_send(node); end + def on_super(node); end + def on_yield(node); end + + private + + def eligible_for_parentheses_omission?(node); end + def ignored_macro?(node); end + def included_macros_list; end +end + +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::IgnoredMethods) + + def autocorrect(node); end + def on_send(node); end + + private + + def any_assignment?(node); end + def ineligible_node?(node); end + def same_name_assignment?(node); end + def variable_in_mass_assignment?(variable_name, node); end +end + +RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def on_block(node); end + def on_csend(node); end + def on_send(node); end +end + +RuboCop::Cop::Style::MethodCalledOnDoEndBlock::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def arguments_without_parentheses?(node); end + def correct_arguments(arg_node, corrector); end + def correct_definition(def_node, corrector); end + def missing_parentheses(node); end + def require_parentheses?(args); end + def unwanted_parentheses(args); end +end + +RuboCop::Cop::Style::MethodDefParentheses::MSG_MISSING = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MethodMissingSuper < ::RuboCop::Cop::Cop + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Style::MethodMissingSuper::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Cop + def autocorrect(node); end + def min_max_candidate(node = _); end + def on_array(node); end + def on_return(node); end + + private + + def argument_range(node); end + def message(offender, receiver); end + def offending_range(node); end +end + +RuboCop::Cop::Style::MinMax::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::OnNormalIfUnless) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def on_case(node); end + def on_normal_if_unless(node); end + + private + + def case_style?; end + def check(node); end + def empty_else_config; end + def empty_else_cop_enabled?; end + def empty_else_style; end + def if_style?; end + def message(node); end + def unless_else_config; end + def unless_else_cop_enabled?; end +end + +RuboCop::Cop::Style::MissingElse::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::MissingElse::MSG_EMPTY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Cop + def on_def(node); end + def on_defs(node); end + + private + + def implements_respond_to_missing?(node); end +end + +RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MixinGrouping < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_class(node); end + def on_module(node); end + + private + + def check(send_node); end + def check_grouped_style(send_node); end + def check_separated_style(send_node); end + def group_mixins(node, mixins); end + def grouped_style?; end + def indent(node); end + def message(send_node); end + def range_to_remove_for_subsequent_mixin(mixins, node); end + def separate_mixins(node); end + def separated_style?; end + def sibling_mixins(send_node); end +end + +RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Cop + def include_statement(node = _); end + def on_send(node); end + def wrapped_macro_scope?(node = _); end + + private + + def accepted_include?(node); end + def ascend_macro_scope?(ancestor); end + def belongs_to_class_or_module?(node); end +end + +RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def extend_self_node?(node = _); end + def module_function_node?(node = _); end + def on_module(node); end + def private_directive?(node = _); end + + private + + def check_extend_self(nodes); end + def check_forbidden(nodes); end + def check_module_function(nodes); end + def each_wrong_style(nodes, &block); end + def message(_node); end +end + +RuboCop::Cop::Style::ModuleFunction::EXTEND_SELF_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def on_block(node); end +end + +RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::LineLengthHelp) + include(::RuboCop::Cop::StatementModifier) + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_if(node); end + + private + + def configured_indentation_width; end + def indented_body(body, node); end + def message(node); end + def to_normal_if(node); end +end + +RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::OnNormalIfUnless) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_normal_if_unless(node); end + + private + + def non_modifier_then?(node); end +end + +RuboCop::Cop::Style::MultilineIfThen::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::MultilineIfThen::NON_MODIFIER_THEN = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Style::MultilineMemoization < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_or_asgn(node); end + + private + + def bad_rhs?(rhs); end + def keyword_autocorrect(node, corrector); end + def keyword_begin_str(node, node_buf); end + def keyword_end_str(node, node_buf); end +end + +RuboCop::Cop::Style::MultilineMemoization::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Cop + def on_def(node); end + def on_defs(node); end + + private + + def closing_line(node); end + def correction_exceeds_max_line_length?(node); end + def definition_width(node); end + def indentation_width(node); end + def max_line_length; end + def opening_line(node); end +end + +RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Cop + def on_if(node); end +end + +RuboCop::Cop::Style::MultilineTernaryOperator::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def accept_node_type?(node); end + def autocorrect(node); end + def on_when(node); end + def require_then?(when_node); end +end + +RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Cop + def on_or(node); end + def simple_comparison?(node = _); end + def simple_double_comparison?(node = _); end + + private + + def comparison?(node); end + def nested_comparison?(node); end + def nested_variable_comparison?(node); end + def root_of_or_node(or_node); end + def variable_name(node); end + def variables_in_node(node); end + def variables_in_simple_node(node); end +end + +RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FrozenStringLiteral) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_casgn(node); end + def on_or_asgn(node); end + def operation_produces_immutable_object?(node = _); end + def range_enclosed_in_parentheses?(node = _); end + def splat_value(node = _); end + + private + + def check(value); end + def correct_splat_expansion(corrector, expr, splat_value); end + def frozen_string_literal?(node); end + def immutable_literal?(node); end + def mutable_literal?(value); end + def on_assignment(value); end + def requires_parentheses?(node); end + def strict_check(value); end +end + +RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NegatedIf < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::NegativeConditional) + + def autocorrect(node); end + def on_if(node); end + + private + + def correct_style?(node); end + def message(node); end +end + +class RuboCop::Cop::Style::NegatedUnless < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::NegativeConditional) + + def autocorrect(node); end + def on_if(node); end + + private + + def correct_style?(node); end + def message(node); end +end + +class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::NegativeConditional) + + def autocorrect(node); end + def on_until(node); end + def on_while(node); end + + private + + def message(node); end +end + +class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def add_parentheses_to_method_arguments(send_node); end + def autocorrect(node); end + def check(node); end + def left_hand_operand(node, operator); end + def modifier?(node); end + def new_expression(inner_node); end + def on_if(node); end + def on_until(node); end + def on_while(node); end + def replacement_operator(keyword); end + def requires_parens?(node); end + def right_hand_operand(node, left_hand_keyword); end +end + +RuboCop::Cop::Style::NestedModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NestedParenthesizedCalls < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(nested); end + def on_csend(node); end + def on_send(node); end + + private + + def allowed?(send_node); end + def allowed_methods; end + def allowed_omission?(send_node); end +end + +RuboCop::Cop::Style::NestedParenthesizedCalls::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Cop + def on_if(node); end +end + +RuboCop::Cop::Style::NestedTernaryOperator::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::MinBodyLength) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def investigate(_processed_source); end + def on_block(node); end + def on_for(node); end + def on_until(node); end + def on_while(node); end + + private + + def actual_indent(lines, buffer); end + def allowed_modifier_if?(node); end + def autocorrect_block(corrector, node); end + def autocorrect_modifier(corrector, node); end + def check(node); end + def cond_range(node, cond); end + def end_followed_by_whitespace_only?(source_buffer, end_pos); end + def end_range(node); end + def ends_with_condition?(body); end + def exit_body_type?(node); end + def heredoc_lines(node); end + def if_else_children?(node); end + def if_without_else?(node); end + def offense_location(offense_node); end + def offense_node(body); end + def reindent(lines, node, corrector); end + def reindent_line(corrector, lineno, delta, buffer); end + def reindentable_lines(node); end + def simple_if_without_break?(node); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::Next::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def nil_check?(node = _); end + def nil_comparison?(node = _); end + def on_send(node); end + + private + + def message(_node); end + def prefer_comparison?; end + def style_check?(node, &block); end +end + +RuboCop::Cop::Style::NilComparison::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Cop + def autocorrect(node); end + def nil_check?(node = _); end + def not_and_nil_check?(node = _); end + def not_equal_to_nil?(node = _); end + def on_def(node); end + def on_defs(node); end + def on_send(node); end + def unless_check?(node = _); end + + private + + def autocorrect_comparison(node); end + def autocorrect_non_nil(node, inner_node); end + def autocorrect_unless_nil(node, receiver); end + def include_semantic_changes?; end + def message(node); end + def unless_and_nil_check?(send_node); end +end + +class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + + private + + def correct_opposite_method(range, child); end + def correct_with_parens(range, node); end + def correct_without_parens(range); end + def opposite_method?(child); end + def requires_parens?(child); end +end + +RuboCop::Cop::Style::Not::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::Not::OPPOSITE_METHODS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::NumericLiteralPrefix < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::IntegerNode) + + def autocorrect(node); end + def on_int(node); end + + private + + def format_binary(source); end + def format_decimal(source); end + def format_hex(source); end + def format_octal(source); end + def format_octal_zero_only(source); end + def hex_bin_dec_literal_type(literal); end + def literal_type(node); end + def message(node); end + def octal_literal_type(literal); end + def octal_zero_only?; end +end + +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_REGEX = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_REGEX = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Style::NumericLiterals < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::IntegerNode) + + def autocorrect(node); end + def on_float(node); end + def on_int(node); end + + private + + def check(node); end + def format_int_part(int_part); end + def format_number(node); end + def max_parameter_name; end + def min_digits; end + def short_group_regex; end +end + +RuboCop::Cop::Style::NumericLiterals::DELIMITER_REGEXP = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::NumericLiterals::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::IgnoredMethods) + + def autocorrect(node); end + def comparison(node = _); end + def inverted_comparison(node = _); end + def on_send(node); end + def predicate(node = _); end + + private + + def check(node); end + def invert; end + def parenthesized_source(node); end + def replacement(numeric, operation); end + def require_parentheses?(node); end +end + +RuboCop::Cop::Style::NumericPredicate::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::NumericPredicate::REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::OnNormalIfUnless) + + def autocorrect(node); end + def on_normal_if_unless(node); end + + private + + def expr_replacement(node); end + def keyword_with_changed_precedence?(node); end + def message(node); end + def method_call_with_changed_precedence?(node); end + def replacement(node); end + def requires_parentheses?(node); end + def to_ternary(node); end +end + +RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Cop + def on_args(node); end + def option_hash(node = _); end + + private + + def allowlist; end + def super_used?(node); end + def suspicious_name?(arg_name); end +end + +RuboCop::Cop::Style::OptionHash::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::OptionalArguments < ::RuboCop::Cop::Cop + def on_def(node); end + + private + + def argument_positions(arguments); end + def each_misplaced_optional_arg(arguments); end +end + +RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_cvasgn(node); end + def on_gvasgn(node); end + def on_if(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + def ternary_assignment?(node = _); end + def unless_assignment?(node = _); end + + private + + def take_variable_and_default_from_ternary(node); end + def take_variable_and_default_from_unless(node); end +end + +RuboCop::Cop::Style::OrAssignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RescueNode) + + def autocorrect(node); end + def implicit_self_getter?(node = _); end + def on_masgn(node); end + + private + + def add_self_to_getters(right_elements); end + def allowed_lhs?(node); end + def allowed_masign?(lhs_elements, rhs_elements); end + def allowed_rhs?(node); end + def assignment_corrector(node, order); end + def find_valid_order(left_elements, right_elements); end + def modifier_statement?(node); end + def return_of_method_call?(node); end +end + +class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter + include(::TSort) + extend(::RuboCop::AST::NodePattern::Macros) + + def initialize(assignments); end + + def accesses?(rhs, lhs); end + def dependency?(lhs, rhs); end + def matching_calls(node0, param1, param2); end + def tsort_each_child(assignment); end + def tsort_each_node; end + def uses_var?(node0, param1); end + def var_name(node = _); end +end + +class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + include(::RuboCop::Cop::Alignment) + + def initialize(node, config, new_elements); end + + def config; end + def correction; end + def correction_range; end + def node; end + + protected + + def assignment; end + + private + + def cop_config; end + def extract_sources(node); end + def source(node); end +end + +RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + def correction; end + def correction_range; end + + private + + def modifier_range(node); end +end + +class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + def correction; end + def correction_range; end + + private + + def begin_correction(rescue_result); end + def def_correction(rescue_result); end +end + +class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::SafeAssignment) + include(::RuboCop::Cop::Parentheses) + + def autocorrect(node); end + def control_op_condition(node = _); end + def on_if(node); end + def on_until(node); end + def on_while(node); end + + private + + def allow_multiline_conditions?; end + def message(node); end + def modifier_op?(node); end + def parens_allowed?(node); end + def process_control_op(node); end +end + +class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def message(node); end + def on_array(node); end + def on_dstr(node); end + def on_regexp(node); end + def on_str(node); end + def on_sym(node); end + def on_xstr(node); end + + private + + def contains_delimiter?(node, delimiters); end + def contains_preferred_delimiter?(node, type); end + def include_same_character_as_used_for_delimiter?(node, type); end + def matchpairs(begin_delimiter); end + def on_percent_literal(node); end + def preferred_delimiters_for(type); end + def string_source(node); end + def uses_preferred_delimiter?(node, type); end +end + +class RuboCop::Cop::Style::PercentQLiterals < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_str(node); end + + private + + def correct_literal_style?(node); end + def corrected(src); end + def message(_node); end + def on_percent_literal(node); end +end + +RuboCop::Cop::Style::PercentQLiterals::LOWER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_nth_ref(node); end +end + +RuboCop::Cop::Style::PerlBackrefs::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def message(node); end + def offending_selector?(method_name); end + def proper_method_name(method_name); end +end + +RuboCop::Cop::Style::PreferredHashMethods::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_block(node); end + def proc_new?(node = _); end +end + +RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RaiseArgs < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_send(node); end + + private + + def acceptable_exploded_args?(args); end + def check_compact(node); end + def check_exploded(node); end + def correction_compact_to_exploded(node); end + def correction_exploded_to_compact(node); end + def message(node); end + def requires_parens?(parent); end +end + +RuboCop::Cop::Style::RaiseArgs::COMPACT_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Cop + def autocorrect(node); end + def integer_op_rand?(node = _); end + def namespace(node = _); end + def on_send(node); end + def rand_modified?(node = _); end + def rand_op_integer?(node = _); end + def random_call(node = _); end + def to_int(node = _); end + + private + + def boundaries_from_random_node(random_node); end + def corrected_integer_op_rand(node); end + def corrected_rand_modified(node); end + def corrected_rand_op_integer(node); end + def prefix_from_prefix_node(node); end +end + +RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_block(node); end + def on_def(node); end + def on_defs(node); end + + private + + def check(node); end +end + +RuboCop::Cop::Style::RedundantBegin::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantCapitalW < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_array(node); end + + private + + def on_percent_literal(node); end + def requires_interpolation?(node); end +end + +RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_if(node); end + + private + + def correct_ternary(corrector, node); end + def else_source(else_branch); end + def make_ternary_form(node); end + def message(node); end + def offense?(node); end + def range_of_offense(node); end + def use_if_branch?(else_branch); end +end + +RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_if(node); end + def redundant_condition?(node = _); end + def redundant_condition_inverted?(node = _); end + + private + + def configured_indentation_width; end + def indented_else_node(expression, node); end + def invert_expression?(node); end + def message(node); end + def offense?(node); end + def replacement_condition(node); end +end + +RuboCop::Cop::Style::RedundantConditional::COMPARISON_OPERATOR_MATCHER = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Cop + def autocorrect(node); end + def compact?(node = _); end + def exploded?(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Style::RedundantException::MSG_1 = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::FrozenStringLiteral) + + def autocorrect(node); end + def on_send(node); end + def operation_produces_immutable_object?(node = _); end + + private + + def immutable_literal?(node); end + def strip_parenthesis(node); end +end + +RuboCop::Cop::Style::RedundantFreeze::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::PercentLiteral) + + def autocorrect(node); end + def on_dstr(node); end + + private + + def autocorrect_other(embedded_node, node); end + def autocorrect_single_variable_interpolation(embedded_node, node); end + def autocorrect_variable_interpolation(embedded_node, node); end + def embedded_in_percent_array?(node); end + def implicit_concatenation?(node); end + def interpolation?(node); end + def single_interpolation?(node); end + def single_variable_interpolation?(node); end + def variable_interpolation?(node); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Parentheses) + + def arg_in_call_with_block?(node = _); end + def autocorrect(node); end + def first_send_argument?(node = _); end + def first_super_argument?(node = _); end + def method_node_and_args(node = _); end + def on_begin(node); end + def range_end?(node = _); end + def rescue?(node = _); end + def square_brackets?(node = _); end + + private + + def allowed_ancestor?(node); end + def allowed_array_or_hash_element?(node); end + def allowed_expression?(node); end + def allowed_method_call?(node); end + def allowed_multiple_expression?(node); end + def array_element?(node); end + def call_chain_starts_with_int?(begin_node, send_node); end + def check(begin_node); end + def check_send(begin_node, node); end + def check_unary(begin_node, node); end + def disallowed_literal?(begin_node, node); end + def empty_parentheses?(node); end + def first_arg_begins_with_hash_literal?(node); end + def first_argument?(node); end + def hash_element?(node); end + def keyword_ancestor?(node); end + def keyword_with_redundant_parentheses?(node); end + def method_call_with_redundant_parentheses?(node); end + def method_chain_begins_with_hash_literal?(node); end + def offense(node, msg); end + def only_begin_arg?(args); end + def only_closing_paren_before_comma?(node); end + def parens_allowed?(node); end + def raised_to_power_negative_numeric?(begin_node, node); end + def suspect_unary?(node); end +end + +class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_dstr(node); end + def on_str(node); end + + private + + def acceptable_capital_q?(node); end + def acceptable_q?(node); end + def allowed_percent_q?(node); end + def check(node); end + def interpolated_quotes?(node); end + def message(node); end + def start_with_percent_q_variant?(string); end + def string_literal?(node); end +end + +RuboCop::Cop::Style::RedundantPercentQ::DYNAMIC_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::EMPTY = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::ESCAPED_NON_BACKSLASH = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Style::RedundantPercentQ::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_CAPITAL_Q = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_Q = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::QUOTE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::MatchRange) + include(::RuboCop::Cop::RegexpLiteralHelp) + + def autocorrect(node); end + def each_redundant_character_class(node); end + def on_regexp(node); end + + private + + def whitespace_in_free_space_mode?(node, loc); end + def without_character_class(loc); end +end + +RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLASS = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantRegexpCharacterClass::PATTERN = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::RegexpLiteralHelp) + + def autocorrect(node); end + def on_regexp(node); end + + private + + def allowed_escape?(node, char, within_character_class); end + def each_escape(node); end + def escape_range_at_index(node, index); end + def pattern_source(node); end + def slash_literal?(node); end +end + +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_ALWAYS_ESCAPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def add_braces(corrector, node); end + def add_brackets(corrector, node); end + def allow_multiple_return_values?; end + def check_begin_node(node); end + def check_branch(node); end + def check_case_node(node); end + def check_ensure_node(node); end + def check_if_node(node); end + def check_rescue_node(node); end + def check_return_node(node); end + def correct_with_arguments(return_node, corrector); end + def correct_without_arguments(return_node, corrector); end + def hash_without_braces?(node); end + def message(node); end +end + +RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Cop + def initialize(config = _, options = _); end + + def autocorrect(node); end + def on_and_asgn(node); end + def on_args(node); end + def on_block(node); end + def on_blockarg(node); end + def on_def(node); end + def on_defs(node); end + def on_lvasgn(node); end + def on_masgn(node); end + def on_op_asgn(node); end + def on_or_asgn(node); end + def on_send(node); end + + private + + def add_lhs_to_local_variables_scopes(rhs, lhs); end + def add_scope(node, local_variables = _); end + def allow_self(node); end + def allowed_send_node?(node); end + def keyword?(method_name); end + def on_argument(node); end + def regular_method_call?(node); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::RedundantSelf::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def redundant_sort?(node = _); end + + private + + def accessor_start(node); end + def arg_node(node); end + def arg_value(node); end + def base(accessor, arg); end + def message(node, sorter, accessor); end + def suffix(sorter); end + def suggestion(sorter, accessor, arg); end +end + +RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_block(node); end + def redundant_sort_by(node = _); end + + private + + def sort_by_range(send, node); end +end + +RuboCop::Cop::Style::RedundantSortBy::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_regexp(node); end + + private + + def allow_inner_slashes?; end + def allowed_mixed_percent_r?(node); end + def allowed_mixed_slash?(node); end + def allowed_percent_r_literal?(node); end + def allowed_slash_literal?(node); end + def calculate_replacement(node); end + def check_percent_r_literal(node); end + def check_slash_literal(node); end + def contains_disallowed_slash?(node); end + def contains_slash?(node); end + def correct_delimiters(node, corrector); end + def correct_inner_slashes(node, corrector); end + def inner_slash_after_correction(node); end + def inner_slash_before_correction(node); end + def inner_slash_for(opening_delimiter); end + def inner_slash_indices(node); end + def node_body(node, include_begin_nodes: _); end + def preferred_delimiters; end + def slash_literal?(node); end +end + +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::RescueNode) + + def autocorrect(node); end + def on_resbody(node); end +end + +RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RescueNode) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_resbody(node); end + def rescue_standard_error?(node = _); end + def rescue_without_error_class?(node = _); end +end + +RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::RescueStandardError::MSG_IMPLICIT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def chained_send?(node = _); end + def define_method?(node = _); end + def on_return(node); end + def return_nil_node?(node = _); end + def return_node?(node = _); end + + private + + def correct_style?(node); end + def message(_node); end + def scoped_node?(node); end +end + +RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::NilMethods) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def check_node(node); end + def modifier_if_safe_navigation_candidate(node = _); end + def not_nil_check?(node = _); end + def on_and(node); end + def on_if(node); end + def use_var_only_in_unless_modifier?(node, variable); end + + private + + def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end + def allowed_if_condition?(node); end + def begin_range(node, method_call); end + def chain_size(method_chain, method); end + def comments(node); end + def end_range(node, method_call); end + def extract_common_parts(method_chain, checked_variable); end + def extract_parts(node); end + def extract_parts_from_and(node); end + def extract_parts_from_if(node); end + def find_matching_receiver_invocation(method_chain, checked_variable); end + def handle_comments(corrector, node, method_call); end + def method_call(node); end + def method_called?(send_node); end + def negated?(send_node); end + def unsafe_method?(send_node); end + def unsafe_method_used?(method_chain, method); end +end + +RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def sample_candidate?(node = _); end + + private + + def correction(shuffle_arg, method, method_args); end + def extract_source(args); end + def message(shuffle_arg, method, method_args, range); end + def offensive?(method, method_args); end + def range_size(range_node); end + def sample_arg(method, method_args); end + def sample_size(method_args); end + def sample_size_for_one_arg(arg); end + def sample_size_for_two_args(first, second); end + def source_range(shuffle_node, node); end +end + +RuboCop::Cop::Style::Sample::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_cvasgn(node); end + def on_ivasgn(node); end + def on_lvasgn(node); end + + private + + def apply_autocorrect(node, rhs, operator, new_rhs); end + def autocorrect_boolean_node(node, rhs); end + def autocorrect_send_node(node, rhs); end + def check(node, var_type); end + def check_boolean_node(node, rhs, var_name, var_type); end + def check_send_node(node, rhs, var_name, var_type); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SelfAssignment::OPS = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(range); end + def investigate(processed_source); end + def on_begin(node); end + + private + + def check_for_line_terminator_or_opener; end + def convention_on(line, column, autocorrect); end + def each_semicolon; end + def tokens_for_lines; end +end + +RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Cop + def on_csend(node); end + def on_send(node); end + def sending?(node = _); end +end + +RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def custom_fail_methods(node0); end + def investigate(processed_source); end + def kernel_call?(node = _, param1); end + def on_rescue(node); end + def on_send(node); end + + private + + def allow(method_name, node); end + def check_scope(method_name, node); end + def check_send(method_name, node); end + def command_or_kernel_call?(name, node); end + def each_command_or_kernel_call(method_name, node); end + def message(method_name); end +end + +RuboCop::Cop::Style::SignalException::FAIL_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SignalException::RAISE_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Cop + def on_block(node); end + + private + + def args_match?(method_name, args); end + def eligible_arguments?(node); end + def eligible_method?(node); end + def message(node); end + def method_name(method); end + def method_names; end + def methods; end + def target_args(method_name); end +end + +RuboCop::Cop::Style::SingleLineBlockParams::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end + + private + + def allow_empty?; end + def each_part(body); end + def move_comment(node, corrector); end +end + +RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Cop + extend(::RuboCop::Cop::TargetRubyVersion) + + def autocorrect(node); end + def on_send(node); end + def range_till_minus_one?(node = _); end +end + +RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def message(node); end + def on_gvar(node); end + + private + + def english_name_replacement(preferred_name, node); end + def format_english_message(global_var); end + def format_list(items); end + def format_message(english, regular, global); end + def preferred_names(global); end + def replacement(node, global_var); end +end + +RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set) + +RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + + def autocorrect(node); end + def on_send(node); end + + private + + def message(_node); end + def missing_parentheses?(node); end + def missing_parentheses_corrector(node); end + def parentheses?(node); end + def redundant_parentheses?(node); end + def stabby_lambda_with_args?(node); end + def unwanted_parentheses_corrector(node); end +end + +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_NO_REQUIRE = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_send(node); end + def stderr_puts?(node = _); end + + private + + def message(node); end + def stderr_gvar?(sym); end + def stderr_puts_range(send); end +end + +RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_pair(node); end + def receive_environments_method?(node = _); end + def string_hash_key?(node = _); end +end + +RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::StringHelp) + include(::RuboCop::Cop::StringLiteralsHelp) + + def autocorrect(node); end + def on_dstr(node); end + + private + + def accept_child_double_quotes?(nodes); end + def all_string_literals?(nodes); end + def check_multiline_quote_style(node, quote); end + def consistent_multiline?; end + def detect_quote_styles(node); end + def message(_node); end + def offense?(node); end + def unexpected_double_quotes?(quote); end + def unexpected_single_quotes?(quote); end +end + +RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::StringHelp) + include(::RuboCop::Cop::StringLiteralsHelp) + + def autocorrect(node); end + + private + + def message(_node); end + def offense?(node); end +end + +class RuboCop::Cop::Style::StringMethods < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::MethodPreference) + + def autocorrect(node); end + def on_csend(node); end + def on_send(node); end + + private + + def message(node); end +end + +RuboCop::Cop::Style::StringMethods::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def lstrip_rstrip(node = _); end + def on_send(node); end +end + +RuboCop::Cop::Style::Strip::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Cop + def on_class(node); end + def struct_constructor?(node = _); end +end + +RuboCop::Cop::Style::StructInheritance::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ArrayMinSize) + include(::RuboCop::Cop::ArraySyntax) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::PercentArray) + + def autocorrect(node); end + def on_array(node); end + + private + + def correct_bracketed(node); end + def symbol_without_quote?(string); end + def symbols_contain_spaces?(node); end + def to_symbol_literal(string); end + + def self.largest_brackets; end + def self.largest_brackets=(_); end +end + +RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SymbolArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SymbolLiteral < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_sym(node); end +end + +RuboCop::Cop::Style::SymbolLiteral::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::IgnoredMethods) + + def autocorrect(node); end + def destructuring_block_argument?(argument_node); end + def on_block(node); end + def proc_node?(node = _); end + def symbol_proc?(node = _); end + + private + + def autocorrect_with_args(corrector, node, args, method_name); end + def autocorrect_without_args(corrector, node); end + def begin_pos_for_replacement(node); end + def block_range_with_space(node); end + def register_offense(node, method_name, block_method_name); end + + def self.autocorrect_incompatible_with; end +end + +RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Style::TernaryCorrector + extend(::RuboCop::Cop::Style::ConditionalAssignmentHelper) + extend(::RuboCop::Cop::Style::ConditionalCorrectorHelper) + + def self.correct(node); end + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::SafeAssignment) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + + def autocorrect(node); end + def method_name(node = _); end + def on_if(node); end + def only_closing_parenthesis_is_last_line?(condition); end + + private + + def below_ternary_precedence?(child); end + def complex_condition?(condition); end + def correct_parenthesized(condition); end + def correct_unparenthesized(condition); end + def infinite_loop?; end + def message(node); end + def non_complex_expression?(condition); end + def non_complex_send?(node); end + def offense?(node); end + def parenthesized?(node); end + def redundant_parentheses_enabled?; end + def require_parentheses?; end + def require_parentheses_when_complex?; end + def unparenthesized_method_call?(child); end + def unsafe_autocorrect?(condition); end + def whitespace_after?(node); end +end + +RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::TrailingBody) + + def autocorrect(node); end + def on_class(node); end +end + +RuboCop::Cop::Style::TrailingBodyOnClass::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::TrailingBody) + + def autocorrect(node); end + def on_def(node); end + def on_defs(node); end +end + +RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrailingBodyOnModule < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + include(::RuboCop::Cop::TrailingBody) + + def autocorrect(node); end + def on_module(node); end +end + +RuboCop::Cop::Style::TrailingBodyOnModule::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::TrailingComma) + + def autocorrect(range); end + def on_csend(node); end + def on_send(node); end + + def self.autocorrect_incompatible_with; end +end + +class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::TrailingComma) + + def autocorrect(range); end + def on_array(node); end +end + +class RuboCop::Cop::Style::TrailingCommaInBlockArgs < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_block(node); end + + private + + def arg_count(node); end + def argument_tokens(node); end + def last_comma(node); end + def trailing_comma?(node); end + def useless_trailing_comma?(node); end +end + +RuboCop::Cop::Style::TrailingCommaInBlockArgs::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrailingCommaInHashLiteral < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::TrailingComma) + + def autocorrect(range); end + def on_hash(node); end +end + +class RuboCop::Cop::Style::TrailingMethodEndStatement < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Alignment) + + def autocorrect(node); end + def on_def(node); end + + private + + def body_and_end_on_same_line?(node); end + def break_line_before_end(node, corrector); end + def end_token(node); end + def remove_semicolon(node, corrector); end + def token_before_end(node); end + def trailing_end?(node); end +end + +RuboCop::Cop::Style::TrailingMethodEndStatement::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + include(::RuboCop::Cop::SurroundingSpace) + + def autocorrect(node); end + def on_masgn(node); end + + private + + def allow_named_underscore_variables; end + def children_offenses(variables); end + def find_first_offense(variables); end + def find_first_possible_offense(variables); end + def main_node_offense(node); end + def range_for_parentheses(offense, left); end + def reverse_index(collection, item); end + def splat_variable_before?(first_offense, variables); end + def unneeded_ranges(node); end + def unused_range(node_type, mlhs_node, right); end + def unused_variables_only?(offense, variables); end +end + +RuboCop::Cop::Style::TrailingUnderscoreVariable::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::TrailingUnderscoreVariable::UNDERSCORE = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Cop + def autocorrect(node); end + def looks_like_trivial_writer?(node = _); end + def on_def(node); end + def on_defs(node); end + + private + + def accessor(kind, method_name); end + def allow_dsl_writers?; end + def allow_predicates?; end + def allowed_method?(node); end + def allowed_methods; end + def allowed_reader?(node); end + def allowed_writer?(method_name); end + def autocorrect_class(node); end + def autocorrect_instance(node); end + def dsl_writer?(method_name); end + def exact_name_match?; end + def ignore_class_methods?; end + def in_module_or_instance_eval?(node); end + def looks_like_trivial_reader?(node); end + def names_match?(node); end + def on_method_def(node); end + def top_level_node?(node); end + def trivial_accessor_kind(node); end + def trivial_reader?(node); end + def trivial_writer?(node); end +end + +RuboCop::Cop::Style::TrivialAccessors::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::UnlessElse < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def on_if(node); end + def range_between_condition_and_else(node, condition); end + def range_between_else_and_end(node); end +end + +RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_send(node); end + def unpack_and_first_element?(node = _); end + + private + + def first_element_range(node, unpack_call); end +end + +RuboCop::Cop::Style::UnpackFirst::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::VariableInterpolation < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::Interpolation) + + def autocorrect(node); end + def on_node_with_interpolations(node); end + + private + + def message(node); end + def var_nodes(nodes); end +end + +RuboCop::Cop::Style::VariableInterpolation::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::WhenThen < ::RuboCop::Cop::Cop + def autocorrect(node); end + def on_when(node); end +end + +RuboCop::Cop::Style::WhenThen::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::WhileUntilDo < ::RuboCop::Cop::Cop + def autocorrect(node); end + def handle(node); end + def on_until(node); end + def on_while(node); end +end + +RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::LineLengthHelp) + include(::RuboCop::Cop::StatementModifier) + + def autocorrect(node); end + def on_until(node); end + def on_while(node); end + + private + + def check(node); end +end + +RuboCop::Cop::Style::WhileUntilModifier::MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ArrayMinSize) + include(::RuboCop::Cop::ArraySyntax) + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::PercentArray) + + def autocorrect(node); end + def on_array(node); end + + private + + def check_bracketed_array(node); end + def complex_content?(strings); end + def correct_bracketed(node); end + def word_regex; end + + def self.largest_brackets; end + def self.largest_brackets=(_); end +end + +RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Cop + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + def autocorrect(node); end + def file_constant_equal_program_name?(node = _); end + def on_send(node); end + + private + + def actual_code_range(node); end + def corrected_code(node); end + def enforce_yoda?; end + def equality_only?; end + def message(node); end + def non_equality_operator?(node); end + def noncommutative_operator?(node); end + def program_name?(name); end + def reverse_comparison(operator); end + def source_file_path_constant?(node); end + def valid_yoda?(node); end + def yoda_compatible_condition?(node); end +end + +RuboCop::Cop::Style::YodaCondition::EQUALITY_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::YodaCondition::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::YodaCondition::NONCOMMUTATIVE_OPERATORS = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::YodaCondition::PROGRAM_NAMES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Cop + def autocorrect(node); end + def non_polymorphic_collection?(node = _); end + def nonzero_length_predicate(node = _); end + def on_send(node); end + def other_receiver(node = _); end + def zero_length_predicate(node = _); end + def zero_length_receiver(node = _); end + + private + + def check_nonzero_length_predicate(node); end + def check_zero_length_predicate(node); end + def replacement(node); end +end + +RuboCop::Cop::Style::ZeroLengthPredicate::NONZERO_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::Style::ZeroLengthPredicate::ZERO_MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::SurroundingSpace + include(::RuboCop::Cop::RangeHelp) + + + private + + def empty_brackets?(left_bracket_token, right_bracket_token); end + def empty_offense(node, range, message, command); end + def empty_offenses(node, left, right, message); end + def extra_space?(token, side); end + def index_of_first_token(node); end + def index_of_last_token(node); end + def no_space_between?(left_bracket_token, right_bracket_token); end + def no_space_offenses(node, left_token, right_token, message, start_ok: _, end_ok: _); end + def offending_empty_no_space?(config, left_token, right_token); end + def offending_empty_space?(config, left_token, right_token); end + def reposition(src, pos, step); end + def side_space_range(range:, side:); end + def space_between?(left_bracket_token, right_bracket_token); end + def space_offense(node, token, side, message, command); end + def space_offenses(node, left_token, right_token, message, start_ok: _, end_ok: _); end + def token_table; end +end + +RuboCop::Cop::SurroundingSpace::NO_SPACE_COMMAND = T.let(T.unsafe(nil), String) + +RuboCop::Cop::SurroundingSpace::SINGLE_SPACE_REGEXP = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::SurroundingSpace::SPACE_COMMAND = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::TargetRubyVersion + def minimum_target_ruby_version(version); end + def required_minimum_ruby_version; end + def support_target_ruby_version?(version); end +end + +class RuboCop::Cop::Team + def initialize(cops, config = _, options = _); end + + def autocorrect(buffer, cops); end + def autocorrect?; end + def cops; end + def debug?; end + def errors; end + def external_dependency_checksum; end + def forces; end + def forces_for(cops); end + def inspect_file(processed_source); end + def updated_source_file; end + def updated_source_file?; end + def warnings; end + + private + + def autocorrect_all_cops(buffer, cops); end + def collate_corrections(corrector, cops); end + def handle_error(error, location, cop); end + def handle_warning(error, location); end + def investigate(cops, processed_source); end + def offenses(processed_source); end + def process_errors(file, errors); end + def roundup_relevant_cops(filename); end + def support_target_rails_version?(cop); end + def support_target_ruby_version?(cop); end + def validate_config; end + + def self.mobilize(cop_classes, config, options = _); end + def self.mobilize_cops(cop_classes, config, options = _); end + def self.new(cop_or_classes, config, options = _); end +end + +RuboCop::Cop::Team::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::Team::Investigation < ::Struct + def errors; end + def errors=(_); end + def offenses; end + def offenses=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RuboCop::Cop::TooManyLines + include(::RuboCop::Cop::ConfigurableMax) + include(::RuboCop::Cop::CodeLength) + + + private + + def code_length(node); end + def extract_body(node); end + def message(length, max_length); end +end + +RuboCop::Cop::TooManyLines::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::TrailingBody + def body_on_first_line?(node, body); end + def first_part_of(body); end + def trailing_body?(node); end +end + +module RuboCop::Cop::TrailingComma + include(::RuboCop::Cop::ConfigurableEnforcedStyle) + include(::RuboCop::Cop::RangeHelp) + + + private + + def allowed_multiline_argument?(node); end + def any_heredoc?(items); end + def autocorrect_range(item); end + def avoid_comma(kind, comma_begin_pos, extra_info); end + def brackets?(node); end + def check(node, items, kind, begin_pos, end_pos); end + def check_comma(node, kind, comma_pos); end + def check_literal(node, kind); end + def comma_offset(items, range); end + def elements(node); end + def extra_avoid_comma_info; end + def heredoc?(node); end + def heredoc_send?(node); end + def inside_comment?(range, comma_offset); end + def method_name_and_arguments_on_same_line?(node); end + def multiline?(node); end + def no_elements_on_same_line?(node); end + def on_same_line?(range1, range2); end + def put_comma(items, kind); end + def should_have_comma?(style, node); end + def style_parameter_name; end +end + +RuboCop::Cop::TrailingComma::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::UncommunicativeName + def check(node, args); end + + private + + def allow_nums; end + def allowed_names; end + def arg_range(arg, length); end + def case_offense(node, range); end + def ends_with_num?(name); end + def forbidden_names; end + def forbidden_offense(node, range, name); end + def issue_offenses(node, range, name); end + def length_offense(node, range); end + def long_enough?(name); end + def min_length; end + def name_type(node); end + def num_offense(node, range); end + def uppercase?(name); end +end + +RuboCop::Cop::UncommunicativeName::CASE_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::UncommunicativeName::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::UncommunicativeName::LENGTH_MSG = T.let(T.unsafe(nil), String) + +RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String) + +class RuboCop::Cop::UnusedArgCorrector + extend(::RuboCop::Cop::RangeHelp) + + def self.correct(processed_source, node); end + def self.correct_for_blockarg_type(node); end + def self.processed_source; end +end + +module RuboCop::Cop::Util + include(::RuboCop::PathUtil) + + + private + + def add_parentheses(node, corrector); end + def args_begin(node); end + def args_end(node); end + def begins_its_line?(range); end + def comment_line?(line_source); end + def comment_lines?(node); end + def compatible_external_encoding_for?(src); end + def double_quotes_required?(string); end + def escape_string(string); end + def first_part_of_call_chain(node); end + def interpret_string_escapes(string); end + def line_range(node); end + def needs_escaping?(string); end + def on_node(syms, sexp, excludes = _, &block); end + def parentheses?(node); end + def same_line?(node1, node2); end + def to_string_literal(string); end + def to_supported_styles(enforced_style); end + def tokens(node); end + def trim_string_interporation_escape_character(str); end + + def self.add_parentheses(node, corrector); end + def self.args_begin(node); end + def self.args_end(node); end + def self.begins_its_line?(range); end + def self.comment_line?(line_source); end + def self.comment_lines?(node); end + def self.double_quotes_required?(string); end + def self.escape_string(string); end + def self.first_part_of_call_chain(node); end + def self.interpret_string_escapes(string); end + def self.line_range(node); end + def self.needs_escaping?(string); end + def self.on_node(syms, sexp, excludes = _, &block); end + def self.parentheses?(node); end + def self.same_line?(node1, node2); end + def self.to_string_literal(string); end + def self.to_supported_styles(enforced_style); end + def self.tokens(node); end + def self.trim_string_interporation_escape_character(str); end +end + +RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp) + +module RuboCop::Cop::Utils +end + +class RuboCop::Cop::Utils::FormatString + def initialize(string); end + + def format_sequences; end + def max_digit_dollar_num; end + def named_interpolation?; end + def valid?; end + + private + + def mixed_formats?; end + def parse; end +end + +RuboCop::Cop::Utils::FormatString::DIGIT_DOLLAR = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::FLAG = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::Utils::FormatString::FormatSequence + def initialize(match); end + + def annotated?; end + def arity; end + def begin_pos; end + def end_pos; end + def flags; end + def max_digit_dollar_num; end + def name; end + def percent?; end + def precision; end + def style; end + def template?; end + def type; end + def width; end +end + +RuboCop::Cop::Utils::FormatString::NAME = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::NUMBER = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::NUMBER_ARG = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::PRECISION = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::SEQUENCE = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::TEMPLATE_NAME = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp) + +RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp) + +class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force + def investigate(processed_source); end + def process_node(node); end + def variable_table; end + + private + + def after_declaring_variable(arg); end + def after_entering_scope(arg); end + def after_leaving_scope(arg); end + def before_declaring_variable(arg); end + def before_entering_scope(arg); end + def before_leaving_scope(arg); end + def descendant_reference(node); end + def each_descendant_reference(loop_node); end + def find_variables_in_loop(loop_node); end + def inspect_variables_in_scope(scope_node); end + def mark_assignments_as_referenced_in_loop(node); end + def node_handler_method_name(node); end + def process_children(origin_node); end + def process_loop(node); end + def process_regexp_named_captures(node); end + def process_rescue(node); end + def process_scope(node); end + def process_send(node); end + def process_variable_assignment(node); end + def process_variable_declaration(node); end + def process_variable_multiple_assignment(node); end + def process_variable_operator_assignment(node); end + def process_variable_referencing(node); end + def process_zero_arity_super(node); end + def regexp_captured_names(node); end + def scanned_node?(node); end + def scanned_nodes; end + def skip_children!; end + def twisted_nodes(node); end +end + +RuboCop::Cop::VariableForce::ARGUMENT_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::VariableForce::Assignment + include(::RuboCop::Cop::VariableForce::Branchable) + + def initialize(node, variable); end + + def meta_assignment_node; end + def multiple_assignment?; end + def name; end + def node; end + def operator; end + def operator_assignment?; end + def reference!(node); end + def referenced; end + def referenced?; end + def references; end + def regexp_named_capture?; end + def scope; end + def used?; end + def variable; end + + private + + def multiple_assignment_node; end + def operator_assignment_node; end +end + +RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct + def assignment?; end + def node; end + def node=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +module RuboCop::Cop::VariableForce::Branch + def self.of(target_node, scope: _); end +end + +class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::LogicalOperator) + + def left_body?; end + def right_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::Base < ::Struct + def ==(other); end + def always_run?; end + def branched?; end + def child_node; end + def child_node=(_); end + def control_node; end + def each_ancestor(include_self: _, &block); end + def eql?(other); end + def exclusive_with?(other); end + def hash; end + def may_jump_to_other_branch?; end + def may_run_incompletely?; end + def parent; end + def scope; end + def scope=(_); end + + private + + def scan_ancestors; end + + def self.[](*_); end + def self.classes; end + def self.define_predicate(name, child_index: _); end + def self.inherited(subclass); end + def self.inspect; end + def self.members; end + def self.new(*_); end + def self.type; end +end + +RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash) + +class RuboCop::Cop::VariableForce::Branch::Case < ::RuboCop::Cop::VariableForce::Branch::Base + def always_run?; end + def else_body?; end + def target?; end + def when_clause?; end +end + +class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::ExceptionHandler) + + def always_run?; end + def ensure_body?; end + def main_body?; end +end + +module RuboCop::Cop::VariableForce::Branch::ExceptionHandler + def may_jump_to_other_branch?; end + def may_run_incompletely?; end +end + +class RuboCop::Cop::VariableForce::Branch::For < ::RuboCop::Cop::VariableForce::Branch::Base + def always_run?; end + def collection?; end + def element?; end + def loop_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::SimpleConditional) + + def conditional_clause?; end + def falsey_body?; end + def truthy_body?; end +end + +module RuboCop::Cop::VariableForce::Branch::LogicalOperator + def always_run?; end +end + +class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::LogicalOperator) + + def left_body?; end + def right_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::ExceptionHandler) + + def always_run?; end + def else_body?; end + def main_body?; end + def rescue_clause?; end +end + +module RuboCop::Cop::VariableForce::Branch::SimpleConditional + def always_run?; end + def conditional_clause?; end +end + +class RuboCop::Cop::VariableForce::Branch::Until < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::SimpleConditional) + + def conditional_clause?; end + def loop_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::UntilPost < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::SimpleConditional) + + def conditional_clause?; end + def loop_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::While < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::SimpleConditional) + + def conditional_clause?; end + def loop_body?; end +end + +class RuboCop::Cop::VariableForce::Branch::WhilePost < ::RuboCop::Cop::VariableForce::Branch::Base + include(::RuboCop::Cop::VariableForce::Branch::SimpleConditional) + + def conditional_clause?; end + def loop_body?; end +end + +module RuboCop::Cop::VariableForce::Branchable + def branch; end + def run_exclusively_with?(other); end +end + +RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Symbol) + +RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Cop::VariableForce::Reference + include(::RuboCop::Cop::VariableForce::Branchable) + + def initialize(node, scope); end + + def explicit?; end + def node; end + def scope; end +end + +RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Cop::VariableForce::Scope + def initialize(node); end + + def ==(other); end + def body_node; end + def each_node(&block); end + def include?(target_node); end + def naked_top_level; end + def naked_top_level?; end + def name; end + def node; end + def variables; end + + private + + def ancestor_node?(target_node); end + def belong_to_inner_scope?(target_node); end + def belong_to_outer_scope?(target_node); end + def scan_node(node, &block); end +end + +RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(nil), Hash) + +RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Cop::VariableForce::Variable + def initialize(name, declaration_node, scope); end + + def argument?; end + def assign(node); end + def assignments; end + def block_argument?; end + def capture_with_block!; end + def captured_by_block; end + def captured_by_block?; end + def declaration_node; end + def explicit_block_local_variable?; end + def in_modifier_if?(assignment); end + def keyword_argument?; end + def method_argument?; end + def name; end + def reference!(node); end + def referenced?; end + def references; end + def scope; end + def should_be_unused?; end + def used?; end +end + +RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +class RuboCop::Cop::VariableForce::VariableReference < ::Struct + def assignment?; end + def name; end + def name=(_); end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +class RuboCop::Cop::VariableForce::VariableTable + def initialize(hook_receiver = _); end + + def accessible_variables; end + def assign_to_variable(name, node); end + def current_scope; end + def current_scope_level; end + def declare_variable(name, node); end + def find_variable(name); end + def invoke_hook(hook_name, *args); end + def pop_scope; end + def push_scope(scope_node); end + def reference_variable(name, node); end + def scope_stack; end + def variable_exist?(name); end + + private + + def mark_variable_as_captured_by_block_if_so(variable); end +end + +RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol) + +class RuboCop::Error < ::StandardError +end + +class RuboCop::ErrorWithAnalyzedFileLocation < ::RuboCop::Error + def initialize(cause:, node:, cop:); end + + def cause; end + def column; end + def cop; end + def line; end + def message; end +end + +module RuboCop::Ext +end + +module RuboCop::Ext::ProcessedSource + def comment_config; end + def disabled_line_ranges; end +end + +module RuboCop::FileFinder + def find_file_upwards(filename, start_dir); end + def find_files_upwards(filename, start_dir); end + + private + + def traverse_files_upwards(filename, start_dir); end + + def self.root_level=(level); end + def self.root_level?(path); end +end + +module RuboCop::Formatter +end + +class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::ProgressFormatter + def finished(inspected_files); end +end + +class RuboCop::Formatter::BaseFormatter + def initialize(output, options = _); end + + def file_finished(file, offenses); end + def file_started(file, options); end + def finished(inspected_files); end + def options; end + def output; end + def started(target_files); end +end + +class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleTextFormatter + def report_file(file, offenses); end + + private + + def report_highlighted_area(highlighted_area); end + def report_line(location); end + def report_offense(file, offense); end + def valid_line?(offense); end +end + +RuboCop::Formatter::ClangStyleFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +module RuboCop::Formatter::Colorizable + def black(string); end + def blue(string); end + def colorize(string, *args); end + def cyan(string); end + def green(string); end + def magenta(string); end + def rainbow; end + def red(string); end + def white(string); end + def yellow(string); end +end + +class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter + def initialize(output, options = _); end + + def file_finished(file, offenses); end + def file_started(_file, _file_info); end + def finished(_inspected_files); end + + private + + def command; end + def cop_config_params(default_cfg, cfg); end + def default_config(cop_name); end + def excludes(offending_files, cop_name, parent); end + def output_cop(cop_name, offense_count); end + def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end + def output_cop_config(output_buffer, cfg, cop_name); end + def output_cop_param_comments(output_buffer, params, default_cfg); end + def output_exclude_list(output_buffer, offending_files, cop_name); end + def output_exclude_path(output_buffer, exclude_path, parent); end + def output_offending_files(output_buffer, cfg, cop_name); end + def output_offenses; end + def set_max(cfg, cop_name); end + def timestamp; end + + def self.config_to_allow_offenses; end + def self.config_to_allow_offenses=(_); end + def self.detected_styles; end + def self.detected_styles=(_); end +end + +RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String) + +class RuboCop::Formatter::EmacsStyleFormatter < ::RuboCop::Formatter::BaseFormatter + def file_finished(file, offenses); end + + private + + def message(offense); end +end + +class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatter + def file_finished(file, offenses); end +end + +class RuboCop::Formatter::FormatterSet < ::Array + def initialize(options = _); end + + def add_formatter(formatter_type, output_path = _); end + def close_output_files; end + def file_finished(file, offenses); end + def file_started(file, options); end + def finished(*args); end + def started(*args); end + + private + + def builtin_formatter_class(specified_key); end + def custom_formatter_class(specified_class_name); end + def formatter_class(formatter_type); end +end + +RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS = T.let(T.unsafe(nil), Hash) + +RuboCop::Formatter::FormatterSet::FORMATTER_APIS = T.let(T.unsafe(nil), Array) + +class RuboCop::Formatter::FuubarStyleFormatter < ::RuboCop::Formatter::ClangStyleFormatter + def initialize(*output); end + + def count_stats(offenses); end + def file_finished(file, offenses); end + def progressbar_color; end + def started(target_files); end + def with_color; end +end + +RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String) + +class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter + def initialize(output, options = _); end + + def file_finished(file, offenses); end + def files; end + def finished(inspected_files); end + def render_html; end + def started(target_files); end + def summary; end +end + +class RuboCop::Formatter::HTMLFormatter::Color < ::Struct + def alpha; end + def alpha=(_); end + def blue; end + def blue=(_); end + def fade_out(amount); end + def green; end + def green=(_); end + def red; end + def red=(_); end + def to_s; end + + def self.[](*_); end + def self.inspect; end + def self.members; end + def self.new(*_); end +end + +RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +class RuboCop::Formatter::HTMLFormatter::ERBContext + include(::RuboCop::PathUtil) + include(::RuboCop::Formatter::TextUtil) + + def initialize(files, summary); end + + def base64_encoded_logo_image; end + def binding; end + def decorated_message(offense); end + def escape(string); end + def files; end + def highlighted_source_line(offense); end + def hightlight_source_tag(offense); end + def possible_ellipses(location); end + def source_after_highlight(offense); end + def source_before_highlight(offense); end + def summary; end +end + +RuboCop::Formatter::HTMLFormatter::ERBContext::LOGO_IMAGE_PATH = T.let(T.unsafe(nil), String) + +RuboCop::Formatter::HTMLFormatter::ERBContext::SEVERITY_COLORS = T.let(T.unsafe(nil), Hash) + +RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String) + +class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter + include(::RuboCop::PathUtil) + + def initialize(output, options = _); end + + def file_finished(file, offenses); end + def finished(inspected_files); end + def hash_for_file(file, offenses); end + def hash_for_location(offense); end + def hash_for_offense(offense); end + def metadata_hash; end + def output_hash; end + def started(target_files); end +end + +class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter + def initialize(output, options = _); end + + def classname_attribute_value(file); end + def file_finished(file, offenses); end + def finished(_inspected_files); end + def offenses_for_cop(all_offenses, cop); end + def relevant_for_output?(options, target_offenses); end + + private + + def add_failure_to(testcase, offenses, cop_name); end +end + +class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter + def file_finished(_file, offenses); end + def finished(_inspected_files); end + def offense_counts; end + def ordered_offense_counts(offense_counts); end + def report_summary(offense_counts); end + def started(target_files); end + def total_offense_count(offense_counts); end +end + +class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include(::RuboCop::Formatter::TextUtil) + + def initialize(output, options = _); end + + def cols; end + def file_finished(file, offenses); end + def file_started(_file, _options); end + def next_step(offenses); end + def pacdots(number); end + def progress_line; end + def progress_line=(_); end + def started(target_files); end + def step(character); end + def update_progress_line; end +end + +RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) + +RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) + +RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter) + +RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter) + +class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include(::RuboCop::Formatter::TextUtil) + + def initialize(output, options = _); end + + def file_finished(file, offenses); end + def finished(inspected_files); end + def report_file_as_mark(offenses); end + def started(target_files); end +end + +RuboCop::Formatter::ProgressFormatter::DOT = T.let(T.unsafe(nil), String) + +class RuboCop::Formatter::QuietFormatter < ::RuboCop::Formatter::SimpleTextFormatter + def report_summary(file_count, offense_count, correction_count); end +end + +class RuboCop::Formatter::SimpleTextFormatter < ::RuboCop::Formatter::BaseFormatter + include(::RuboCop::Formatter::Colorizable) + include(::RuboCop::PathUtil) + + def file_finished(file, offenses); end + def finished(inspected_files); end + def report_file(file, offenses); end + def report_summary(file_count, offense_count, correction_count); end + def started(_target_files); end + + private + + def annotate_message(msg); end + def colored_severity_code(offense); end + def count_stats(offenses); end + def message(offense); end +end + +RuboCop::Formatter::SimpleTextFormatter::COLOR_FOR_SEVERITY = T.let(T.unsafe(nil), Hash) + +class RuboCop::Formatter::SimpleTextFormatter::Report + include(::RuboCop::Formatter::Colorizable) + include(::RuboCop::Formatter::TextUtil) + + def initialize(file_count, offense_count, correction_count, rainbow); end + + def summary; end + + private + + def corrections; end + def files; end + def offenses; end + def rainbow; end +end + +class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatter + def file_finished(file, offenses); end + def started(target_files); end + + private + + def annotate_message(msg); end + def message(offense); end + def report_highlighted_area(highlighted_area); end + def report_line(location); end + def report_offense(file, offense); end +end + +module RuboCop::Formatter::TextUtil + + private + + def pluralize(number, thing, options = _); end + + def self.pluralize(number, thing, options = _); end +end + +class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter + def file_finished(file, offenses); end + def finished(_inspected_files); end + def offense_counts; end + def ordered_offense_counts(offense_counts); end + def report_summary(offense_counts); end + def started(target_files); end + def total_offense_count(offense_counts); end +end + +class RuboCop::IncorrectCopNameError < ::StandardError +end + +class RuboCop::MagicComment + def initialize(comment); end + + def any?; end + def encoding_specified?; end + def frozen_string_literal; end + def frozen_string_literal?; end + def frozen_string_literal_specified?; end + def valid_literal_value?; end + + private + + def extract(pattern); end + def specified?(value); end + + def self.parse(comment); end +end + +class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment + + private + + def match(keyword); end + def tokens; end +end + +class RuboCop::MagicComment::EmacsComment < ::RuboCop::MagicComment::EditorComment + def encoding; end + + private + + def extract_frozen_string_literal; end +end + +RuboCop::MagicComment::EmacsComment::FORMAT = T.let(T.unsafe(nil), Regexp) + +RuboCop::MagicComment::EmacsComment::OPERATOR = T.let(T.unsafe(nil), String) + +RuboCop::MagicComment::EmacsComment::SEPARATOR = T.let(T.unsafe(nil), String) + +class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment + def encoding; end + + private + + def extract_frozen_string_literal; end +end + +RuboCop::MagicComment::TOKEN = T.let(T.unsafe(nil), Regexp) + +class RuboCop::MagicComment::VimComment < ::RuboCop::MagicComment::EditorComment + def encoding; end + def frozen_string_literal; end +end + +RuboCop::MagicComment::VimComment::FORMAT = T.let(T.unsafe(nil), Regexp) + +RuboCop::MagicComment::VimComment::OPERATOR = T.let(T.unsafe(nil), String) + +RuboCop::MagicComment::VimComment::SEPARATOR = T.let(T.unsafe(nil), String) + +module RuboCop::NameSimilarity + + private + + def find_similar_name(target_name, names); end + def find_similar_names(target_name, names); end + + def self.find_similar_name(target_name, names); end + def self.find_similar_names(target_name, names); end +end + +RuboCop::NodePattern = RuboCop::AST::NodePattern + +class RuboCop::OptionArgumentError < ::StandardError +end + +class RuboCop::Options + def initialize; end + + def parse(command_line_args); end + + private + + def add_aliases(opts); end + def add_auto_gen_options(opts); end + def add_boolean_flags(opts); end + def add_configuration_options(opts); end + def add_cop_selection_csv_option(option, opts); end + def add_flags_with_optional_args(opts); end + def add_formatting_options(opts); end + def add_list_options(opts); end + def add_only_options(opts); end + def add_severity_option(opts); end + def args_from_env; end + def args_from_file; end + def define_options; end + def long_opt_symbol(args); end + def option(opts, *args); end +end + +RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer) + +RuboCop::Options::EXITING_OPTIONS = T.let(T.unsafe(nil), Array) + +RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String) + +module RuboCop::OptionsHelp +end + +RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array) + +RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String) + +RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash) + +class RuboCop::OptionsValidator + def initialize(options); end + + def boolean_or_empty_cache?; end + def display_only_fail_level_offenses_with_autocorrect?; end + def except_syntax?; end + def incompatible_options; end + def only_includes_redundant_disable?; end + def validate_auto_correct; end + def validate_auto_gen_config; end + def validate_compatibility; end + def validate_cop_options; end + def validate_display_only_failed; end + def validate_exclude_limit_option; end + def validate_parallel; end + def validate_parallel_with_combo_option; end + + def self.validate_cop_list(names); end +end + +module RuboCop::PathUtil + + private + + def absolute?(path); end + def hidden_dir?(path); end + def hidden_file_in_not_hidden_dir?(pattern, path); end + def match_path?(pattern, path); end + def relative_path(path, base_dir = _); end + def smart_path(path); end + + def self.absolute?(path); end + def self.chdir(dir, &block); end + def self.hidden_dir?(path); end + def self.hidden_file_in_not_hidden_dir?(pattern, path); end + def self.match_path?(pattern, path); end + def self.pwd; end + def self.relative_path(path, base_dir = _); end + def self.reset_pwd; end + def self.smart_path(path); end +end + +module RuboCop::Platform + def self.windows?; end +end + +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +class RuboCop::RemoteConfig + def initialize(url, base_dir); end + + def file; end + def inherit_from_remote(file, path); end + def uri; end + + private + + def cache_name_from_uri; end + def cache_path; end + def cache_path_exists?; end + def cache_path_expired?; end + def generate_request(uri); end + def handle_response(response, limit, &block); end + def request(uri = _, limit = _, &block); end +end + +RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer) + +class RuboCop::ResultCache + def initialize(file, team, options, config_store, cache_root = _); end + + def load; end + def save(offenses); end + def valid?; end + + private + + def any_symlink?(path); end + def context_checksum(team, options); end + def file_checksum(file, config_store); end + def relevant_options_digest(options); end + def rubocop_checksum; end + def symlink_protection_triggered?(path); end + def team_checksum(team); end + + def self.allow_symlinks_in_cache_location?(config_store); end + def self.cache_root(config_store); end + def self.cleanup(config_store, verbose, cache_root = _); end + def self.inhibit_cleanup; end + def self.inhibit_cleanup=(_); end + def self.source_checksum; end + def self.source_checksum=(_); end +end + +RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array) + +class RuboCop::Runner + def initialize(options, config_store); end + + def aborting=(_); end + def aborting?; end + def errors; end + def run(paths); end + def warnings; end + + private + + def add_redundant_disables(file, offenses, source); end + def autocorrect_redundant_disables(file, source, cop, offenses); end + def cached_result(file, team); end + def cached_run?; end + def check_for_infinite_loop(processed_source, offenses); end + def check_for_redundant_disables?(source); end + def considered_failure?(offense); end + def do_inspection_loop(file, processed_source); end + def each_inspected_file(files); end + def file_finished(file, offenses); end + def file_offense_cache(file); end + def file_offenses(file); end + def file_started(file); end + def filter_cop_classes(cop_classes, config); end + def filtered_run?; end + def find_target_files(paths); end + def formatter_set; end + def get_processed_source(file); end + def inspect_file(processed_source); end + def inspect_files(files); end + def iterate_until_no_changes(source, offenses); end + def list_files(paths); end + def minimum_severity_to_fail; end + def mobilized_cop_classes(config); end + def process_file(file); end + def redundant_cop_disable_directive(file); end + def save_in_cache(cache, offenses); end + def standby_team(config); end + def style_guide_cops_only?(config); end + def warm_cache(target_files); end +end + +class RuboCop::Runner::InfiniteCorrectionLoop < ::RuntimeError + def initialize(path, offenses); end + + def offenses; end +end + +RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer) + +class RuboCop::StringInterpreter + def self.interpret(string); end +end + +RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash) + +RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp) + +class RuboCop::TargetFinder + def initialize(config_store, options = _); end + + def all_cops_include; end + def configured_include?(file); end + def debug?; end + def excluded_dirs(base_dir); end + def fail_fast?; end + def find(args, mode); end + def find_files(base_dir, flags); end + def force_exclusion?; end + def included_file?(file); end + def process_explicit_path(path, mode); end + def ruby_executable?(file); end + def ruby_extension?(file); end + def ruby_extensions; end + def ruby_file?(file); end + def ruby_filename?(file); end + def ruby_filenames; end + def ruby_interpreters(file); end + def stdin?; end + def target_files_in_dir(base_dir = _); end + def to_inspect?(file, hidden_files, base_dir_config); end + def toplevel_dirs(base_dir, flags); end + + private + + def order; end +end + +class RuboCop::TargetRuby + def initialize(config); end + + def rubocop_version_with_support; end + def source; end + def supported?; end + def version; end + + def self.supported_versions; end +end + +class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source + def name; end + + private + + def bundler_lock_file_path; end + def find_version; end +end + +RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float) + +class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source + def name; end + + private + + def find_version; end +end + +class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source + def name; end + + private + + def find_version; end +end + +class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source + def name; end + + private + + def find_version; end + def ruby_version_file; end +end + +RuboCop::TargetRuby::RubyVersionFile::FILENAME = T.let(T.unsafe(nil), String) + +class RuboCop::TargetRuby::Source + def initialize(config); end + + def name; end + def to_s; end + def version; end +end + +RuboCop::Token = RuboCop::AST::Token + +class RuboCop::ValidationError < ::RuboCop::Error +end + +module RuboCop::Version + def self.version(debug = _); end +end + +RuboCop::Version::MSG = T.let(T.unsafe(nil), String) + +RuboCop::Version::STRING = T.let(T.unsafe(nil), String) + +class RuboCop::Warning < ::StandardError +end + +module RuboCop::YAMLDuplicationChecker + def self.check(yaml_string, filename, &on_duplicated); end +end + +class String + include(::Comparable) + include(::JSON::Ext::Generator::GeneratorMethods::String) + extend(::JSON::Ext::Generator::GeneratorMethods::String::Extend) + + def blank?; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi new file mode 100644 index 0000000000..baaaa5b2fc --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi @@ -0,0 +1,421 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class ProgressBar + def self.create(*args); end +end + +class ProgressBar::Base + extend(::Forwardable) + + def initialize(options = _); end + + def clear(*args, &block); end + def decrement; end + def finish; end + def finished?; end + def format(other); end + def format=(other); end + def increment; end + def inspect; end + def log(*args, &block); end + def pause; end + def paused?; end + def progress(*args, &block); end + def progress=(new_progress); end + def progress_mark=(mark); end + def refresh(*args, &block); end + def remainder_mark=(mark); end + def reset; end + def resume; end + def start(options = _); end + def started?; end + def stop; end + def stopped?; end + def title; end + def title=(title); end + def to_h; end + def to_s(new_format = _); end + def total(*args, &block); end + def total=(new_total); end + + protected + + def autofinish; end + def autofinish=(_); end + def autostart; end + def autostart=(_); end + def bar; end + def bar=(_); end + def finished; end + def finished=(_); end + def output; end + def output=(_); end + def percentage; end + def percentage=(_); end + def progressable; end + def progressable=(_); end + def rate; end + def rate=(_); end + def time; end + def time=(_); end + def timer; end + def timer=(_); end + def title_comp; end + def title_comp=(_); end + def update_progress(*args); end +end + +module ProgressBar::Calculators +end + +class ProgressBar::Calculators::Length + def initialize(options = _); end + + def calculate_length; end + def current_length; end + def current_length=(_); end + def length; end + def length_changed?; end + def length_override; end + def length_override=(other); end + def output; end + def output=(_); end + def reset_length; end + + private + + def dynamic_width; end + def dynamic_width_stty; end + def dynamic_width_tput; end + def dynamic_width_via_io_object; end + def dynamic_width_via_output_stream_object; end + def dynamic_width_via_system_calls; end + def terminal_width; end + def unix?; end +end + +class ProgressBar::Calculators::RunningAverage + def self.calculate(current_average, new_value_to_average, smoothing_factor); end +end + +module ProgressBar::Components +end + +class ProgressBar::Components::Bar + def initialize(options = _); end + + def length; end + def length=(_); end + def progress; end + def progress=(_); end + def progress_mark; end + def progress_mark=(_); end + def remainder_mark; end + def remainder_mark=(_); end + def to_s(options = _); end + def upa_steps; end + def upa_steps=(_); end + + private + + def bar(length); end + def bar_with_percentage(length); end + def complete_bar(length); end + def complete_bar_with_percentage(length); end + def completed_length; end + def incomplete_space(length); end + def incomplete_string; end + def integrated_percentage_complete_string; end + def standard_complete_string; end + def unknown_progress_frame; end + def unknown_string; end +end + +ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array) + +class ProgressBar::Components::Percentage + def initialize(options = _); end + + def progress; end + def progress=(_); end + + private + + def justified_percentage; end + def justified_percentage_with_precision; end + def percentage; end + def percentage_with_precision; end +end + +class ProgressBar::Components::Rate + def initialize(options = _); end + + def progress; end + def progress=(_); end + def rate_scale; end + def rate_scale=(_); end + def started_at; end + def started_at=(_); end + def stopped_at; end + def stopped_at=(_); end + def timer; end + def timer=(_); end + + private + + def base_rate; end + def elapsed_seconds; end + def rate_of_change(format_string = _); end + def rate_of_change_with_precision; end + def scaled_rate; end +end + +class ProgressBar::Components::Time + def initialize(options = _); end + + def elapsed_with_label; end + def estimated_with_label; end + + protected + + def estimated_with_friendly_oob; end + def estimated_with_no_oob; end + def estimated_with_unknown_oob; end + def out_of_bounds_time_format; end + def out_of_bounds_time_format=(format); end + def progress; end + def progress=(_); end + def timer; end + def timer=(_); end + + private + + def elapsed; end + def estimated; end + def estimated_seconds_remaining; end + def estimated_with_elapsed_fallback; end + def out_of_bounds_time; end +end + +ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer) + +ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array) + +ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String) + +ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String) + +class ProgressBar::Components::Title + def initialize(options = _); end + + def title; end + def title=(_); end +end + +ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String) + +module ProgressBar::Format +end + +class ProgressBar::Format::Formatter + def self.process(format_string, max_length, bar); end +end + +class ProgressBar::Format::Molecule + def initialize(letter); end + + def bar_molecule?; end + def full_key; end + def key; end + def key=(_); end + def lookup_value(environment, length = _); end + def method_name; end + def method_name=(_); end + def non_bar_molecule?; end +end + +ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array) + +ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash) + +class ProgressBar::Format::String < ::String + def bar_molecule_placeholder_length; end + def bar_molecules; end + def displayable_length; end + def molecules; end + def non_bar_molecules; end +end + +ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp) + +ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp) + +class ProgressBar::InvalidProgressError < ::RuntimeError +end + +class ProgressBar::Output + def initialize(options = _); end + + def clear_string; end + def length; end + def log(string); end + def refresh(options = _); end + def stream; end + def stream=(_); end + def with_refresh; end + + protected + + def bar; end + def bar=(_); end + def length_calculator; end + def length_calculator=(_); end + def throttle; end + def throttle=(_); end + + private + + def print_and_flush; end + + def self.detect(options = _); end +end + +ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO) + +module ProgressBar::Outputs +end + +class ProgressBar::Outputs::NonTty < ::ProgressBar::Output + def bar_update_string; end + def clear; end + def default_format; end + def eol; end + def last_update_length; end + def refresh_with_format_change(*_); end + def resolve_format(*_); end + + protected + + def last_update_length=(_); end +end + +ProgressBar::Outputs::NonTty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String) + +class ProgressBar::Outputs::Tty < ::ProgressBar::Output + def bar_update_string; end + def clear; end + def default_format; end + def eol; end + def refresh_with_format_change; end + def resolve_format(other_format); end +end + +ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String) + +class ProgressBar::Progress + def initialize(options = _); end + + def absolute; end + def decrement; end + def finish; end + def finished?; end + def increment; end + def none?; end + def percentage_completed; end + def percentage_completed_with_precision; end + def progress; end + def progress=(new_progress); end + def reset; end + def running_average; end + def running_average=(_); end + def smoothing; end + def smoothing=(_); end + def start(options = _); end + def starting_position; end + def starting_position=(_); end + def total; end + def total=(new_total); end + def total_with_unknown_indicator; end + def unknown?; end +end + +ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer) + +ProgressBar::Progress::DEFAULT_SMOOTHING = T.let(T.unsafe(nil), Float) + +ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer) + +module ProgressBar::Refinements +end + +module ProgressBar::Refinements::Enumerator +end + +class ProgressBar::Throttle + def initialize(options = _); end + + def choke(options = _); end + def rate; end + def rate=(_); end + def started_at; end + def started_at=(_); end + def stopped_at; end + def stopped_at=(_); end + def timer; end + def timer=(_); end +end + +class ProgressBar::Time + def initialize(time = _); end + + def now; end + def unmocked_time_method; end + + protected + + def time; end + def time=(_); end +end + +ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array) + +class ProgressBar::Timer + def initialize(options = _); end + + def divide_seconds(seconds); end + def elapsed_seconds; end + def elapsed_whole_seconds; end + def pause; end + def reset; end + def reset?; end + def restart; end + def resume; end + def start; end + def started?; end + def started_at; end + def started_at=(_); end + def stop; end + def stopped?; end + def stopped_at; end + def stopped_at=(_); end + + protected + + def time; end + def time=(_); end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.10.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.10.2.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.10.2.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.16.1.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.16.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.16.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/term-ansicolor@1.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/term-ansicolor@1.7.1.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/term-ansicolor@1.7.1.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi new file mode 100644 index 0000000000..9b80e20809 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi @@ -0,0 +1,825 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class Thor + include(::Thor::Base) + include(::Thor::Invocation) + include(::Thor::Shell) + extend(::Thor::Base::ClassMethods) + extend(::Thor::Invocation::ClassMethods) + + def help(command = _, subcommand = _); end + + def self.check_unknown_options!(options = _); end + def self.check_unknown_options?(config); end + def self.command_help(shell, command_name); end + def self.default_command(meth = _); end + def self.default_task(meth = _); end + def self.deprecation_warning(message); end + def self.desc(usage, description, options = _); end + def self.disable_required_check!(*command_names); end + def self.disable_required_check?(command); end + def self.help(shell, subcommand = _); end + def self.long_desc(long_description, options = _); end + def self.map(mappings = _, **kw); end + def self.method_option(name, options = _); end + def self.method_options(options = _); end + def self.option(name, options = _); end + def self.options(options = _); end + def self.package_name(name, _ = _); end + def self.printable_commands(all = _, subcommand = _); end + def self.printable_tasks(all = _, subcommand = _); end + def self.register(klass, subcommand_name, usage, description, options = _); end + def self.stop_on_unknown_option!(*command_names); end + def self.stop_on_unknown_option?(command); end + def self.subcommand(subcommand, subcommand_class); end + def self.subcommand_classes; end + def self.subcommands; end + def self.subtask(subcommand, subcommand_class); end + def self.subtasks; end + def self.task_help(shell, command_name); end +end + +module Thor::Actions + mixes_in_class_methods(::Thor::Actions::ClassMethods) + + def initialize(args = _, options = _, config = _); end + + def action(instance); end + def add_file(destination, *args, &block); end + def add_link(destination, *args); end + def append_file(path, *args, &block); end + def append_to_file(path, *args, &block); end + def apply(path, config = _); end + def behavior; end + def behavior=(_); end + def chmod(path, mode, config = _); end + def comment_lines(path, flag, *args); end + def copy_file(source, *args, &block); end + def create_file(destination, *args, &block); end + def create_link(destination, *args); end + def destination_root; end + def destination_root=(root); end + def directory(source, *args, &block); end + def empty_directory(destination, config = _); end + def find_in_source_paths(file); end + def get(source, *args, &block); end + def gsub_file(path, flag, *args, &block); end + def in_root; end + def inject_into_class(path, klass, *args, &block); end + def inject_into_file(destination, *args, &block); end + def inject_into_module(path, module_name, *args, &block); end + def insert_into_file(destination, *args, &block); end + def inside(dir = _, config = _, &block); end + def link_file(source, *args); end + def prepend_file(path, *args, &block); end + def prepend_to_file(path, *args, &block); end + def relative_to_original_destination_root(path, remove_dot = _); end + def remove_dir(path, config = _); end + def remove_file(path, config = _); end + def run(command, config = _); end + def run_ruby_script(command, config = _); end + def source_paths; end + def template(source, *args, &block); end + def thor(command, *args); end + def uncomment_lines(path, flag, *args); end + + protected + + def _cleanup_options_and_set(options, key); end + def _shared_configuration; end + + private + + def capture(*args); end + def concat(string); end + def output_buffer; end + def output_buffer=(_); end + def with_output_buffer(buf = _); end + + def self.included(base); end +end + +class Thor::Actions::CapturableERB < ::ERB + def set_eoutvar(compiler, eoutvar = _); end +end + +module Thor::Actions::ClassMethods + def add_runtime_options!; end + def source_paths; end + def source_paths_for_search; end + def source_root(path = _); end +end + +class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory + def initialize(base, destination, data, config = _); end + + def data; end + def identical?; end + def invoke!; end + def render; end + + protected + + def force_on_collision?; end + def force_or_skip_or_conflict(force, skip, &block); end + def on_conflict_behavior(&block); end +end + +class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile + def data; end + def exists?; end + def identical?; end + def invoke!; end +end + +class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory + def initialize(base, source, destination = _, config = _, &block); end + + def invoke!; end + def revoke!; end + def source; end + + protected + + def execute!; end + def file_level_lookup(previous_lookup); end + def files(lookup); end +end + +class Thor::Actions::EmptyDirectory + def initialize(base, destination, config = _); end + + def base; end + def config; end + def destination; end + def exists?; end + def given_destination; end + def invoke!; end + def relative_destination; end + def revoke!; end + + protected + + def convert_encoded_instructions(filename); end + def destination=(destination); end + def invoke_with_conflict_check(&block); end + def on_conflict_behavior; end + def on_file_clash_behavior; end + def pretend?; end + def say_status(status, color); end +end + +class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory + def initialize(base, destination, data, config); end + + def behavior; end + def flag; end + def invoke!; end + def replacement; end + def revoke!; end + + protected + + def replace!(regexp, string, force); end + def say_status(behavior, warning: _, color: _); end +end + +Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash) + +class Thor::AmbiguousCommandError < ::Thor::Error +end + +Thor::AmbiguousTaskError = Thor::AmbiguousCommandError + +class Thor::Argument + def initialize(name, options = _); end + + def banner; end + def default; end + def description; end + def enum; end + def human_name; end + def name; end + def required; end + def required?; end + def show_default?; end + def type; end + def usage; end + + protected + + def default_banner; end + def valid_type?(type); end + def validate!; end +end + +Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array) + +class Thor::Arguments + def initialize(arguments = _); end + + def parse(args); end + def remaining; end + + private + + def check_requirement!; end + def current_is_value?; end + def last?; end + def no_or_skip?(arg); end + def parse_array(name); end + def parse_hash(name); end + def parse_numeric(name); end + def parse_string(name); end + def peek; end + def shift; end + def unshift(arg); end + + def self.parse(*args); end + def self.split(args); end +end + +Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp) + +module Thor::Base + include(::Thor::Invocation) + include(::Thor::Shell) + + mixes_in_class_methods(::Thor::Base::ClassMethods) + + def initialize(args = _, local_options = _, config = _); end + + def args; end + def args=(_); end + def options; end + def options=(_); end + def parent_options; end + def parent_options=(_); end + + def self.included(base); end + def self.register_klass_file(klass); end + def self.shell; end + def self.shell=(_); end + def self.subclass_files; end + def self.subclasses; end +end + +module Thor::Base::ClassMethods + def all_commands; end + def all_tasks; end + def allow_incompatible_default_type!; end + def argument(name, options = _); end + def arguments; end + def attr_accessor(*_); end + def attr_reader(*_); end + def attr_writer(*_); end + def check_default_type; end + def check_default_type!; end + def check_unknown_options; end + def check_unknown_options!; end + def check_unknown_options?(config); end + def class_option(name, options = _); end + def class_options(options = _); end + def commands; end + def disable_required_check?(command_name); end + def exit_on_failure?; end + def group(name = _); end + def handle_argument_error(command, error, args, arity); end + def handle_no_command_error(command, has_namespace = _); end + def handle_no_task_error(command, has_namespace = _); end + def namespace(name = _); end + def no_commands(&block); end + def no_commands?; end + def no_commands_context; end + def no_tasks(&block); end + def public_command(*names); end + def public_task(*names); end + def remove_argument(*names); end + def remove_class_option(*names); end + def remove_command(*names); end + def remove_task(*names); end + def start(given_args = _, config = _); end + def stop_on_unknown_option?(command_name); end + def strict_args_position; end + def strict_args_position!; end + def strict_args_position?(config); end + def tasks; end + + protected + + def baseclass; end + def basename; end + def build_option(name, options, scope); end + def build_options(options, scope); end + def class_options_help(shell, groups = _); end + def create_command(meth); end + def create_task(meth); end + def dispatch(command, given_args, given_opts, config); end + def find_and_refresh_command(name); end + def find_and_refresh_task(name); end + def from_superclass(method, default = _); end + def inherited(klass); end + def initialize_added; end + def is_thor_reserved_word?(word, type); end + def method_added(meth); end + def print_options(shell, options, group_name = _); end +end + +class Thor::Command < ::Struct + def initialize(name, description, long_description, usage, options = _); end + + def formatted_usage(klass, namespace = _, subcommand = _); end + def hidden?; end + def run(instance, args = _); end + + protected + + def handle_argument_error?(instance, error, caller); end + def handle_no_method_error?(instance, error, caller); end + def local_method?(instance, name); end + def not_debugging?(instance); end + def private_method?(instance); end + def public_method?(instance); end + def required_arguments_for(klass, usage); end + def required_options; end + def sans_backtrace(backtrace, caller); end + + private + + def initialize_copy(other); end +end + +Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp) + +module Thor::CoreExt +end + +class Thor::CoreExt::HashWithIndifferentAccess < ::Hash + def initialize(hash = _); end + + def [](key); end + def []=(key, value); end + def delete(key); end + def fetch(key, *args); end + def key?(key); end + def merge(other); end + def merge!(other); end + def replace(other_hash); end + def reverse_merge(other); end + def reverse_merge!(other_hash); end + def to_hash; end + def values_at(*indices); end + + protected + + def convert_key(key); end + def method_missing(method, *args); end +end + +Thor::Correctable = DidYouMean::Correctable + +class Thor::DynamicCommand < ::Thor::Command + def initialize(name, options = _); end + + def run(instance, args = _); end +end + +Thor::DynamicTask = Thor::DynamicCommand + +class Thor::Error < ::StandardError +end + +class Thor::Group + include(::Thor::Base) + include(::Thor::Invocation) + include(::Thor::Shell) + extend(::Thor::Base::ClassMethods) + extend(::Thor::Invocation::ClassMethods) + + + protected + + def _invoke_for_class_method(klass, command = _, *args, &block); end + + def self.class_options_help(shell, groups = _); end + def self.desc(description = _); end + def self.get_options_from_invocations(group_options, base_options); end + def self.handle_argument_error(command, error, _args, arity); end + def self.help(shell); end + def self.invocation_blocks; end + def self.invocations; end + def self.invoke(*names, &block); end + def self.invoke_from_option(*names, &block); end + def self.printable_commands(*_); end + def self.printable_tasks(*_); end + def self.remove_invocation(*names); end +end + +Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array) + +class Thor::HiddenCommand < ::Thor::Command + def hidden?; end +end + +Thor::HiddenTask = Thor::HiddenCommand + +module Thor::Invocation + mixes_in_class_methods(::Thor::Invocation::ClassMethods) + + def initialize(args = _, options = _, config = _, &block); end + + def current_command_chain; end + def invoke(name = _, *args); end + def invoke_all; end + def invoke_command(command, *args); end + def invoke_task(command, *args); end + def invoke_with_padding(*args); end + + protected + + def _parse_initialization_options(args, opts, config); end + def _retrieve_class_and_command(name, sent_command = _); end + def _retrieve_class_and_task(name, sent_command = _); end + def _shared_configuration; end + + def self.included(base); end +end + +module Thor::Invocation::ClassMethods + def prepare_for_invocation(key, name); end +end + +class Thor::InvocationError < ::Thor::Error +end + +module Thor::LineEditor + def self.best_available; end + def self.readline(prompt, options = _); end +end + +class Thor::LineEditor::Basic + def initialize(prompt, options); end + + def options; end + def prompt; end + def readline; end + + private + + def echo?; end + def get_input; end + + def self.available?; end +end + +class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic + def readline; end + + private + + def add_to_history?; end + def completion_options; end + def completion_proc; end + def use_path_completion?; end + + def self.available?; end +end + +class Thor::LineEditor::Readline::PathCompletion + def initialize(text); end + + def matches; end + + private + + def absolute_matches; end + def base_path; end + def glob_pattern; end + def relative_matches; end + def text; end +end + +class Thor::MalformattedArgumentError < ::Thor::InvocationError +end + +class Thor::NestedContext + def initialize; end + + def enter; end + def entered?; end + + private + + def pop; end + def push; end +end + +class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker + def initialize(dictionary); end +end + +class Thor::Option < ::Thor::Argument + def initialize(name, options = _); end + + def aliases; end + def array?; end + def boolean?; end + def group; end + def hash?; end + def hide; end + def human_name; end + def lazy_default; end + def numeric?; end + def repeatable; end + def string?; end + def switch_name; end + def usage(padding = _); end + + protected + + def dasherize(str); end + def dasherized?; end + def undasherize(str); end + def validate!; end + def validate_default_type!; end + + def self.parse(key, value); end +end + +Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array) + +class Thor::Options < ::Thor::Arguments + def initialize(hash_options = _, defaults = _, stop_on_unknown = _, disable_required_check = _); end + + def check_unknown!; end + def parse(args); end + def peek; end + def remaining; end + + protected + + def assign_result!(option, result); end + def current_is_switch?; end + def current_is_switch_formatted?; end + def current_is_value?; end + def normalize_switch(arg); end + def parse_boolean(switch); end + def parse_peek(switch, option); end + def parsing_options?; end + def switch?(arg); end + def switch_option(arg); end + + def self.to_switches(options); end +end + +Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp) + +Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp) + +Thor::Options::OPTS_END = T.let(T.unsafe(nil), String) + +Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp) + +Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp) + +Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp) + +class Thor::RequiredArgumentMissingError < ::Thor::InvocationError +end + +module Thor::Sandbox +end + +module Thor::Shell + def initialize(args = _, options = _, config = _); end + + def ask(*args, &block); end + def error(*args, &block); end + def file_collision(*args, &block); end + def no?(*args, &block); end + def print_in_columns(*args, &block); end + def print_table(*args, &block); end + def print_wrapped(*args, &block); end + def say(*args, &block); end + def say_status(*args, &block); end + def set_color(*args, &block); end + def shell; end + def shell=(_); end + def terminal_width(*args, &block); end + def with_padding; end + def yes?(*args, &block); end + + protected + + def _shared_configuration; end +end + +class Thor::Shell::Basic + def initialize; end + + def ask(statement, *args); end + def base; end + def base=(_); end + def error(statement); end + def file_collision(destination); end + def indent(count = _); end + def mute; end + def mute?; end + def no?(statement, color = _); end + def padding; end + def padding=(value); end + def print_in_columns(array); end + def print_table(array, options = _); end + def print_wrapped(message, options = _); end + def say(message = _, color = _, force_new_line = _); end + def say_status(status, message, log_status = _); end + def set_color(string, *_); end + def terminal_width; end + def yes?(statement, color = _); end + + protected + + def answer_match(possibilities, answer, case_insensitive); end + def as_unicode; end + def ask_filtered(statement, color, options); end + def ask_simply(statement, color, options); end + def can_display_colors?; end + def dynamic_width; end + def dynamic_width_stty; end + def dynamic_width_tput; end + def file_collision_help; end + def git_merge_tool; end + def is?(value); end + def lookup_color(color); end + def merge(destination, content); end + def merge_tool; end + def prepare_message(message, *color); end + def quiet?; end + def show_diff(destination, content); end + def stderr; end + def stdout; end + def truncate(string, width); end + def unix?; end +end + +Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) + +class Thor::Shell::Color < ::Thor::Shell::Basic + def set_color(string, *colors); end + + protected + + def are_colors_disabled?; end + def can_display_colors?; end + def diff_lcs_loaded?; end + def output_diff_line(diff); end + def show_diff(destination, content); end +end + +Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::RED = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String) + +Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String) + +class Thor::Shell::HTML < ::Thor::Shell::Basic + def ask(statement, color = _); end + def set_color(string, *colors); end + + protected + + def can_display_colors?; end + def diff_lcs_loaded?; end + def output_diff_line(diff); end + def show_diff(destination, content); end +end + +Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String) + +Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String) + +Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array) + +Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String) + +Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array) + +Thor::Task = Thor::Command + +class Thor::UndefinedCommandError < ::Thor::Error + include(::DidYouMean::Correctable) + + def initialize(command, all_commands, namespace); end + + def all_commands; end + def command; end +end + +class Thor::UndefinedCommandError::SpellChecker + def initialize(error); end + + def corrections; end + def error; end + def spell_checker; end +end + +Thor::UndefinedTaskError = Thor::UndefinedCommandError + +class Thor::UnknownArgumentError < ::Thor::Error + include(::DidYouMean::Correctable) + + def initialize(switches, unknown); end + + def switches; end + def unknown; end +end + +class Thor::UnknownArgumentError::SpellChecker + def initialize(error); end + + def corrections; end + def error; end + def spell_checker; end +end + +module Thor::Util + def self.camel_case(str); end + def self.escape_globs(path); end + def self.escape_html(string); end + def self.find_by_namespace(namespace); end + def self.find_class_and_command_by_namespace(namespace, fallback = _); end + def self.find_class_and_task_by_namespace(namespace, fallback = _); end + def self.globs_for(path); end + def self.load_thorfile(path, content = _, debug = _); end + def self.namespace_from_thor_class(constant); end + def self.namespaces_in_content(contents, file = _); end + def self.ruby_command; end + def self.snake_case(str); end + def self.thor_classes_in(klass); end + def self.thor_root; end + def self.thor_root_glob; end + def self.user_home; end +end diff --git a/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi b/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi b/Library/Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi b/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi new file mode 100644 index 0000000000..2d49ec540f --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi @@ -0,0 +1,21 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module UNF +end + +class UNF::Normalizer + include(::Singleton) + extend(::Singleton::SingletonClassMethods) + + def initialize; end + + def normalize(_, _); end + + def self.instance; end + def self.normalize(string, form); end +end + +UNF::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi new file mode 100644 index 0000000000..90001fa9fa --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi @@ -0,0 +1,26 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +module Unicode +end + +module Unicode::DisplayWidth + def self.emoji_extra_width_of(string, ambiguous = _, overwrite = _, _ = _); end + def self.of(string, ambiguous = _, overwrite = _, options = _); end +end + +Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String) + +Unicode::DisplayWidth::DEPTHS = T.let(T.unsafe(nil), Array) + +Unicode::DisplayWidth::INDEX = T.let(T.unsafe(nil), Array) + +Unicode::DisplayWidth::INDEX_FILENAME = T.let(T.unsafe(nil), String) + +Unicode::DisplayWidth::NO_STRING_EXT = T.let(T.unsafe(nil), TrueClass) + +Unicode::DisplayWidth::UNICODE_VERSION = T.let(T.unsafe(nil), String) + +Unicode::DisplayWidth::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi new file mode 100644 index 0000000000..f8d2990806 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi @@ -0,0 +1,172 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + +class Nokogiri::HTML::Document < ::Nokogiri::XML::Document + def fragment(tags = _); end + def meta_encoding; end + def meta_encoding=(encoding); end + def meta_robots(custom_name = _); end + def nofollow?(custom_name = _); end + def noindex?(custom_name = _); end + def serialize(options = _); end + def title; end + def title=(text); end + def type; end + + private + + def meta_content_type; end + def parse_meta_robots(custom_name); end + def set_metadata_element(element); end + + def self.new(*_); end + def self.parse(string_or_io, url = _, encoding = _, options = _); end + def self.read_io(_, _, _, _); end + def self.read_memory(_, _, _, _); end +end + +class WebRobots + def initialize(user_agent, options = _); end + + def allowed?(url); end + def crawl_delay(url); end + def create_cache; end + def disallowed?(url); end + def error(url); end + def error!(url); end + def flush_cache; end + def option(url, token); end + def options(url); end + def reset(url); end + def sitemaps(url); end + def user_agent; end + + private + + def crawl_delay_handler(delay, last_checked_at); end + def fetch_robots_txt(site); end + def get_robots_txt(site); end + def http_get(uri); end + def robots_txt_for(url); end + def split_uri(url); end +end + +class WebRobots::Error < ::StandardError +end + +class WebRobots::ParseError < ::WebRobots::Error + def initialize(message, site); end + + def site; end + def to_s; end +end + +class WebRobots::RobotsTxt + def initialize(site, records, options = _); end + + def allow?(request_uri, user_agent = _); end + def crawl_delay(user_agent = _); end + def error; end + def error!; end + def error=(_); end + def options(user_agent = _); end + def site; end + def sitemaps; end + def timestamp; end + + private + + def find_record(user_agent = _); end + def target(user_agent = _); end + + def self.unfetchable(site, reason, target = _); end +end + +class WebRobots::RobotsTxt::AccessControlLine < ::WebRobots::RobotsTxt::Line + def compile; end + def match?(request_uri); end +end + +class WebRobots::RobotsTxt::AgentLine < ::WebRobots::RobotsTxt::Line + def compile; end + def pattern; end +end + +class WebRobots::RobotsTxt::AllowLine < ::WebRobots::RobotsTxt::AccessControlLine + def allow?; end +end + +class WebRobots::RobotsTxt::CrawlDelayLine < ::WebRobots::RobotsTxt::Line + def compile; end + def delay; end +end + +WebRobots::RobotsTxt::DISALLOW_ALL = T.let(T.unsafe(nil), String) + +class WebRobots::RobotsTxt::DisallowLine < ::WebRobots::RobotsTxt::AccessControlLine + def allow?; end +end + +class WebRobots::RobotsTxt::ExtentionLine < ::WebRobots::RobotsTxt::Line +end + +class WebRobots::RobotsTxt::Line + def initialize(token, value); end + + def compile; end + def token; end + def value; end +end + +class WebRobots::RobotsTxt::Parser < ::Racc::Parser + def initialize(target, crawl_delay_handler = _); end + + def _reduce_1(val, _values, result); end + def _reduce_17(val, _values, result); end + def _reduce_18(val, _values, result); end + def _reduce_19(val, _values, result); end + def _reduce_2(val, _values, result); end + def _reduce_20(val, _values, result); end + def _reduce_21(val, _values, result); end + def _reduce_24(val, _values, result); end + def _reduce_25(val, _values, result); end + def _reduce_26(val, _values, result); end + def _reduce_28(val, _values, result); end + def _reduce_31(val, _values, result); end + def _reduce_32(val, _values, result); end + def _reduce_38(val, _values, result); end + def _reduce_39(val, _values, result); end + def _reduce_40(val, _values, result); end + def _reduce_41(val, _values, result); end + def _reduce_none(val, _values, result); end + def next_token; end + def on_error(token_id, value, stack); end + def parse(input, site); end + def parse!(input, site); end + def parse_error(message); end +end + +WebRobots::RobotsTxt::Parser::KNOWN_TOKENS = T.let(T.unsafe(nil), Array) + +WebRobots::RobotsTxt::Parser::RE_KNOWN_TOKENS = T.let(T.unsafe(nil), Regexp) + +WebRobots::RobotsTxt::Parser::Racc_arg = T.let(T.unsafe(nil), Array) + +WebRobots::RobotsTxt::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) + +class WebRobots::RobotsTxt::Record + def initialize(agentlines, rulelines); end + + def allow?(request_uri); end + def default?; end + def delay; end + def match?(user_agent); end + def options; end +end + +module Webrobots +end + +Webrobots::VERSION = T.let(T.unsafe(nil), String) diff --git a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.3.0.rbi new file mode 100644 index 0000000000..27b1fb4bc6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.3.0.rbi @@ -0,0 +1,6 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# tapioca sync + +# typed: true + + diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt b/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt index f0dc7e8dbc..de7f604aae 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt @@ -108,54 +108,6 @@ # wrong constant name > # wrong constant name # wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `AST::Node' -# undefined method `initialize2' for class `AST::Node' -# undefined method `inspect1' for class `AST::Node' -# undefined method `to_s1' for class `AST::Node' -# undefined method `to_sexp1' for class `AST::Node' -# undefined method `updated1' for class `AST::Node' -# undefined method `updated2' for class `AST::Node' -# undefined method `updated3' for class `AST::Node' -# wrong constant name + -# wrong constant name << -# wrong constant name == -# wrong constant name append -# wrong constant name assign_properties -# wrong constant name children -# wrong constant name clone -# wrong constant name concat -# wrong constant name eql? -# wrong constant name fancy_type -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name inspect1 -# wrong constant name inspect -# wrong constant name to_a -# wrong constant name to_ast -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name to_sexp1 -# wrong constant name to_sexp -# wrong constant name to_sexp_array -# wrong constant name type -# wrong constant name updated1 -# wrong constant name updated2 -# wrong constant name updated3 -# wrong constant name updated -# wrong constant name -# wrong constant name -# wrong constant name handler_missing -# wrong constant name process -# wrong constant name process_all -# wrong constant name -# wrong constant name -# wrong constant name s -# wrong constant name -# wrong constant name # uninitialized constant Abbrev # uninitialized constant Abbrev # uninitialized constant AbstractDownloadStrategy::LOW_METHODS @@ -3202,25 +3154,18 @@ # wrong constant name short_description # wrong constant name banner # wrong constant name -# undefined singleton method `spawn1' for `Byebug' -# undefined singleton method `spawn2' for `Byebug' # undefined singleton method `start_client1' for `Byebug' # undefined singleton method `start_client2' for `Byebug' # undefined singleton method `start_control1' for `Byebug' # undefined singleton method `start_control2' for `Byebug' # undefined singleton method `start_server1' for `Byebug' # undefined singleton method `start_server2' for `Byebug' -# wrong constant name # wrong constant name actual_control_port # wrong constant name actual_port -# wrong constant name attach # wrong constant name handle_post_mortem # wrong constant name interrupt # wrong constant name load_settings # wrong constant name parse_host_and_port -# wrong constant name spawn1 -# wrong constant name spawn2 -# wrong constant name spawn # wrong constant name start_client1 # wrong constant name start_client2 # wrong constant name start_client @@ -3554,7 +3499,6 @@ # wrong constant name class_attribute4 # wrong constant name class_attribute5 # wrong constant name class_attribute -# wrong constant name json_creatable? # wrong constant name # wrong constant name # wrong constant name @@ -3817,1552 +3761,14 @@ # wrong constant name scanner # wrong constant name [] # wrong constant name members -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `exchange1' for class `Concurrent::AbstractExchanger' -# undefined method `exchange!1' for class `Concurrent::AbstractExchanger' -# undefined method `try_exchange1' for class `Concurrent::AbstractExchanger' -# wrong constant name exchange1 -# wrong constant name exchange -# wrong constant name exchange!1 -# wrong constant name exchange! -# wrong constant name try_exchange1 -# wrong constant name try_exchange -# wrong constant name -# undefined method `initialize1' for class `Concurrent::AbstractExecutorService' -# undefined method `wait_for_termination1' for class `Concurrent::AbstractExecutorService' -# uninitialized constant Concurrent::AbstractExecutorService::DEBUG -# uninitialized constant Concurrent::AbstractExecutorService::ERROR -# uninitialized constant Concurrent::AbstractExecutorService::FATAL -# uninitialized constant Concurrent::AbstractExecutorService::INFO -# uninitialized constant Concurrent::AbstractExecutorService::UNKNOWN -# uninitialized constant Concurrent::AbstractExecutorService::WARN -# wrong constant name auto_terminate= -# wrong constant name auto_terminate? -# wrong constant name fallback_policy -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name kill -# wrong constant name name -# wrong constant name running? -# wrong constant name shutdown -# wrong constant name shutdown? -# wrong constant name shuttingdown? -# wrong constant name wait_for_termination1 -# wrong constant name wait_for_termination -# wrong constant name -# undefined method `initialize1' for class `Concurrent::AbstractThreadLocalVar' -# wrong constant name allocate_storage -# wrong constant name bind -# wrong constant name default -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `initialize1' for class `Concurrent::Agent' -# undefined method `restart1' for class `Concurrent::Agent' -# undefined method `wait1' for class `Concurrent::Agent' -# wrong constant name << -# wrong constant name -# wrong constant name -# wrong constant name await -# wrong constant name await_for -# wrong constant name await_for! -# wrong constant name deref -# wrong constant name error -# wrong constant name error_mode -# wrong constant name failed? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name post -# wrong constant name reason -# wrong constant name restart1 -# wrong constant name restart -# wrong constant name send -# wrong constant name send! -# wrong constant name send_off -# wrong constant name send_off! -# wrong constant name send_via -# wrong constant name send_via! -# wrong constant name stopped? -# wrong constant name value -# wrong constant name wait1 -# wrong constant name wait -# undefined method `initialize1' for class `Concurrent::Agent::Error' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name await -# wrong constant name await_for -# wrong constant name await_for! -# uninitialized constant Concurrent::Array::DEFAULT_INDENT -# uninitialized constant Concurrent::Array::Elem -# wrong constant name -# wrong constant name async -# wrong constant name await -# wrong constant name call -# wrong constant name cast -# wrong constant name init_synchronization -# wrong constant name -# wrong constant name included -# wrong constant name validate_argc -# undefined method `initialize1' for class `Concurrent::Atom' -# wrong constant name compare_and_set -# wrong constant name deref -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name reset -# wrong constant name swap -# wrong constant name value -# wrong constant name -# wrong constant name new -# wrong constant name -# wrong constant name try_update -# wrong constant name try_update! -# wrong constant name update -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Concurrent::AtomicMarkableReference' -# undefined method `initialize2' for class `Concurrent::AtomicMarkableReference' -# wrong constant name compare_and_set -# wrong constant name compare_and_swap -# wrong constant name get -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name mark -# wrong constant name marked? -# wrong constant name set -# wrong constant name try_update -# wrong constant name try_update! -# wrong constant name update -# wrong constant name value -# wrong constant name -# wrong constant name new -# wrong constant name compare_and_set -# wrong constant name -# wrong constant name -# uninitialized constant Concurrent::CachedThreadPool::DEBUG -# uninitialized constant Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE -# uninitialized constant Concurrent::CachedThreadPool::DEFAULT_MAX_QUEUE_SIZE -# uninitialized constant Concurrent::CachedThreadPool::DEFAULT_MIN_POOL_SIZE -# uninitialized constant Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT -# uninitialized constant Concurrent::CachedThreadPool::ERROR -# uninitialized constant Concurrent::CachedThreadPool::FALLBACK_POLICIES -# uninitialized constant Concurrent::CachedThreadPool::FATAL -# uninitialized constant Concurrent::CachedThreadPool::INFO -# uninitialized constant Concurrent::CachedThreadPool::UNKNOWN -# uninitialized constant Concurrent::CachedThreadPool::WARN -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `add_observer1' for class `Concurrent::Collection::CopyOnNotifyObserverSet' -# undefined method `add_observer2' for class `Concurrent::Collection::CopyOnNotifyObserverSet' -# wrong constant name add_observer1 -# wrong constant name add_observer2 -# wrong constant name add_observer -# wrong constant name count_observers -# wrong constant name delete_observer -# wrong constant name delete_observers -# wrong constant name initialize -# wrong constant name notify_and_delete_observers -# wrong constant name notify_observers -# wrong constant name ns_initialize -# wrong constant name -# undefined method `add_observer1' for class `Concurrent::Collection::CopyOnWriteObserverSet' -# undefined method `add_observer2' for class `Concurrent::Collection::CopyOnWriteObserverSet' -# wrong constant name add_observer1 -# wrong constant name add_observer2 -# wrong constant name add_observer -# wrong constant name count_observers -# wrong constant name delete_observer -# wrong constant name delete_observers -# wrong constant name initialize -# wrong constant name notify_and_delete_observers -# wrong constant name notify_observers -# wrong constant name ns_initialize -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Concurrent::Collection::NonConcurrentMapBackend' -# wrong constant name [] -# wrong constant name []= -# wrong constant name clear -# wrong constant name compute -# wrong constant name compute_if_absent -# wrong constant name compute_if_present -# wrong constant name delete -# wrong constant name delete_pair -# wrong constant name each_pair -# wrong constant name get_and_set -# wrong constant name get_or_default -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name key? -# wrong constant name merge_pair -# wrong constant name replace_if_exists -# wrong constant name replace_pair -# wrong constant name size -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Concurrent::Collection::RubyNonConcurrentPriorityQueue' -# wrong constant name << -# wrong constant name clear -# wrong constant name delete -# wrong constant name deq -# wrong constant name empty? -# wrong constant name enq -# wrong constant name has_priority? -# wrong constant name include? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name length -# wrong constant name peek -# wrong constant name pop -# wrong constant name push -# wrong constant name shift -# wrong constant name size -# undefined singleton method `from_list1' for `Concurrent::Collection::RubyNonConcurrentPriorityQueue' -# wrong constant name -# wrong constant name from_list1 -# wrong constant name from_list -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `deprecated1' for module `Concurrent::Concern::Deprecation' -# uninitialized constant Concurrent::Concern::Deprecation::DEBUG -# uninitialized constant Concurrent::Concern::Deprecation::ERROR -# uninitialized constant Concurrent::Concern::Deprecation::FATAL -# uninitialized constant Concurrent::Concern::Deprecation::INFO -# uninitialized constant Concurrent::Concern::Deprecation::UNKNOWN -# uninitialized constant Concurrent::Concern::Deprecation::WARN -# wrong constant name deprecated1 -# wrong constant name deprecated -# wrong constant name deprecated_method -# wrong constant name -# undefined method `set_deref_options1' for module `Concurrent::Concern::Dereferenceable' -# wrong constant name apply_deref_options -# wrong constant name deref -# wrong constant name ns_set_deref_options -# wrong constant name set_deref_options1 -# wrong constant name set_deref_options -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `log1' for module `Concurrent::Concern::Logging' -# uninitialized constant Concurrent::Concern::Logging::DEBUG -# uninitialized constant Concurrent::Concern::Logging::ERROR -# uninitialized constant Concurrent::Concern::Logging::FATAL -# uninitialized constant Concurrent::Concern::Logging::INFO -# uninitialized constant Concurrent::Concern::Logging::UNKNOWN -# uninitialized constant Concurrent::Concern::Logging::WARN -# wrong constant name log1 -# wrong constant name log -# wrong constant name -# undefined method `get_arguments_from1' for module `Concurrent::Concern::Obligation' -# undefined method `no_error!1' for module `Concurrent::Concern::Obligation' -# undefined method `value1' for module `Concurrent::Concern::Obligation' -# undefined method `value!1' for module `Concurrent::Concern::Obligation' -# undefined method `wait1' for module `Concurrent::Concern::Obligation' -# undefined method `wait!1' for module `Concurrent::Concern::Obligation' -# wrong constant name compare_and_set_state -# wrong constant name complete? -# wrong constant name event -# wrong constant name exception -# wrong constant name fulfilled? -# wrong constant name get_arguments_from1 -# wrong constant name get_arguments_from -# wrong constant name if_state -# wrong constant name incomplete? -# wrong constant name init_obligation -# wrong constant name no_error!1 -# wrong constant name no_error! -# wrong constant name ns_check_state? -# wrong constant name ns_set_state -# wrong constant name pending? -# wrong constant name realized? -# wrong constant name reason -# wrong constant name rejected? -# wrong constant name set_state -# wrong constant name state -# wrong constant name state= -# wrong constant name unscheduled? -# wrong constant name value1 -# wrong constant name value -# wrong constant name value!1 -# wrong constant name value! -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name wait!1 -# wrong constant name wait! -# wrong constant name -# undefined method `add_observer1' for module `Concurrent::Concern::Observable' -# undefined method `add_observer2' for module `Concurrent::Concern::Observable' -# undefined method `with_observer1' for module `Concurrent::Concern::Observable' -# undefined method `with_observer2' for module `Concurrent::Concern::Observable' -# wrong constant name add_observer1 -# wrong constant name add_observer2 -# wrong constant name add_observer -# wrong constant name count_observers -# wrong constant name delete_observer -# wrong constant name delete_observers -# wrong constant name observers -# wrong constant name observers= -# wrong constant name with_observer1 -# wrong constant name with_observer2 -# wrong constant name with_observer -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `ns_generation_done1' for class `Concurrent::CyclicBarrier' -# undefined method `wait1' for class `Concurrent::CyclicBarrier' -# wrong constant name broken? -# wrong constant name initialize -# wrong constant name ns_generation_done1 -# wrong constant name ns_generation_done -# wrong constant name ns_initialize -# wrong constant name ns_next_generation -# wrong constant name number_waiting -# wrong constant name parties -# wrong constant name reset -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name -# undefined method `initialize1' for class `Concurrent::Delay' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name reconfigure -# wrong constant name -# wrong constant name initialize -# wrong constant name update -# wrong constant name -# wrong constant name -# undefined method `wait1' for class `Concurrent::Event' -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name ns_set -# wrong constant name reset -# wrong constant name set -# wrong constant name set? -# wrong constant name try? -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name -# wrong constant name -# wrong constant name << -# uninitialized constant Concurrent::ExecutorService::DEBUG -# uninitialized constant Concurrent::ExecutorService::ERROR -# uninitialized constant Concurrent::ExecutorService::FATAL -# uninitialized constant Concurrent::ExecutorService::INFO -# uninitialized constant Concurrent::ExecutorService::UNKNOWN -# uninitialized constant Concurrent::ExecutorService::WARN -# wrong constant name can_overflow? -# wrong constant name post -# wrong constant name serialized? -# wrong constant name -# undefined method `initialize1' for class `Concurrent::FixedThreadPool' -# uninitialized constant Concurrent::FixedThreadPool::DEBUG -# uninitialized constant Concurrent::FixedThreadPool::DEFAULT_MAX_POOL_SIZE -# uninitialized constant Concurrent::FixedThreadPool::DEFAULT_MAX_QUEUE_SIZE -# uninitialized constant Concurrent::FixedThreadPool::DEFAULT_MIN_POOL_SIZE -# uninitialized constant Concurrent::FixedThreadPool::DEFAULT_THREAD_IDLETIMEOUT -# uninitialized constant Concurrent::FixedThreadPool::ERROR -# uninitialized constant Concurrent::FixedThreadPool::FALLBACK_POLICIES -# uninitialized constant Concurrent::FixedThreadPool::FATAL -# uninitialized constant Concurrent::FixedThreadPool::INFO -# uninitialized constant Concurrent::FixedThreadPool::UNKNOWN -# uninitialized constant Concurrent::FixedThreadPool::WARN -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# undefined method `initialize1' for class `Concurrent::Future' -# undefined method `set1' for class `Concurrent::Future' -# wrong constant name cancel -# wrong constant name cancelled? -# wrong constant name execute -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name set1 -# wrong constant name set -# wrong constant name wait_or_cancel -# undefined singleton method `execute1' for `Concurrent::Future' -# wrong constant name -# wrong constant name execute1 -# wrong constant name execute -# uninitialized constant Concurrent::Hash::DEFAULT_INDENT -# uninitialized constant Concurrent::Hash::Elem -# uninitialized constant Concurrent::Hash::K -# uninitialized constant Concurrent::Hash::V -# wrong constant name -# undefined method `fail1' for class `Concurrent::IVar' -# undefined method `initialize1' for class `Concurrent::IVar' -# undefined method `initialize2' for class `Concurrent::IVar' -# undefined method `safe_execute1' for class `Concurrent::IVar' -# undefined method `set1' for class `Concurrent::IVar' -# undefined method `try_set1' for class `Concurrent::IVar' -# wrong constant name check_for_block_or_value! -# wrong constant name complete -# wrong constant name complete_without_notification -# wrong constant name fail1 -# wrong constant name fail -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name notify_observers -# wrong constant name ns_complete_without_notification -# wrong constant name ns_initialize -# wrong constant name safe_execute1 -# wrong constant name safe_execute -# wrong constant name set1 -# wrong constant name set -# wrong constant name try_set1 -# wrong constant name try_set -# wrong constant name -# wrong constant name -# uninitialized constant Concurrent::ImmediateExecutor::DEBUG -# uninitialized constant Concurrent::ImmediateExecutor::ERROR -# uninitialized constant Concurrent::ImmediateExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::ImmediateExecutor::FATAL -# uninitialized constant Concurrent::ImmediateExecutor::INFO -# uninitialized constant Concurrent::ImmediateExecutor::UNKNOWN -# uninitialized constant Concurrent::ImmediateExecutor::WARN -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name == -# wrong constant name [] -# wrong constant name each -# wrong constant name each_pair -# wrong constant name inspect -# wrong constant name merge -# wrong constant name select -# wrong constant name to_a -# wrong constant name to_h -# wrong constant name to_s -# wrong constant name values -# wrong constant name values_at -# wrong constant name -# wrong constant name included -# wrong constant name new -# uninitialized constant Concurrent::IndirectImmediateExecutor::DEBUG -# uninitialized constant Concurrent::IndirectImmediateExecutor::ERROR -# uninitialized constant Concurrent::IndirectImmediateExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::IndirectImmediateExecutor::FATAL -# uninitialized constant Concurrent::IndirectImmediateExecutor::INFO -# uninitialized constant Concurrent::IndirectImmediateExecutor::UNKNOWN -# uninitialized constant Concurrent::IndirectImmediateExecutor::WARN -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `each1' for class `Concurrent::LockFreeStack' -# undefined method `empty?1' for class `Concurrent::LockFreeStack' -# undefined method `initialize1' for class `Concurrent::LockFreeStack' -# uninitialized constant Concurrent::LockFreeStack::Elem -# wrong constant name -# wrong constant name clear -# wrong constant name clear_each -# wrong constant name clear_if -# wrong constant name compare_and_clear -# wrong constant name compare_and_pop -# wrong constant name compare_and_push -# wrong constant name each1 -# wrong constant name each -# wrong constant name empty?1 -# wrong constant name empty? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name peek -# wrong constant name pop -# wrong constant name push -# wrong constant name replace_if -# wrong constant name initialize -# wrong constant name next_node -# wrong constant name value -# wrong constant name value= -# wrong constant name -# wrong constant name [] -# wrong constant name -# wrong constant name new -# wrong constant name of1 -# wrong constant name of2 -# undefined method `borrow1' for class `Concurrent::MVar' -# undefined method `initialize1' for class `Concurrent::MVar' -# undefined method `initialize2' for class `Concurrent::MVar' -# undefined method `modify1' for class `Concurrent::MVar' -# undefined method `put1' for class `Concurrent::MVar' -# undefined method `take1' for class `Concurrent::MVar' -# wrong constant name borrow1 -# wrong constant name borrow -# wrong constant name empty? -# wrong constant name full? -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name modify1 -# wrong constant name modify -# wrong constant name modify! -# wrong constant name put1 -# wrong constant name put -# wrong constant name set! -# wrong constant name synchronize -# wrong constant name take1 -# wrong constant name take -# wrong constant name try_put! -# wrong constant name try_take! -# wrong constant name -# wrong constant name new -# undefined method `fetch1' for class `Concurrent::Map' -# undefined method `fetch_or_store1' for class `Concurrent::Map' -# undefined method `initialize1' for class `Concurrent::Map' -# wrong constant name each -# wrong constant name each_key -# wrong constant name each_value -# wrong constant name empty? -# wrong constant name fetch1 -# wrong constant name fetch -# wrong constant name fetch_or_store1 -# wrong constant name fetch_or_store -# wrong constant name get -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name key -# wrong constant name keys -# wrong constant name marshal_dump -# wrong constant name marshal_load -# wrong constant name put -# wrong constant name put_if_absent -# wrong constant name value? -# wrong constant name values -# wrong constant name -# wrong constant name -# wrong constant name <=> -# wrong constant name fulfilled? -# wrong constant name initialize -# wrong constant name just -# wrong constant name just? -# wrong constant name nothing -# wrong constant name nothing? -# wrong constant name or -# wrong constant name reason -# wrong constant name rejected? -# wrong constant name value -# undefined singleton method `nothing1' for `Concurrent::Maybe' -# wrong constant name -# wrong constant name from -# wrong constant name just -# wrong constant name nothing1 -# wrong constant name nothing -# undefined method `initialize1' for class `Concurrent::MultipleAssignmentError' -# undefined method `initialize2' for class `Concurrent::MultipleAssignmentError' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name inspection_data -# wrong constant name -# undefined method `initialize1' for class `Concurrent::MultipleErrors' -# wrong constant name errors -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name == -# wrong constant name [] -# wrong constant name []= -# wrong constant name each -# wrong constant name each_pair -# wrong constant name inspect -# wrong constant name merge -# wrong constant name select -# wrong constant name to_a -# wrong constant name to_h -# wrong constant name to_s -# wrong constant name values -# wrong constant name values_at -# wrong constant name -# wrong constant name new -# undefined method `initialize1' for class `Concurrent::MutexAtomicBoolean' -# wrong constant name false? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name make_false -# wrong constant name make_true -# wrong constant name ns_initialize -# wrong constant name true? -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `decrement1' for class `Concurrent::MutexAtomicFixnum' -# undefined method `down1' for class `Concurrent::MutexAtomicFixnum' -# undefined method `increment1' for class `Concurrent::MutexAtomicFixnum' -# undefined method `initialize1' for class `Concurrent::MutexAtomicFixnum' -# undefined method `up1' for class `Concurrent::MutexAtomicFixnum' -# wrong constant name compare_and_set -# wrong constant name decrement1 -# wrong constant name decrement -# wrong constant name down1 -# wrong constant name down -# wrong constant name increment1 -# wrong constant name increment -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name up1 -# wrong constant name up -# wrong constant name update -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `initialize1' for class `Concurrent::MutexAtomicReference' -# wrong constant name _compare_and_set -# wrong constant name compare_and_swap -# wrong constant name get -# wrong constant name get_and_set -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name set -# wrong constant name swap -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `initialize1' for class `Concurrent::MutexCountDownLatch' -# undefined method `wait1' for class `Concurrent::MutexCountDownLatch' -# wrong constant name count -# wrong constant name count_down -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name -# undefined method `acquire1' for class `Concurrent::MutexSemaphore' -# undefined method `release1' for class `Concurrent::MutexSemaphore' -# undefined method `try_acquire1' for class `Concurrent::MutexSemaphore' -# undefined method `try_acquire2' for class `Concurrent::MutexSemaphore' -# wrong constant name acquire1 -# wrong constant name acquire -# wrong constant name available_permits -# wrong constant name drain_permits -# wrong constant name initialize -# wrong constant name ns_initialize -# wrong constant name reduce_permits -# wrong constant name release1 -# wrong constant name release -# wrong constant name try_acquire1 -# wrong constant name try_acquire2 -# wrong constant name try_acquire -# wrong constant name -# undefined singleton method `executor_from_options1' for `Concurrent::Options' -# wrong constant name -# wrong constant name executor -# wrong constant name executor_from_options1 -# wrong constant name executor_from_options -# undefined method `initialize1' for class `Concurrent::Promise' -# undefined method `set1' for class `Concurrent::Promise' -# wrong constant name catch -# wrong constant name execute -# wrong constant name flat_map -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name notify_child -# wrong constant name on_error -# wrong constant name on_fulfill -# wrong constant name on_reject -# wrong constant name on_success -# wrong constant name realize -# wrong constant name rescue -# wrong constant name root? -# wrong constant name set1 -# wrong constant name set -# wrong constant name set_pending -# wrong constant name set_state! -# wrong constant name synchronized_set_state! -# wrong constant name then -# wrong constant name zip -# undefined singleton method `execute1' for `Concurrent::Promise' -# undefined singleton method `fulfill1' for `Concurrent::Promise' -# undefined singleton method `reject1' for `Concurrent::Promise' -# wrong constant name -# wrong constant name aggregate -# wrong constant name all? -# wrong constant name any? -# wrong constant name execute1 -# wrong constant name execute -# wrong constant name fulfill1 -# wrong constant name fulfill -# wrong constant name reject1 -# wrong constant name reject -# wrong constant name zip -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `resolve_with1' for class `Concurrent::Promises::AbstractEventFuture' -# undefined method `resolve_with2' for class `Concurrent::Promises::AbstractEventFuture' -# undefined method `wait1' for class `Concurrent::Promises::AbstractEventFuture' # uninitialized constant Concurrent::Promises::AbstractEventFuture::PENDING # uninitialized constant Concurrent::Promises::AbstractEventFuture::RESERVED # uninitialized constant Concurrent::Promises::AbstractEventFuture::RESOLVED -# wrong constant name add_callback_clear_delayed_node -# wrong constant name add_callback_notify_blocked -# wrong constant name blocks -# wrong constant name callbacks -# wrong constant name chain -# wrong constant name chain_on -# wrong constant name chain_resolvable -# wrong constant name default_executor -# wrong constant name initialize -# wrong constant name internal_state -# wrong constant name on_resolution -# wrong constant name on_resolution! -# wrong constant name on_resolution_using -# wrong constant name pending? -# wrong constant name promise -# wrong constant name resolve_with1 -# wrong constant name resolve_with2 -# wrong constant name resolve_with -# wrong constant name resolved? -# wrong constant name state -# wrong constant name tangle -# wrong constant name touch -# wrong constant name touched? -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name waiting_threads -# wrong constant name with_default_executor -# wrong constant name with_hidden_resolvable -# wrong constant name -# wrong constant name new -# wrong constant name & -# uninitialized constant Concurrent::Promises::Event::PENDING -# uninitialized constant Concurrent::Promises::Event::RESERVED -# uninitialized constant Concurrent::Promises::Event::RESOLVED -# wrong constant name any -# wrong constant name delay -# wrong constant name schedule -# wrong constant name then -# wrong constant name to_event -# wrong constant name to_future -# wrong constant name zip -# wrong constant name | -# wrong constant name -# undefined method `fulfilled_future1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `make_future1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `make_future2' for module `Concurrent::Promises::FactoryMethods' -# undefined method `rejected_future1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `resolvable_event_on1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `resolvable_future_on1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `resolved_event1' for module `Concurrent::Promises::FactoryMethods' -# undefined method `resolved_future1' for module `Concurrent::Promises::FactoryMethods' -# wrong constant name -# wrong constant name any -# wrong constant name any_event -# wrong constant name any_event_on -# wrong constant name any_fulfilled_future -# wrong constant name any_fulfilled_future_on -# wrong constant name any_resolved_future -# wrong constant name any_resolved_future_on -# wrong constant name delay -# wrong constant name delay_on -# wrong constant name fulfilled_future1 -# wrong constant name fulfilled_future -# wrong constant name future -# wrong constant name future_on -# wrong constant name make_future1 -# wrong constant name make_future2 -# wrong constant name make_future -# wrong constant name rejected_future1 -# wrong constant name rejected_future -# wrong constant name resolvable_event -# wrong constant name resolvable_event_on1 -# wrong constant name resolvable_event_on -# wrong constant name resolvable_future -# wrong constant name resolvable_future_on1 -# wrong constant name resolvable_future_on -# wrong constant name resolved_event1 -# wrong constant name resolved_event -# wrong constant name resolved_future1 -# wrong constant name resolved_future -# wrong constant name schedule -# wrong constant name schedule_on -# wrong constant name zip -# wrong constant name zip_events -# wrong constant name zip_events_on -# wrong constant name zip_futures -# wrong constant name zip_futures_on -# wrong constant name default_executor -# wrong constant name -# wrong constant name -# undefined method `flat1' for class `Concurrent::Promises::Future' -# undefined method `flat_future1' for class `Concurrent::Promises::Future' -# undefined method `reason1' for class `Concurrent::Promises::Future' -# undefined method `reason2' for class `Concurrent::Promises::Future' -# undefined method `result1' for class `Concurrent::Promises::Future' -# undefined method `run1' for class `Concurrent::Promises::Future' -# undefined method `value1' for class `Concurrent::Promises::Future' -# undefined method `value2' for class `Concurrent::Promises::Future' -# undefined method `value!1' for class `Concurrent::Promises::Future' -# undefined method `value!2' for class `Concurrent::Promises::Future' -# undefined method `wait!1' for class `Concurrent::Promises::Future' -# wrong constant name & -# uninitialized constant Concurrent::Promises::Future::PENDING -# uninitialized constant Concurrent::Promises::Future::RESERVED -# uninitialized constant Concurrent::Promises::Future::RESOLVED -# wrong constant name any -# wrong constant name apply -# wrong constant name delay -# wrong constant name exception -# wrong constant name flat1 -# wrong constant name flat -# wrong constant name flat_event -# wrong constant name flat_future1 -# wrong constant name flat_future -# wrong constant name fulfilled? -# wrong constant name on_fulfillment -# wrong constant name on_fulfillment! -# wrong constant name on_fulfillment_using -# wrong constant name on_rejection -# wrong constant name on_rejection! -# wrong constant name on_rejection_using -# wrong constant name reason1 -# wrong constant name reason2 -# wrong constant name reason -# wrong constant name rejected? -# wrong constant name rescue -# wrong constant name rescue_on -# wrong constant name result1 -# wrong constant name result -# wrong constant name run1 -# wrong constant name run -# wrong constant name schedule -# wrong constant name then -# wrong constant name then_on -# wrong constant name to_event -# wrong constant name to_future -# wrong constant name value1 -# wrong constant name value2 -# wrong constant name value -# wrong constant name value!1 -# wrong constant name value!2 -# wrong constant name value! -# wrong constant name wait!1 -# wrong constant name wait! -# wrong constant name zip -# wrong constant name | -# wrong constant name -# wrong constant name # uninitialized constant Concurrent::Promises::Resolvable::PENDING # uninitialized constant Concurrent::Promises::Resolvable::RESERVED # uninitialized constant Concurrent::Promises::Resolvable::RESOLVED -# wrong constant name -# undefined method `resolve1' for class `Concurrent::Promises::ResolvableEvent' -# undefined method `resolve2' for class `Concurrent::Promises::ResolvableEvent' -# undefined method `wait1' for class `Concurrent::Promises::ResolvableEvent' -# undefined method `wait2' for class `Concurrent::Promises::ResolvableEvent' -# uninitialized constant Concurrent::Promises::ResolvableEvent::PENDING -# uninitialized constant Concurrent::Promises::ResolvableEvent::RESERVED -# uninitialized constant Concurrent::Promises::ResolvableEvent::RESOLVED -# wrong constant name resolve1 -# wrong constant name resolve2 -# wrong constant name resolve -# wrong constant name wait1 -# wrong constant name wait2 -# wrong constant name wait -# wrong constant name -# undefined method `fulfill1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `fulfill2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `reason1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `reason2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `reason3' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `reject1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `reject2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `resolve1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `resolve2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `resolve3' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `resolve4' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `resolve5' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `result1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `result2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value3' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value!1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value!2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `value!3' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `wait1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `wait2' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `wait!1' for class `Concurrent::Promises::ResolvableFuture' -# undefined method `wait!2' for class `Concurrent::Promises::ResolvableFuture' -# uninitialized constant Concurrent::Promises::ResolvableFuture::PENDING -# uninitialized constant Concurrent::Promises::ResolvableFuture::RESERVED -# uninitialized constant Concurrent::Promises::ResolvableFuture::RESOLVED -# wrong constant name evaluate_to -# wrong constant name evaluate_to! -# wrong constant name fulfill1 -# wrong constant name fulfill2 -# wrong constant name fulfill -# wrong constant name reason1 -# wrong constant name reason2 -# wrong constant name reason3 -# wrong constant name reason -# wrong constant name reject1 -# wrong constant name reject2 -# wrong constant name reject -# wrong constant name resolve1 -# wrong constant name resolve2 -# wrong constant name resolve3 -# wrong constant name resolve4 -# wrong constant name resolve5 -# wrong constant name resolve -# wrong constant name result1 -# wrong constant name result2 -# wrong constant name result -# wrong constant name value1 -# wrong constant name value2 -# wrong constant name value3 -# wrong constant name value -# wrong constant name value!1 -# wrong constant name value!2 -# wrong constant name value!3 -# wrong constant name value! -# wrong constant name wait1 -# wrong constant name wait2 -# wrong constant name wait -# wrong constant name wait!1 -# wrong constant name wait!2 -# wrong constant name wait! -# wrong constant name -# wrong constant name -# wrong constant name extended -# wrong constant name include -# wrong constant name included -# wrong constant name -# wrong constant name acquire_read_lock -# wrong constant name acquire_write_lock -# wrong constant name has_waiters? -# wrong constant name release_read_lock -# wrong constant name release_write_lock -# wrong constant name with_read_lock -# wrong constant name with_write_lock -# wrong constant name write_locked? -# wrong constant name -# wrong constant name new -# wrong constant name acquire_read_lock -# wrong constant name acquire_write_lock -# wrong constant name release_read_lock -# wrong constant name release_write_lock -# wrong constant name try_read_lock -# wrong constant name try_write_lock -# wrong constant name with_read_lock -# wrong constant name with_write_lock -# wrong constant name -# wrong constant name new -# wrong constant name -# wrong constant name -# wrong constant name compare_and_set_slot -# wrong constant name slot -# wrong constant name slot= -# wrong constant name swap_slot -# wrong constant name update_slot -# wrong constant name -# wrong constant name new -# uninitialized constant Concurrent::RubyExecutorService::DEBUG -# uninitialized constant Concurrent::RubyExecutorService::ERROR -# uninitialized constant Concurrent::RubyExecutorService::FALLBACK_POLICIES -# uninitialized constant Concurrent::RubyExecutorService::FATAL -# uninitialized constant Concurrent::RubyExecutorService::INFO -# uninitialized constant Concurrent::RubyExecutorService::UNKNOWN -# uninitialized constant Concurrent::RubyExecutorService::WARN -# wrong constant name initialize -# wrong constant name -# uninitialized constant Concurrent::RubySingleThreadExecutor::DEBUG -# uninitialized constant Concurrent::RubySingleThreadExecutor::DEFAULT_MAX_POOL_SIZE -# uninitialized constant Concurrent::RubySingleThreadExecutor::DEFAULT_MAX_QUEUE_SIZE -# uninitialized constant Concurrent::RubySingleThreadExecutor::DEFAULT_MIN_POOL_SIZE -# uninitialized constant Concurrent::RubySingleThreadExecutor::DEFAULT_THREAD_IDLETIMEOUT -# uninitialized constant Concurrent::RubySingleThreadExecutor::ERROR -# uninitialized constant Concurrent::RubySingleThreadExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::RubySingleThreadExecutor::FATAL -# uninitialized constant Concurrent::RubySingleThreadExecutor::INFO -# uninitialized constant Concurrent::RubySingleThreadExecutor::UNKNOWN -# uninitialized constant Concurrent::RubySingleThreadExecutor::WARN -# wrong constant name -# wrong constant name -# wrong constant name thread_finalizer -# wrong constant name thread_local_finalizer -# undefined method `initialize1' for class `Concurrent::RubyThreadPoolExecutor' -# uninitialized constant Concurrent::RubyThreadPoolExecutor::DEBUG -# uninitialized constant Concurrent::RubyThreadPoolExecutor::ERROR -# uninitialized constant Concurrent::RubyThreadPoolExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::RubyThreadPoolExecutor::FATAL -# uninitialized constant Concurrent::RubyThreadPoolExecutor::INFO -# uninitialized constant Concurrent::RubyThreadPoolExecutor::UNKNOWN -# uninitialized constant Concurrent::RubyThreadPoolExecutor::WARN -# wrong constant name completed_task_count -# wrong constant name idletime -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name largest_length -# wrong constant name length -# wrong constant name max_length -# wrong constant name max_queue -# wrong constant name min_length -# wrong constant name queue_length -# wrong constant name ready_worker -# wrong constant name remaining_capacity -# wrong constant name remove_busy_worker -# wrong constant name scheduled_task_count -# wrong constant name worker_died -# wrong constant name worker_not_old_enough -# wrong constant name worker_task_completed -# wrong constant name -# undefined method `initialize1' for class `Concurrent::SafeTaskExecutor' -# wrong constant name execute -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# undefined method `initialize1' for class `Concurrent::ScheduledTask' -# wrong constant name <=> -# wrong constant name cancel -# wrong constant name cancelled? -# wrong constant name execute -# wrong constant name executor -# wrong constant name initial_delay -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name ns_reschedule -# wrong constant name ns_schedule -# wrong constant name process_task -# wrong constant name processing? -# wrong constant name reschedule -# wrong constant name reset -# wrong constant name schedule_time -# undefined singleton method `execute1' for `Concurrent::ScheduledTask' -# wrong constant name -# wrong constant name execute1 -# wrong constant name execute -# wrong constant name -# uninitialized constant Concurrent::SerialExecutorService::DEBUG -# uninitialized constant Concurrent::SerialExecutorService::ERROR -# uninitialized constant Concurrent::SerialExecutorService::FATAL -# uninitialized constant Concurrent::SerialExecutorService::INFO -# uninitialized constant Concurrent::SerialExecutorService::UNKNOWN -# uninitialized constant Concurrent::SerialExecutorService::WARN -# wrong constant name serialized? -# wrong constant name -# uninitialized constant Concurrent::SerializedExecution::DEBUG -# uninitialized constant Concurrent::SerializedExecution::ERROR -# uninitialized constant Concurrent::SerializedExecution::FATAL -# uninitialized constant Concurrent::SerializedExecution::INFO -# wrong constant name -# uninitialized constant Concurrent::SerializedExecution::UNKNOWN -# uninitialized constant Concurrent::SerializedExecution::WARN -# wrong constant name initialize -# wrong constant name post -# wrong constant name posts -# uninitialized constant Concurrent::SerializedExecution::Job::Elem -# wrong constant name args -# wrong constant name args= -# wrong constant name block -# wrong constant name block= -# wrong constant name call -# wrong constant name executor -# wrong constant name executor= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# uninitialized constant DEBUG -# uninitialized constant ERROR -# uninitialized constant FATAL -# uninitialized constant INFO -# uninitialized constant UNKNOWN -# uninitialized constant WARN -# wrong constant name initialize -# wrong constant name -# uninitialized constant Concurrent::Set::Elem -# uninitialized constant Concurrent::Set::InspectKey -# wrong constant name -# wrong constant name == -# wrong constant name [] -# wrong constant name []= -# wrong constant name each -# wrong constant name each_pair -# wrong constant name inspect -# wrong constant name merge -# wrong constant name select -# wrong constant name to_a -# wrong constant name to_h -# wrong constant name to_s -# wrong constant name values -# wrong constant name values_at -# wrong constant name -# wrong constant name new -# uninitialized constant Concurrent::SimpleExecutorService::DEBUG -# uninitialized constant Concurrent::SimpleExecutorService::ERROR -# uninitialized constant Concurrent::SimpleExecutorService::FALLBACK_POLICIES -# uninitialized constant Concurrent::SimpleExecutorService::FATAL -# uninitialized constant Concurrent::SimpleExecutorService::INFO -# uninitialized constant Concurrent::SimpleExecutorService::UNKNOWN -# uninitialized constant Concurrent::SimpleExecutorService::WARN -# wrong constant name << -# wrong constant name -# wrong constant name post -# uninitialized constant Concurrent::SingleThreadExecutor::DEBUG -# uninitialized constant Concurrent::SingleThreadExecutor::DEFAULT_MAX_POOL_SIZE -# uninitialized constant Concurrent::SingleThreadExecutor::DEFAULT_MAX_QUEUE_SIZE -# uninitialized constant Concurrent::SingleThreadExecutor::DEFAULT_MIN_POOL_SIZE -# uninitialized constant Concurrent::SingleThreadExecutor::DEFAULT_THREAD_IDLETIMEOUT -# uninitialized constant Concurrent::SingleThreadExecutor::ERROR -# uninitialized constant Concurrent::SingleThreadExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::SingleThreadExecutor::FATAL -# uninitialized constant Concurrent::SingleThreadExecutor::INFO -# uninitialized constant Concurrent::SingleThreadExecutor::UNKNOWN -# uninitialized constant Concurrent::SingleThreadExecutor::WARN -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `ns_wait1' for class `Concurrent::Synchronization::AbstractLockableObject' -# undefined method `ns_wait_until1' for class `Concurrent::Synchronization::AbstractLockableObject' -# wrong constant name ns_broadcast -# wrong constant name ns_signal -# wrong constant name ns_wait1 -# wrong constant name ns_wait -# wrong constant name ns_wait_until1 -# wrong constant name ns_wait_until -# wrong constant name synchronize -# wrong constant name -# wrong constant name full_memory_barrier -# wrong constant name -# wrong constant name attr_volatile -# wrong constant name initialize -# wrong constant name length -# wrong constant name members -# wrong constant name ns_each -# wrong constant name ns_each_pair -# wrong constant name ns_equality -# wrong constant name ns_get -# wrong constant name ns_initialize_copy -# wrong constant name ns_inspect -# wrong constant name ns_merge -# wrong constant name ns_select -# wrong constant name ns_to_h -# wrong constant name ns_values -# wrong constant name ns_values_at -# wrong constant name pr_underscore -# wrong constant name size -# wrong constant name -# wrong constant name define_struct_class -# undefined method `wait1' for class `Concurrent::Synchronization::Condition' -# undefined method `wait_until1' for class `Concurrent::Synchronization::Condition' -# wrong constant name broadcast -# wrong constant name initialize -# wrong constant name signal -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name wait_until1 -# wrong constant name wait_until -# wrong constant name -# wrong constant name private_new -# wrong constant name ns_broadcast -# wrong constant name ns_signal -# wrong constant name -# undefined method `wait1' for class `Concurrent::Synchronization::Lock' -# undefined method `wait_until1' for class `Concurrent::Synchronization::Lock' -# wrong constant name broadcast -# wrong constant name signal -# wrong constant name wait1 -# wrong constant name wait -# wrong constant name wait_until1 -# wrong constant name wait_until -# wrong constant name -# wrong constant name new_condition -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name new -# wrong constant name full_memory_barrier -# wrong constant name -# wrong constant name included -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name new -# undefined singleton method `atomic_attributes1' for `Concurrent::Synchronization::Object' -# wrong constant name -# wrong constant name atomic_attribute? -# wrong constant name atomic_attributes1 -# wrong constant name atomic_attributes -# wrong constant name attr_atomic -# wrong constant name ensure_safe_initialization_when_final_fields_are_present -# wrong constant name safe_initialization! -# wrong constant name safe_initialization? -# wrong constant name -# wrong constant name full_memory_barrier -# wrong constant name attr_volatile -# wrong constant name -# wrong constant name -# wrong constant name included -# wrong constant name initialize -# wrong constant name synchronize -# wrong constant name -# wrong constant name new -# wrong constant name -# wrong constant name -# wrong constant name full_memory_barrier -# wrong constant name attr_volatile -# wrong constant name -# wrong constant name -# wrong constant name included -# wrong constant name -# wrong constant name -# wrong constant name method_missing -# wrong constant name setup -# wrong constant name teardown -# wrong constant name -# wrong constant name initialize -# wrong constant name unsafe_increment_version -# wrong constant name unsafe_lock -# wrong constant name unsafe_value -# wrong constant name unsafe_value= -# wrong constant name unsafe_version -# wrong constant name value -# wrong constant name value= -# wrong constant name -# wrong constant name new -# wrong constant name -# uninitialized constant Concurrent::ThreadPoolExecutor::DEBUG -# uninitialized constant Concurrent::ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE -# uninitialized constant Concurrent::ThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE -# uninitialized constant Concurrent::ThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE -# uninitialized constant Concurrent::ThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT -# uninitialized constant Concurrent::ThreadPoolExecutor::ERROR -# uninitialized constant Concurrent::ThreadPoolExecutor::FALLBACK_POLICIES -# uninitialized constant Concurrent::ThreadPoolExecutor::FATAL -# uninitialized constant Concurrent::ThreadPoolExecutor::INFO -# uninitialized constant Concurrent::ThreadPoolExecutor::UNKNOWN -# uninitialized constant Concurrent::ThreadPoolExecutor::WARN -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Concurrent::TimerSet' -# uninitialized constant Concurrent::TimerSet::DEBUG -# uninitialized constant Concurrent::TimerSet::ERROR -# uninitialized constant Concurrent::TimerSet::FALLBACK_POLICIES -# uninitialized constant Concurrent::TimerSet::FATAL -# uninitialized constant Concurrent::TimerSet::INFO -# uninitialized constant Concurrent::TimerSet::UNKNOWN -# uninitialized constant Concurrent::TimerSet::WARN -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name post -# wrong constant name -# undefined method `initialize1' for class `Concurrent::TimerTask' -# uninitialized constant Concurrent::TimerTask::DEBUG -# uninitialized constant Concurrent::TimerTask::ERROR -# uninitialized constant Concurrent::TimerTask::FALLBACK_POLICIES -# uninitialized constant Concurrent::TimerTask::FATAL -# uninitialized constant Concurrent::TimerTask::INFO -# uninitialized constant Concurrent::TimerTask::UNKNOWN -# uninitialized constant Concurrent::TimerTask::WARN -# wrong constant name execute -# wrong constant name execution_interval -# wrong constant name execution_interval= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name timeout_interval -# wrong constant name timeout_interval= -# undefined singleton method `execute1' for `Concurrent::TimerTask' -# wrong constant name -# wrong constant name execute1 -# wrong constant name execute -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name abort -# wrong constant name commit -# wrong constant name read -# wrong constant name unlock -# wrong constant name valid? -# wrong constant name write -# wrong constant name -# wrong constant name -# uninitialized constant Concurrent::Transaction::ReadLogEntry::Elem -# wrong constant name tvar -# wrong constant name tvar= -# wrong constant name version -# wrong constant name version= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name current -# wrong constant name current= -# uninitialized constant Concurrent::Tuple::Elem -# wrong constant name cas -# wrong constant name compare_and_set -# wrong constant name each -# wrong constant name get -# wrong constant name initialize -# wrong constant name set -# wrong constant name size -# wrong constant name volatile_get -# wrong constant name volatile_set -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `ruby_version1' for module `Concurrent::Utility::EngineDetector' -# wrong constant name on_cruby? -# wrong constant name on_jruby? -# wrong constant name on_jruby_9000? -# wrong constant name on_linux? -# wrong constant name on_osx? -# wrong constant name on_rbx? -# wrong constant name on_truffleruby? -# wrong constant name on_windows? -# wrong constant name ruby_engine -# wrong constant name ruby_version1 -# wrong constant name ruby_version -# wrong constant name -# wrong constant name allow_c_extensions? -# wrong constant name c_extensions_loaded? -# wrong constant name java_extensions_loaded? -# wrong constant name load_native_extensions -# wrong constant name -# wrong constant name ensure_integer -# wrong constant name ensure_integer_and_bounds -# wrong constant name ensure_lower_bound -# wrong constant name ensure_positive -# wrong constant name ensure_positive_and_no_zero -# wrong constant name ensure_upper_bound -# wrong constant name -# wrong constant name physical_processor_count -# wrong constant name processor_count -# wrong constant name -# wrong constant name -# undefined singleton method `create_simple_logger1' for `Concurrent' -# undefined singleton method `create_simple_logger2' for `Concurrent' -# undefined singleton method `create_stdlib_logger1' for `Concurrent' -# undefined singleton method `create_stdlib_logger2' for `Concurrent' -# undefined singleton method `new_fast_executor1' for `Concurrent' -# undefined singleton method `new_io_executor1' for `Concurrent' -# undefined singleton method `use_simple_logger1' for `Concurrent' -# undefined singleton method `use_simple_logger2' for `Concurrent' -# undefined singleton method `use_stdlib_logger1' for `Concurrent' -# undefined singleton method `use_stdlib_logger2' for `Concurrent' -# wrong constant name -# wrong constant name abort_transaction -# wrong constant name atomically -# wrong constant name call_dataflow -# wrong constant name create_simple_logger1 -# wrong constant name create_simple_logger2 -# wrong constant name create_simple_logger -# wrong constant name create_stdlib_logger1 -# wrong constant name create_stdlib_logger2 -# wrong constant name create_stdlib_logger -# wrong constant name dataflow -# wrong constant name dataflow! -# wrong constant name dataflow_with -# wrong constant name dataflow_with! -# wrong constant name disable_at_exit_handlers! -# wrong constant name executor -# wrong constant name global_fast_executor -# wrong constant name global_immediate_executor -# wrong constant name global_io_executor -# wrong constant name global_logger -# wrong constant name global_logger= -# wrong constant name global_timer_set -# wrong constant name leave_transaction -# wrong constant name monotonic_time -# wrong constant name new_fast_executor1 -# wrong constant name new_fast_executor -# wrong constant name new_io_executor1 -# wrong constant name new_io_executor -# wrong constant name physical_processor_count -# wrong constant name processor_count -# wrong constant name processor_counter -# wrong constant name use_simple_logger1 -# wrong constant name use_simple_logger2 -# wrong constant name use_simple_logger -# wrong constant name use_stdlib_logger1 -# wrong constant name use_stdlib_logger2 -# wrong constant name use_stdlib_logger # uninitialized constant Configatron # uninitialized constant Configatron -# undefined method `checkout1' for class `ConnectionPool' -# undefined method `initialize1' for class `ConnectionPool' -# undefined method `with1' for class `ConnectionPool' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name available -# wrong constant name checkin -# wrong constant name checkout1 -# wrong constant name checkout -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name shutdown -# wrong constant name size -# wrong constant name with1 -# wrong constant name with -# wrong constant name -# wrong constant name -# undefined method `<<1' for class `ConnectionPool::TimedStack' -# undefined method `initialize1' for class `ConnectionPool::TimedStack' -# undefined method `pop1' for class `ConnectionPool::TimedStack' -# undefined method `pop2' for class `ConnectionPool::TimedStack' -# undefined method `push1' for class `ConnectionPool::TimedStack' -# wrong constant name <<1 -# wrong constant name << -# wrong constant name empty? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name length -# wrong constant name max -# wrong constant name pop1 -# wrong constant name pop2 -# wrong constant name pop -# wrong constant name push1 -# wrong constant name push -# wrong constant name shutdown -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ConnectionPool::Wrapper' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name pool_available -# wrong constant name pool_shutdown -# wrong constant name pool_size -# wrong constant name respond_to? -# wrong constant name with -# wrong constant name wrapped_pool -# wrong constant name -# wrong constant name -# wrong constant name wrap # uninitialized constant Continuation # uninitialized constant Continuation # undefined method `autocorrect_source1' for module `CopHelper' @@ -5792,43 +4198,6 @@ # wrong constant name dsl_eval # wrong constant name dsl_eval_immutable # wrong constant name dsl_eval_with_block_return -# undefined method `cookie_domain?1' for class `DomainName' -# wrong constant name < -# wrong constant name <= -# wrong constant name <=> -# wrong constant name == -# wrong constant name > -# wrong constant name >= -# wrong constant name -# wrong constant name canonical? -# wrong constant name canonical_tld? -# wrong constant name cookie_domain?1 -# wrong constant name cookie_domain? -# wrong constant name domain -# wrong constant name domain_idn -# wrong constant name hostname -# wrong constant name hostname_idn -# wrong constant name idn -# wrong constant name initialize -# wrong constant name ipaddr -# wrong constant name ipaddr? -# wrong constant name superdomain -# wrong constant name tld -# wrong constant name tld_idn -# wrong constant name to_str -# wrong constant name uri_host -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name decode -# wrong constant name decode_hostname -# wrong constant name encode -# wrong constant name encode_hostname -# wrong constant name -# wrong constant name etld_data -# wrong constant name normalize # undefined method `def_method1' for class `ERB' # undefined method `def_module1' for class `ERB' # undefined method `initialize4' for class `ERB' @@ -5965,12 +4334,6 @@ # uninitialized constant FileUtils::DryRun::VERSION # uninitialized constant FileUtils::NoWrite::VERSION # uninitialized constant FileUtils::Verbose::VERSION -# uninitialized constant Float::EXABYTE -# uninitialized constant Float::GIGABYTE -# uninitialized constant Float::KILOBYTE -# uninitialized constant Float::MEGABYTE -# uninitialized constant Float::PETABYTE -# uninitialized constant Float::TERABYTE # wrong constant name [] # wrong constant name members # wrong constant name _compile_method @@ -6336,123 +4699,9 @@ # wrong constant name # uninitialized constant GetoptLong # uninitialized constant GetoptLong -# wrong constant name -# wrong constant name -# undefined method `expired?1' for class `HTTP::Cookie' -# wrong constant name <=> -# wrong constant name -# wrong constant name acceptable? -# wrong constant name acceptable_from_uri? -# wrong constant name accessed_at -# wrong constant name accessed_at= -# wrong constant name cookie_value -# wrong constant name created_at -# wrong constant name created_at= -# wrong constant name domain -# wrong constant name domain= -# wrong constant name domain_name -# wrong constant name dot_domain -# wrong constant name encode_with -# wrong constant name expire! -# wrong constant name expired?1 -# wrong constant name expired? -# wrong constant name expires -# wrong constant name expires= -# wrong constant name expires_at -# wrong constant name expires_at= -# wrong constant name for_domain -# wrong constant name for_domain= -# wrong constant name for_domain? -# wrong constant name httponly -# wrong constant name httponly= -# wrong constant name httponly? -# wrong constant name init_with -# wrong constant name initialize -# wrong constant name max_age -# wrong constant name max_age= -# wrong constant name name -# wrong constant name name= -# wrong constant name origin -# wrong constant name origin= -# wrong constant name path -# wrong constant name path= -# wrong constant name secure -# wrong constant name secure= -# wrong constant name secure? -# wrong constant name session -# wrong constant name session? -# wrong constant name set_cookie_value -# wrong constant name to_yaml_properties -# wrong constant name valid_for_uri? -# wrong constant name value -# wrong constant name value= -# wrong constant name yaml_initialize -# undefined method `initialize1' for class `HTTP::Cookie::Scanner' -# undefined method `scan_name_value1' for class `HTTP::Cookie::Scanner' -# undefined method `scan_value1' for class `HTTP::Cookie::Scanner' -# uninitialized constant HTTP::Cookie::Scanner::Id -# uninitialized constant HTTP::Cookie::Scanner::Version -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name parse_cookie_date -# wrong constant name scan_cookie -# wrong constant name scan_dquoted -# wrong constant name scan_name -# wrong constant name scan_name_value1 -# wrong constant name scan_name_value -# wrong constant name scan_set_cookie -# wrong constant name scan_value1 -# wrong constant name scan_value -# wrong constant name skip_wsp -# wrong constant name -# wrong constant name quote # undefined singleton method `parse1' for `HTTP::Cookie' -# wrong constant name -# wrong constant name cookie_value -# wrong constant name cookie_value_to_hash # wrong constant name parse1 # wrong constant name parse -# wrong constant name path_match? -# undefined method `cleanup1' for class `HTTP::CookieJar' -# undefined method `cookies1' for class `HTTP::CookieJar' -# undefined method `each1' for class `HTTP::CookieJar' -# undefined method `empty?1' for class `HTTP::CookieJar' -# undefined method `initialize1' for class `HTTP::CookieJar' -# undefined method `parse1' for class `HTTP::CookieJar' -# wrong constant name << -# wrong constant name -# no implicit conversion of nil into String -# wrong constant name -# wrong constant name cleanup1 -# wrong constant name cleanup -# wrong constant name clear -# wrong constant name cookies1 -# wrong constant name cookies -# wrong constant name delete -# wrong constant name each1 -# wrong constant name each -# wrong constant name empty?1 -# wrong constant name empty? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name load -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name save -# wrong constant name store -# undefined method `initialize1' for class `HTTP::CookieJar::AbstractSaver' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name load -# wrong constant name save -# wrong constant name -# wrong constant name class_to_symbol -# wrong constant name implementation -# wrong constant name inherited -# wrong constant name -# wrong constant name -# wrong constant name const_missing -# wrong constant name # wrong constant name lm? # undefined method `to_param1' for class `Hash' # undefined method `to_query1' for class `Hash' @@ -8025,17 +6274,10 @@ # wrong constant name members # wrong constant name [] # wrong constant name members -# undefined method `remote_byebug1' for module `Kernel' -# undefined method `remote_byebug2' for module `Kernel' -# wrong constant name byebug # wrong constant name class_eval -# wrong constant name debugger # wrong constant name itself # wrong constant name object_id # wrong constant name pretty_inspect -# wrong constant name remote_byebug1 -# wrong constant name remote_byebug2 -# wrong constant name remote_byebug # wrong constant name then # wrong constant name yield_self # wrong constant name at_exit @@ -8047,212 +6289,6 @@ # wrong constant name is_missing? # uninitialized constant Logger::LogDevice::SiD # wrong constant name -# wrong constant name -# wrong constant name -# undefined method `friendly1' for class `MIME::Type' -# wrong constant name <=> -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name add_extensions -# wrong constant name ascii? -# wrong constant name binary? -# wrong constant name complete? -# wrong constant name content_type -# wrong constant name default_encoding -# wrong constant name docs -# wrong constant name docs= -# wrong constant name encode_with -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name eql? -# wrong constant name extensions -# wrong constant name extensions= -# wrong constant name friendly1 -# wrong constant name friendly -# wrong constant name i18n_key -# wrong constant name init_with -# wrong constant name initialize -# wrong constant name like? -# wrong constant name media_type -# wrong constant name obsolete -# wrong constant name obsolete= -# wrong constant name obsolete? -# wrong constant name preferred_extension -# wrong constant name preferred_extension= -# wrong constant name priority_compare -# wrong constant name raw_media_type -# wrong constant name raw_sub_type -# wrong constant name registered -# wrong constant name registered= -# wrong constant name registered? -# wrong constant name signature -# wrong constant name signature= -# wrong constant name signature? -# wrong constant name simplified -# wrong constant name sub_type -# wrong constant name to_h -# wrong constant name to_json -# wrong constant name to_str -# wrong constant name use_instead -# wrong constant name use_instead= -# wrong constant name xref_urls -# wrong constant name xrefs -# wrong constant name xrefs= -# uninitialized constant MIME::Type::Columnar::VERSION -# wrong constant name docs -# wrong constant name docs= -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name friendly -# wrong constant name initialize -# wrong constant name obsolete -# wrong constant name obsolete= -# wrong constant name obsolete? -# wrong constant name preferred_extension -# wrong constant name preferred_extension= -# wrong constant name registered -# wrong constant name registered= -# wrong constant name registered? -# wrong constant name signature -# wrong constant name signature= -# wrong constant name signature? -# wrong constant name use_instead -# wrong constant name use_instead= -# wrong constant name xref_urls -# wrong constant name xrefs -# wrong constant name xrefs= -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# undefined singleton method `simplified1' for `MIME::Type' -# wrong constant name -# wrong constant name i18n_key -# wrong constant name match -# wrong constant name simplified1 -# wrong constant name simplified -# undefined method `[]1' for class `MIME::Types' -# undefined method `[]2' for class `MIME::Types' -# undefined method `add_type1' for class `MIME::Types' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant MIME::Types::Elem -# wrong constant name -# wrong constant name -# wrong constant name []1 -# wrong constant name []2 -# wrong constant name [] -# wrong constant name add -# wrong constant name add_type1 -# wrong constant name add_type -# wrong constant name count -# wrong constant name each -# wrong constant name of -# wrong constant name type_for -# uninitialized constant MIME::Types::Cache::Elem -# wrong constant name data -# wrong constant name data= -# wrong constant name version -# wrong constant name version= -# undefined singleton method `load1' for `MIME::Types::Cache' -# undefined singleton method `save1' for `MIME::Types::Cache' -# undefined singleton method `save2' for `MIME::Types::Cache' -# wrong constant name -# wrong constant name [] -# wrong constant name load1 -# wrong constant name load -# wrong constant name members -# wrong constant name save1 -# wrong constant name save2 -# wrong constant name save -# wrong constant name load_base_data -# wrong constant name -# wrong constant name extended -# undefined method `initialize1' for class `MIME::Types::Container' -# wrong constant name == -# wrong constant name [] -# wrong constant name []= -# wrong constant name add -# wrong constant name container -# wrong constant name container= -# wrong constant name count -# wrong constant name each -# wrong constant name each_value -# wrong constant name empty? -# wrong constant name encode_with -# wrong constant name flat_map -# wrong constant name init_with -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name keys -# wrong constant name marshal_dump -# wrong constant name marshal_load -# wrong constant name merge -# wrong constant name merge! -# wrong constant name normalize -# wrong constant name select -# wrong constant name to_hash -# wrong constant name values -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `MIME::Types::Loader' -# undefined method `initialize2' for class `MIME::Types::Loader' -# undefined method `load1' for class `MIME::Types::Loader' -# wrong constant name container -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name load1 -# wrong constant name load -# wrong constant name load_columnar -# wrong constant name load_json -# wrong constant name load_yaml -# wrong constant name path -# undefined singleton method `load1' for `MIME::Types::Loader' -# wrong constant name -# wrong constant name load1 -# wrong constant name load -# wrong constant name load_from_json -# wrong constant name load_from_yaml -# undefined method `initialize1' for class `MIME::Types::WarnLogger' -# undefined method `initialize2' for class `MIME::Types::WarnLogger' -# uninitialized constant MIME::Types::WarnLogger::DEBUG -# uninitialized constant MIME::Types::WarnLogger::ERROR -# uninitialized constant MIME::Types::WarnLogger::FATAL -# uninitialized constant MIME::Types::WarnLogger::INFO -# uninitialized constant MIME::Types::WarnLogger::ProgName -# uninitialized constant MIME::Types::WarnLogger::SEV_LABEL -# uninitialized constant MIME::Types::WarnLogger::UNKNOWN -# uninitialized constant MIME::Types::WarnLogger::VERSION -# uninitialized constant MIME::Types::WarnLogger::WARN -# wrong constant name -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# uninitialized constant MIME::Types::WarnLogger::WarnLogDevice::SiD -# wrong constant name initialize -# wrong constant name write -# wrong constant name -# wrong constant name -# undefined singleton method `[]1' for `MIME::Types' -# undefined singleton method `[]2' for `MIME::Types' -# wrong constant name -# uninitialized constant MIME::Types::Elem -# wrong constant name []1 -# wrong constant name []2 -# wrong constant name [] -# wrong constant name add -# wrong constant name count -# wrong constant name each -# wrong constant name logger -# wrong constant name logger= -# wrong constant name of -# wrong constant name type_for -# wrong constant name # wrong constant name # wrong constant name # wrong constant name @@ -8831,1169 +6867,6 @@ # wrong constant name rpaths # uninitialized constant Matrix # uninitialized constant Matrix -# undefined method `add_auth1' for class `Mechanize' -# undefined method `add_auth2' for class `Mechanize' -# undefined method `auth1' for class `Mechanize' -# undefined method `basic_auth1' for class `Mechanize' -# undefined method `delete1' for class `Mechanize' -# undefined method `delete2' for class `Mechanize' -# undefined method `download1' for class `Mechanize' -# undefined method `download2' for class `Mechanize' -# undefined method `download3' for class `Mechanize' -# undefined method `get1' for class `Mechanize' -# undefined method `get2' for class `Mechanize' -# undefined method `get3' for class `Mechanize' -# undefined method `head1' for class `Mechanize' -# undefined method `head2' for class `Mechanize' -# undefined method `initialize1' for class `Mechanize' -# undefined method `post1' for class `Mechanize' -# undefined method `post2' for class `Mechanize' -# undefined method `put1' for class `Mechanize' -# undefined method `request_with_entity1' for class `Mechanize' -# undefined method `set_proxy1' for class `Mechanize' -# undefined method `set_proxy2' for class `Mechanize' -# undefined method `submit1' for class `Mechanize' -# undefined method `submit2' for class `Mechanize' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name add_auth1 -# wrong constant name add_auth2 -# wrong constant name add_auth -# wrong constant name agent -# wrong constant name auth1 -# wrong constant name auth -# wrong constant name back -# wrong constant name basic_auth1 -# wrong constant name basic_auth -# wrong constant name ca_file -# wrong constant name ca_file= -# wrong constant name cert -# wrong constant name cert= -# wrong constant name cert_store -# wrong constant name cert_store= -# wrong constant name certificate -# wrong constant name click -# wrong constant name conditional_requests -# wrong constant name conditional_requests= -# wrong constant name content_encoding_hooks -# wrong constant name cookie_jar -# wrong constant name cookie_jar= -# wrong constant name cookies -# wrong constant name current_page -# wrong constant name default_encoding -# wrong constant name default_encoding= -# wrong constant name delete1 -# wrong constant name delete2 -# wrong constant name delete -# wrong constant name download1 -# wrong constant name download2 -# wrong constant name download3 -# wrong constant name download -# wrong constant name follow_meta_refresh -# wrong constant name follow_meta_refresh= -# wrong constant name follow_meta_refresh_self -# wrong constant name follow_meta_refresh_self= -# wrong constant name follow_redirect= -# wrong constant name follow_redirect? -# wrong constant name force_default_encoding -# wrong constant name force_default_encoding= -# wrong constant name get1 -# wrong constant name get2 -# wrong constant name get3 -# wrong constant name get -# wrong constant name get_file -# wrong constant name gzip_enabled -# wrong constant name gzip_enabled= -# wrong constant name head1 -# wrong constant name head2 -# wrong constant name head -# wrong constant name history -# wrong constant name history_added -# wrong constant name history_added= -# wrong constant name html_parser -# wrong constant name html_parser= -# wrong constant name idle_timeout -# wrong constant name idle_timeout= -# wrong constant name ignore_bad_chunking -# wrong constant name ignore_bad_chunking= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name keep_alive -# wrong constant name keep_alive= -# wrong constant name keep_alive_time -# wrong constant name keep_alive_time= -# wrong constant name key -# wrong constant name key= -# wrong constant name log -# wrong constant name log= -# wrong constant name max_file_buffer -# wrong constant name max_file_buffer= -# wrong constant name max_history -# wrong constant name max_history= -# wrong constant name open_timeout -# wrong constant name open_timeout= -# wrong constant name page -# wrong constant name parse -# wrong constant name pass -# wrong constant name pass= -# wrong constant name pluggable_parser -# wrong constant name post1 -# wrong constant name post2 -# wrong constant name post -# wrong constant name post_connect_hooks -# wrong constant name pre_connect_hooks -# wrong constant name proxy_addr -# wrong constant name proxy_pass -# wrong constant name proxy_port -# wrong constant name proxy_user -# wrong constant name put1 -# wrong constant name put -# wrong constant name read_timeout -# wrong constant name read_timeout= -# wrong constant name redirect_ok -# wrong constant name redirect_ok= -# wrong constant name redirection_limit -# wrong constant name redirection_limit= -# wrong constant name request_headers -# wrong constant name request_headers= -# wrong constant name request_with_entity1 -# wrong constant name request_with_entity -# wrong constant name reset -# wrong constant name resolve -# wrong constant name retry_change_requests -# wrong constant name retry_change_requests= -# wrong constant name robots -# wrong constant name robots= -# wrong constant name scheme_handlers -# wrong constant name scheme_handlers= -# wrong constant name set_proxy1 -# wrong constant name set_proxy2 -# wrong constant name set_proxy -# wrong constant name shutdown -# wrong constant name ssl_version -# wrong constant name ssl_version= -# wrong constant name submit1 -# wrong constant name submit2 -# wrong constant name submit -# wrong constant name transact -# wrong constant name user_agent -# wrong constant name user_agent= -# wrong constant name user_agent_alias= -# wrong constant name verify_callback -# wrong constant name verify_callback= -# wrong constant name verify_mode -# wrong constant name verify_mode= -# wrong constant name visited? -# wrong constant name visited_page -# wrong constant name watch_for_set -# wrong constant name watch_for_set= -# wrong constant name -# wrong constant name content_type -# wrong constant name initialize -# wrong constant name -# undefined method `parse1' for module `Mechanize::CookieCMethods' -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name -# wrong constant name -# wrong constant name set_domain -# wrong constant name -# no implicit conversion of nil into String -# wrong constant name load -# wrong constant name save -# wrong constant name -# undefined method `add1' for module `Mechanize::CookieJarIMethods' -# wrong constant name add1 -# wrong constant name add -# wrong constant name add! -# wrong constant name clear! -# wrong constant name dump_cookiestxt -# wrong constant name jar -# wrong constant name load_cookiestxt -# wrong constant name save_as -# wrong constant name -# uninitialized constant Mechanize::DirectorySaver::SPECIAL_FILENAMES -# undefined singleton method `save_to1' for `Mechanize::DirectorySaver' -# wrong constant name -# wrong constant name decode_filename? -# wrong constant name directory -# wrong constant name overwrite? -# wrong constant name save_to1 -# wrong constant name save_to -# undefined method `initialize1' for class `Mechanize::Download' -# undefined method `initialize2' for class `Mechanize::Download' -# undefined method `initialize3' for class `Mechanize::Download' -# undefined method `initialize4' for class `Mechanize::Download' -# undefined method `save1' for class `Mechanize::Download' -# undefined method `save!1' for class `Mechanize::Download' -# undefined method `save_as1' for class `Mechanize::Download' -# uninitialized constant Mechanize::Download::SPECIAL_FILENAMES -# wrong constant name body -# wrong constant name body_io -# wrong constant name content -# wrong constant name filename -# wrong constant name filename= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize -# wrong constant name save1 -# wrong constant name save -# wrong constant name save!1 -# wrong constant name save! -# wrong constant name save_as1 -# wrong constant name save_as -# wrong constant name -# undefined method `elements_with1' for module `Mechanize::ElementMatcher' -# wrong constant name elements_with1 -# wrong constant name elements_with -# wrong constant name -# wrong constant name conditions -# wrong constant name element -# wrong constant name initialize -# wrong constant name source -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Mechanize::File' -# undefined method `initialize2' for class `Mechanize::File' -# undefined method `initialize3' for class `Mechanize::File' -# undefined method `initialize4' for class `Mechanize::File' -# undefined method `save1' for class `Mechanize::File' -# undefined method `save!1' for class `Mechanize::File' -# undefined method `save_as1' for class `Mechanize::File' -# uninitialized constant Mechanize::File::SPECIAL_FILENAMES -# wrong constant name body -# wrong constant name body= -# wrong constant name content -# wrong constant name filename -# wrong constant name filename= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize -# wrong constant name save1 -# wrong constant name save -# wrong constant name save!1 -# wrong constant name save! -# wrong constant name save_as1 -# wrong constant name save_as -# wrong constant name -# wrong constant name request -# wrong constant name -# wrong constant name new -# wrong constant name []= -# wrong constant name add_field -# wrong constant name each_header -# wrong constant name initialize -# wrong constant name path -# wrong constant name response_body_permitted? -# wrong constant name uri -# wrong constant name uri= -# wrong constant name -# wrong constant name [] -# wrong constant name code -# wrong constant name content_length -# wrong constant name each -# wrong constant name each_header -# wrong constant name get_fields -# wrong constant name http_version -# wrong constant name initialize -# wrong constant name message -# wrong constant name read_body -# wrong constant name uri -# wrong constant name -# uninitialized constant Mechanize::FileSaver::SPECIAL_FILENAMES -# wrong constant name -# undefined method `add_field!1' for class `Mechanize::Form' -# undefined method `build_query1' for class `Mechanize::Form' -# undefined method `button1' for class `Mechanize::Form' -# undefined method `button_with1' for class `Mechanize::Form' -# undefined method `button_with!1' for class `Mechanize::Form' -# undefined method `buttons_with1' for class `Mechanize::Form' -# undefined method `checkbox1' for class `Mechanize::Form' -# undefined method `checkbox_with1' for class `Mechanize::Form' -# undefined method `checkbox_with!1' for class `Mechanize::Form' -# undefined method `checkboxes_with1' for class `Mechanize::Form' -# undefined method `click_button1' for class `Mechanize::Form' -# undefined method `field1' for class `Mechanize::Form' -# undefined method `field_with1' for class `Mechanize::Form' -# undefined method `field_with!1' for class `Mechanize::Form' -# undefined method `fields_with1' for class `Mechanize::Form' -# undefined method `file_upload1' for class `Mechanize::Form' -# undefined method `file_upload_with1' for class `Mechanize::Form' -# undefined method `file_upload_with!1' for class `Mechanize::Form' -# undefined method `file_uploads_with1' for class `Mechanize::Form' -# undefined method `initialize1' for class `Mechanize::Form' -# undefined method `initialize2' for class `Mechanize::Form' -# undefined method `radiobutton1' for class `Mechanize::Form' -# undefined method `radiobutton_with1' for class `Mechanize::Form' -# undefined method `radiobutton_with!1' for class `Mechanize::Form' -# undefined method `radiobuttons_with1' for class `Mechanize::Form' -# undefined method `select_buttons1' for class `Mechanize::Form' -# undefined method `select_checkboxes1' for class `Mechanize::Form' -# undefined method `select_fields1' for class `Mechanize::Form' -# undefined method `select_file_uploads1' for class `Mechanize::Form' -# undefined method `select_radiobuttons1' for class `Mechanize::Form' -# undefined method `set_fields1' for class `Mechanize::Form' -# undefined method `submit1' for class `Mechanize::Form' -# undefined method `submit2' for class `Mechanize::Form' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name [] -# wrong constant name []= -# wrong constant name action -# wrong constant name action= -# wrong constant name add_button_to_query -# wrong constant name add_field!1 -# wrong constant name add_field! -# wrong constant name at -# wrong constant name at_css -# wrong constant name at_xpath -# wrong constant name build_query1 -# wrong constant name build_query -# wrong constant name button1 -# wrong constant name button -# wrong constant name button_with1 -# wrong constant name button_with -# wrong constant name button_with!1 -# wrong constant name button_with! -# wrong constant name buttons -# wrong constant name buttons_with1 -# wrong constant name buttons_with -# wrong constant name checkbox1 -# wrong constant name checkbox -# wrong constant name checkbox_with1 -# wrong constant name checkbox_with -# wrong constant name checkbox_with!1 -# wrong constant name checkbox_with! -# wrong constant name checkboxes -# wrong constant name checkboxes_with1 -# wrong constant name checkboxes_with -# wrong constant name click_button1 -# wrong constant name click_button -# wrong constant name css -# wrong constant name delete_field! -# wrong constant name dom_class -# wrong constant name dom_id -# wrong constant name elements -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name enctype -# wrong constant name enctype= -# wrong constant name field1 -# wrong constant name field -# wrong constant name field_with1 -# wrong constant name field_with -# wrong constant name field_with!1 -# wrong constant name field_with! -# wrong constant name fields -# wrong constant name fields_with1 -# wrong constant name fields_with -# wrong constant name file_upload1 -# wrong constant name file_upload -# wrong constant name file_upload_with1 -# wrong constant name file_upload_with -# wrong constant name file_upload_with!1 -# wrong constant name file_upload_with! -# wrong constant name file_uploads -# wrong constant name file_uploads_with1 -# wrong constant name file_uploads_with -# wrong constant name form_node -# wrong constant name has_field? -# wrong constant name has_key? -# wrong constant name has_value? -# wrong constant name hidden_field? -# wrong constant name hiddens -# wrong constant name ignore_encoding_error -# wrong constant name ignore_encoding_error= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name keygens -# wrong constant name keys -# wrong constant name method -# wrong constant name method= -# wrong constant name method_missing -# wrong constant name name -# wrong constant name name= -# wrong constant name node -# wrong constant name page -# wrong constant name radiobutton1 -# wrong constant name radiobutton -# wrong constant name radiobutton_with1 -# wrong constant name radiobutton_with -# wrong constant name radiobutton_with!1 -# wrong constant name radiobutton_with! -# wrong constant name radiobuttons -# wrong constant name radiobuttons_with1 -# wrong constant name radiobuttons_with -# wrong constant name request_data -# wrong constant name reset -# wrong constant name reset_button? -# wrong constant name resets -# wrong constant name save_hash_field_order -# wrong constant name search -# wrong constant name select_buttons1 -# wrong constant name select_buttons -# wrong constant name select_checkboxes1 -# wrong constant name select_checkboxes -# wrong constant name select_fields1 -# wrong constant name select_fields -# wrong constant name select_file_uploads1 -# wrong constant name select_file_uploads -# wrong constant name select_radiobuttons1 -# wrong constant name select_radiobuttons -# wrong constant name set_fields1 -# wrong constant name set_fields -# wrong constant name submit1 -# wrong constant name submit2 -# wrong constant name submit -# wrong constant name submit_button? -# wrong constant name submits -# wrong constant name text_field? -# wrong constant name textarea_field? -# wrong constant name textareas -# wrong constant name texts -# wrong constant name values -# wrong constant name xpath -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Mechanize::Form::Field' -# wrong constant name <=> -# wrong constant name at -# wrong constant name at_css -# wrong constant name at_xpath -# wrong constant name css -# wrong constant name dom_class -# wrong constant name dom_id -# wrong constant name index -# wrong constant name index= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name node -# wrong constant name node= -# wrong constant name query_value -# wrong constant name raw_value -# wrong constant name search -# wrong constant name type -# wrong constant name type= -# wrong constant name value -# wrong constant name value= -# wrong constant name xpath -# wrong constant name -# wrong constant name file_data -# wrong constant name file_data= -# wrong constant name file_name -# wrong constant name file_name= -# wrong constant name initialize -# wrong constant name mime_type -# wrong constant name mime_type= -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name x -# wrong constant name x= -# wrong constant name y -# wrong constant name y= -# wrong constant name -# undefined method `generate_key1' for class `Mechanize::Form::Keygen' -# wrong constant name challenge -# wrong constant name generate_key1 -# wrong constant name generate_key -# wrong constant name key -# wrong constant name -# undefined method `option1' for class `Mechanize::Form::MultiSelectList' -# undefined method `option_with1' for class `Mechanize::Form::MultiSelectList' -# undefined method `option_with!1' for class `Mechanize::Form::MultiSelectList' -# undefined method `options_with1' for class `Mechanize::Form::MultiSelectList' -# undefined method `select_options1' for class `Mechanize::Form::MultiSelectList' -# wrong constant name initialize -# wrong constant name option1 -# wrong constant name option -# wrong constant name option_with1 -# wrong constant name option_with -# wrong constant name option_with!1 -# wrong constant name option_with! -# wrong constant name options -# wrong constant name options= -# wrong constant name options_with1 -# wrong constant name options_with -# wrong constant name select_all -# wrong constant name select_none -# wrong constant name select_options1 -# wrong constant name select_options -# wrong constant name selected_options -# wrong constant name value= -# wrong constant name -# wrong constant name click -# wrong constant name initialize -# wrong constant name node -# wrong constant name select -# wrong constant name select_list -# wrong constant name selected -# wrong constant name selected? -# wrong constant name text -# wrong constant name tick -# wrong constant name unselect -# wrong constant name untick -# wrong constant name value -# wrong constant name -# wrong constant name == -# wrong constant name [] -# wrong constant name check -# wrong constant name checked -# wrong constant name checked= -# wrong constant name checked? -# wrong constant name click -# wrong constant name eql? -# wrong constant name form -# wrong constant name initialize -# wrong constant name label -# wrong constant name text -# wrong constant name uncheck -# wrong constant name -# wrong constant name -# wrong constant name value= -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `add_auth1' for class `Mechanize::HTTP::Agent' -# undefined method `add_auth2' for class `Mechanize::HTTP::Agent' -# undefined method `add_default_auth1' for class `Mechanize::HTTP::Agent' -# undefined method `fetch1' for class `Mechanize::HTTP::Agent' -# undefined method `fetch2' for class `Mechanize::HTTP::Agent' -# undefined method `fetch3' for class `Mechanize::HTTP::Agent' -# undefined method `fetch4' for class `Mechanize::HTTP::Agent' -# undefined method `fetch5' for class `Mechanize::HTTP::Agent' -# undefined method `http_request1' for class `Mechanize::HTTP::Agent' -# undefined method `inflate1' for class `Mechanize::HTTP::Agent' -# undefined method `initialize1' for class `Mechanize::HTTP::Agent' -# undefined method `request_add_headers1' for class `Mechanize::HTTP::Agent' -# undefined method `resolve1' for class `Mechanize::HTTP::Agent' -# undefined method `response_redirect1' for class `Mechanize::HTTP::Agent' -# undefined method `secure_resolve!1' for class `Mechanize::HTTP::Agent' -# undefined method `set_proxy1' for class `Mechanize::HTTP::Agent' -# undefined method `set_proxy2' for class `Mechanize::HTTP::Agent' -# undefined method `set_proxy3' for class `Mechanize::HTTP::Agent' -# wrong constant name add_auth1 -# wrong constant name add_auth2 -# wrong constant name add_auth -# wrong constant name add_default_auth1 -# wrong constant name add_default_auth -# wrong constant name allowed_error_codes -# wrong constant name allowed_error_codes= -# wrong constant name auth_store -# wrong constant name authenticate_methods -# wrong constant name auto_io -# wrong constant name back -# wrong constant name ca_file -# wrong constant name ca_file= -# wrong constant name cert_store -# wrong constant name cert_store= -# wrong constant name certificate -# wrong constant name certificate= -# wrong constant name conditional_requests -# wrong constant name conditional_requests= -# wrong constant name connection_for -# wrong constant name content_encoding_gunzip -# wrong constant name content_encoding_hooks -# wrong constant name content_encoding_inflate -# wrong constant name context -# wrong constant name context= -# wrong constant name cookie_jar -# wrong constant name cookie_jar= -# wrong constant name current_page -# wrong constant name digest_challenges -# wrong constant name disable_keep_alive -# wrong constant name enable_gzip -# wrong constant name fetch1 -# wrong constant name fetch2 -# wrong constant name fetch3 -# wrong constant name fetch4 -# wrong constant name fetch5 -# wrong constant name fetch -# wrong constant name follow_meta_refresh -# wrong constant name follow_meta_refresh= -# wrong constant name follow_meta_refresh_self -# wrong constant name follow_meta_refresh_self= -# wrong constant name get_meta_refresh -# wrong constant name get_robots -# wrong constant name gzip_enabled -# wrong constant name gzip_enabled= -# wrong constant name history -# wrong constant name history= -# wrong constant name hook_content_encoding -# wrong constant name http -# wrong constant name http_request1 -# wrong constant name http_request -# wrong constant name idle_timeout -# wrong constant name idle_timeout= -# wrong constant name ignore_bad_chunking -# wrong constant name ignore_bad_chunking= -# wrong constant name inflate1 -# wrong constant name inflate -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name keep_alive -# wrong constant name keep_alive= -# wrong constant name log -# wrong constant name make_tempfile -# wrong constant name max_file_buffer -# wrong constant name max_file_buffer= -# wrong constant name max_history -# wrong constant name max_history= -# wrong constant name open_timeout -# wrong constant name open_timeout= -# wrong constant name pass -# wrong constant name pass= -# wrong constant name post_connect -# wrong constant name post_connect_hooks -# wrong constant name pre_connect -# wrong constant name pre_connect_hooks -# wrong constant name private_key -# wrong constant name private_key= -# wrong constant name proxy_uri -# wrong constant name read_timeout -# wrong constant name read_timeout= -# wrong constant name redirect_ok -# wrong constant name redirect_ok= -# wrong constant name redirection_limit -# wrong constant name redirection_limit= -# wrong constant name request_add_headers1 -# wrong constant name request_add_headers -# wrong constant name request_auth -# wrong constant name request_auth_digest -# wrong constant name request_cookies -# wrong constant name request_headers -# wrong constant name request_headers= -# wrong constant name request_host -# wrong constant name request_language_charset -# wrong constant name request_log -# wrong constant name request_referer -# wrong constant name request_user_agent -# wrong constant name reset -# wrong constant name resolve1 -# wrong constant name resolve -# wrong constant name resolve_parameters -# wrong constant name response_authenticate -# wrong constant name response_content_encoding -# wrong constant name response_cookies -# wrong constant name response_follow_meta_refresh -# wrong constant name response_log -# wrong constant name response_parse -# wrong constant name response_read -# wrong constant name response_redirect1 -# wrong constant name response_redirect -# wrong constant name retry_change_requests -# wrong constant name retry_change_requests= -# wrong constant name robots -# wrong constant name robots= -# wrong constant name robots_allowed? -# wrong constant name robots_disallowed? -# wrong constant name robots_error -# wrong constant name robots_error! -# wrong constant name robots_mutex -# wrong constant name robots_reset -# wrong constant name save_cookies -# wrong constant name scheme_handlers -# wrong constant name scheme_handlers= -# wrong constant name secure_resolve!1 -# wrong constant name secure_resolve! -# wrong constant name set_proxy1 -# wrong constant name set_proxy2 -# wrong constant name set_proxy3 -# wrong constant name set_proxy -# wrong constant name shutdown -# wrong constant name ssl_version -# wrong constant name ssl_version= -# wrong constant name use_tempfile? -# wrong constant name user_agent -# wrong constant name user_agent= -# wrong constant name verify_callback -# wrong constant name verify_callback= -# wrong constant name verify_mode -# wrong constant name verify_mode= -# wrong constant name visited_page -# wrong constant name webrobots -# wrong constant name -# uninitialized constant Mechanize::HTTP::AuthChallenge::Elem -# wrong constant name [] -# wrong constant name params -# wrong constant name params= -# wrong constant name raw -# wrong constant name raw= -# wrong constant name realm -# wrong constant name realm_name -# wrong constant name scheme -# wrong constant name scheme= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name == -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name realm -# wrong constant name scheme -# wrong constant name uri -# wrong constant name -# undefined method `add_auth1' for class `Mechanize::HTTP::AuthStore' -# undefined method `add_auth2' for class `Mechanize::HTTP::AuthStore' -# undefined method `add_default_auth1' for class `Mechanize::HTTP::AuthStore' -# undefined method `remove_auth1' for class `Mechanize::HTTP::AuthStore' -# wrong constant name add_auth1 -# wrong constant name add_auth2 -# wrong constant name add_auth -# wrong constant name add_default_auth1 -# wrong constant name add_default_auth -# wrong constant name auth_accounts -# wrong constant name credentials? -# wrong constant name credentials_for -# wrong constant name default_auth -# wrong constant name remove_auth1 -# wrong constant name remove_auth -# wrong constant name -# uninitialized constant Mechanize::HTTP::ContentDisposition::Elem -# wrong constant name creation_date -# wrong constant name creation_date= -# wrong constant name filename -# wrong constant name filename= -# wrong constant name modification_date -# wrong constant name modification_date= -# wrong constant name parameters -# wrong constant name parameters= -# wrong constant name read_date -# wrong constant name read_date= -# wrong constant name size= -# wrong constant name type -# wrong constant name type= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# undefined method `parse1' for class `Mechanize::HTTP::ContentDispositionParser' -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name parse_parameters -# wrong constant name rfc_2045_quoted_string -# wrong constant name rfc_2045_token -# wrong constant name rfc_2045_value -# wrong constant name scanner -# wrong constant name scanner= -# wrong constant name spaces -# wrong constant name -# wrong constant name parse -# wrong constant name auth_param -# wrong constant name auth_scheme -# wrong constant name parse -# wrong constant name quoted_string -# wrong constant name scan_comma_spaces -# wrong constant name scanner -# wrong constant name scanner= -# wrong constant name spaces -# wrong constant name token -# wrong constant name -# wrong constant name -# uninitialized constant Mechanize::Headers::DEFAULT_INDENT -# uninitialized constant Mechanize::Headers::Elem -# uninitialized constant Mechanize::Headers::K -# uninitialized constant Mechanize::Headers::V -# wrong constant name [] -# wrong constant name []= -# wrong constant name canonical_each -# wrong constant name key? -# wrong constant name -# undefined method `<<1' for class `Mechanize::History' -# undefined method `initialize1' for class `Mechanize::History' -# undefined method `push1' for class `Mechanize::History' -# wrong constant name <<1 -# wrong constant name << -# uninitialized constant Mechanize::History::DEFAULT_INDENT -# uninitialized constant Mechanize::History::Elem -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name max_size -# wrong constant name max_size= -# wrong constant name pop -# wrong constant name push1 -# wrong constant name push -# wrong constant name shift -# wrong constant name visited? -# wrong constant name visited_page -# wrong constant name -# uninitialized constant Mechanize::Image::SPECIAL_FILENAMES -# wrong constant name -# undefined method `base1' for class `Mechanize::Page' -# undefined method `base_with1' for class `Mechanize::Page' -# undefined method `base_with!1' for class `Mechanize::Page' -# undefined method `bases_with1' for class `Mechanize::Page' -# undefined method `encoding_error?1' for class `Mechanize::Page' -# undefined method `form1' for class `Mechanize::Page' -# undefined method `form_with1' for class `Mechanize::Page' -# undefined method `form_with!1' for class `Mechanize::Page' -# undefined method `forms_with1' for class `Mechanize::Page' -# undefined method `frame1' for class `Mechanize::Page' -# undefined method `frame_with1' for class `Mechanize::Page' -# undefined method `frame_with!1' for class `Mechanize::Page' -# undefined method `frames_with1' for class `Mechanize::Page' -# undefined method `iframe1' for class `Mechanize::Page' -# undefined method `iframe_with1' for class `Mechanize::Page' -# undefined method `iframe_with!1' for class `Mechanize::Page' -# undefined method `iframes_with1' for class `Mechanize::Page' -# undefined method `image1' for class `Mechanize::Page' -# undefined method `image_with1' for class `Mechanize::Page' -# undefined method `image_with!1' for class `Mechanize::Page' -# undefined method `images_with1' for class `Mechanize::Page' -# undefined method `initialize1' for class `Mechanize::Page' -# undefined method `initialize2' for class `Mechanize::Page' -# undefined method `initialize3' for class `Mechanize::Page' -# undefined method `initialize4' for class `Mechanize::Page' -# undefined method `initialize5' for class `Mechanize::Page' -# undefined method `link1' for class `Mechanize::Page' -# undefined method `link_with1' for class `Mechanize::Page' -# undefined method `link_with!1' for class `Mechanize::Page' -# undefined method `links_with1' for class `Mechanize::Page' -# undefined method `select_bases1' for class `Mechanize::Page' -# undefined method `select_forms1' for class `Mechanize::Page' -# undefined method `select_frames1' for class `Mechanize::Page' -# undefined method `select_iframes1' for class `Mechanize::Page' -# undefined method `select_images1' for class `Mechanize::Page' -# undefined method `select_links1' for class `Mechanize::Page' -# wrong constant name % -# wrong constant name / -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Mechanize::Page::SPECIAL_FILENAMES -# wrong constant name at -# wrong constant name at_css -# wrong constant name at_xpath -# wrong constant name base1 -# wrong constant name base -# wrong constant name base_with1 -# wrong constant name base_with -# wrong constant name base_with!1 -# wrong constant name base_with! -# wrong constant name bases -# wrong constant name bases_with1 -# wrong constant name bases_with -# wrong constant name canonical_uri -# wrong constant name content_type -# wrong constant name css -# wrong constant name detected_encoding -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name encoding_error?1 -# wrong constant name encoding_error? -# wrong constant name encodings -# wrong constant name form1 -# wrong constant name form -# wrong constant name form_with1 -# wrong constant name form_with -# wrong constant name form_with!1 -# wrong constant name form_with! -# wrong constant name forms -# wrong constant name forms_with1 -# wrong constant name forms_with -# wrong constant name frame1 -# wrong constant name frame -# wrong constant name frame_with1 -# wrong constant name frame_with -# wrong constant name frame_with!1 -# wrong constant name frame_with! -# wrong constant name frames -# wrong constant name frames_with1 -# wrong constant name frames_with -# wrong constant name iframe1 -# wrong constant name iframe -# wrong constant name iframe_with1 -# wrong constant name iframe_with -# wrong constant name iframe_with!1 -# wrong constant name iframe_with! -# wrong constant name iframes -# wrong constant name iframes_with1 -# wrong constant name iframes_with -# wrong constant name image1 -# wrong constant name image -# wrong constant name image_urls -# wrong constant name image_with1 -# wrong constant name image_with -# wrong constant name image_with!1 -# wrong constant name image_with! -# wrong constant name images -# wrong constant name images_with1 -# wrong constant name images_with -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize5 -# wrong constant name initialize -# wrong constant name labels -# wrong constant name labels_hash -# wrong constant name link1 -# wrong constant name link -# wrong constant name link_with1 -# wrong constant name link_with -# wrong constant name link_with!1 -# wrong constant name link_with! -# wrong constant name links -# wrong constant name links_with1 -# wrong constant name links_with -# wrong constant name mech -# wrong constant name mech= -# wrong constant name meta_charset -# wrong constant name meta_refresh -# wrong constant name parser -# wrong constant name reset -# wrong constant name response_header_charset -# wrong constant name root -# wrong constant name search -# wrong constant name select_bases1 -# wrong constant name select_bases -# wrong constant name select_forms1 -# wrong constant name select_forms -# wrong constant name select_frames1 -# wrong constant name select_frames -# wrong constant name select_iframes1 -# wrong constant name select_iframes -# wrong constant name select_images1 -# wrong constant name select_images -# wrong constant name select_links1 -# wrong constant name select_links -# wrong constant name title -# wrong constant name xpath -# wrong constant name -# wrong constant name content -# wrong constant name initialize -# wrong constant name name -# wrong constant name src -# wrong constant name -# undefined method `fetch1' for class `Mechanize::Page::Image' -# undefined method `fetch2' for class `Mechanize::Page::Image' -# undefined method `fetch3' for class `Mechanize::Page::Image' -# wrong constant name alt -# wrong constant name caption -# wrong constant name dom_class -# wrong constant name dom_id -# wrong constant name extname -# wrong constant name fetch1 -# wrong constant name fetch2 -# wrong constant name fetch3 -# wrong constant name fetch -# wrong constant name height -# wrong constant name image_referer -# wrong constant name initialize -# wrong constant name mech -# wrong constant name mech= -# wrong constant name mime_type -# wrong constant name node -# wrong constant name page -# wrong constant name page= -# wrong constant name relative? -# wrong constant name src -# wrong constant name text -# wrong constant name title -# wrong constant name uri -# wrong constant name url -# wrong constant name width -# wrong constant name -# wrong constant name for -# wrong constant name initialize -# wrong constant name node -# wrong constant name page -# wrong constant name text -# wrong constant name -# wrong constant name attributes -# wrong constant name click -# wrong constant name dom_class -# wrong constant name dom_id -# wrong constant name href -# wrong constant name initialize -# wrong constant name node -# wrong constant name noreferrer? -# wrong constant name page -# wrong constant name referer -# wrong constant name rel -# wrong constant name rel? -# wrong constant name resolved_uri -# wrong constant name text -# wrong constant name uri -# wrong constant name -# undefined method `initialize1' for class `Mechanize::Page::MetaRefresh' -# wrong constant name delay -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name link_self -# undefined singleton method `from_node1' for `Mechanize::Page::MetaRefresh' -# undefined singleton method `parse1' for `Mechanize::Page::MetaRefresh' -# wrong constant name -# wrong constant name from_node1 -# wrong constant name from_node -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name -# wrong constant name charset -# wrong constant name charset_from_content_type -# wrong constant name meta_charset -# wrong constant name meta_content_type -# wrong constant name response_header_charset -# undefined method `extract_filename1' for module `Mechanize::Parser' -# wrong constant name [] -# wrong constant name []= -# wrong constant name canonical_each -# wrong constant name code -# wrong constant name code= -# wrong constant name each -# wrong constant name extract_filename1 -# wrong constant name extract_filename -# wrong constant name fill_header -# wrong constant name find_free_name -# wrong constant name header -# wrong constant name key? -# wrong constant name response -# wrong constant name response= -# wrong constant name uri -# wrong constant name uri= -# wrong constant name -# wrong constant name [] -# wrong constant name []= -# wrong constant name csv= -# wrong constant name default -# wrong constant name default= -# wrong constant name html= -# wrong constant name parser -# wrong constant name pdf= -# wrong constant name register_parser -# wrong constant name xhtml= -# wrong constant name xml= -# wrong constant name -# wrong constant name initialize -# wrong constant name page -# wrong constant name redirects -# wrong constant name response_code -# wrong constant name -# wrong constant name initialize -# wrong constant name page -# wrong constant name response_code -# wrong constant name uri -# wrong constant name verb -# wrong constant name -# undefined method `initialize1' for class `Mechanize::ResponseCodeError' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name page -# wrong constant name response_code -# wrong constant name -# wrong constant name body_io -# wrong constant name error -# wrong constant name force_parse -# wrong constant name initialize -# wrong constant name mechanize -# wrong constant name response -# wrong constant name uri -# wrong constant name -# wrong constant name initialize -# wrong constant name uri -# wrong constant name url -# wrong constant name -# wrong constant name challenges -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name scheme -# wrong constant name scheme= -# wrong constant name uri -# wrong constant name uri= -# wrong constant name -# undefined singleton method `build_query_string1' for `Mechanize::Util' -# undefined singleton method `from_native_charset1' for `Mechanize::Util' -# undefined singleton method `from_native_charset2' for `Mechanize::Util' -# undefined singleton method `uri_escape1' for `Mechanize::Util' -# wrong constant name -# wrong constant name build_query_string1 -# wrong constant name build_query_string -# wrong constant name detect_charset -# wrong constant name each_parameter -# wrong constant name from_native_charset1 -# wrong constant name from_native_charset2 -# wrong constant name from_native_charset -# wrong constant name guess_encoding -# wrong constant name html_unescape -# wrong constant name uri_escape1 -# wrong constant name uri_escape -# wrong constant name uri_unescape -# uninitialized constant Mechanize::XmlFile::SPECIAL_FILENAMES -# wrong constant name at -# wrong constant name search -# wrong constant name xml -# wrong constant name -# wrong constant name -# wrong constant name html_parser -# wrong constant name html_parser= -# wrong constant name inherited -# wrong constant name log -# wrong constant name log= -# wrong constant name start # uninitialized constant MessagePack # uninitialized constant MessagePack # wrong constant name @@ -10945,35 +7818,18 @@ # wrong constant name # uninitialized constant Net::IMAP # uninitialized constant Net::IMAP -# wrong constant name inherited # uninitialized constant Net::NTLM::ChannelBinding # uninitialized constant Net::NTLM::ChannelBinding # uninitialized constant Net::NTLM::Client # uninitialized constant Net::NTLM::Client # uninitialized constant Net::NTLM::EncodeUtil # uninitialized constant Net::NTLM::EncodeUtil -# wrong constant name define # uninitialized constant Net::NTLM::InvalidTargetDataError # uninitialized constant Net::NTLM::InvalidTargetDataError -# wrong constant name inherited -# wrong constant name padding -# wrong constant name padding= -# wrong constant name parse -# wrong constant name inherited -# wrong constant name padding -# wrong constant name padding= -# wrong constant name parse -# wrong constant name inherited -# wrong constant name inherited # uninitialized constant Net::NTLM::NtlmError # uninitialized constant Net::NTLM::NtlmError -# wrong constant name inherited # uninitialized constant Net::NTLM::TargetInfo # uninitialized constant Net::NTLM::TargetInfo -# wrong constant name -# wrong constant name decode_utf16le -# wrong constant name encode_utf16le -# wrong constant name swap16 # undefined method `initialize1' for class `Net::ReadTimeout' # wrong constant name initialize1 # wrong constant name initialize @@ -11011,36 +7867,6 @@ # wrong constant name try # wrong constant name try!1 # wrong constant name try! -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `to_xpath1' for class `Nokogiri::CSS::Node' -# undefined method `to_xpath2' for class `Nokogiri::CSS::Node' -# wrong constant name accept -# wrong constant name find_by_type -# wrong constant name initialize -# wrong constant name to_a -# wrong constant name to_type -# wrong constant name to_xpath1 -# wrong constant name to_xpath2 -# wrong constant name to_xpath -# wrong constant name type -# wrong constant name type= -# wrong constant name value -# wrong constant name value= -# wrong constant name -# undefined method `initialize1' for class `Nokogiri::CSS::Parser' -# undefined method `xpath_for1' for class `Nokogiri::CSS::Parser' # uninitialized constant Nokogiri::CSS::Parser::Racc_Main_Parsing_Routine # uninitialized constant Nokogiri::CSS::Parser::Racc_Runtime_Core_Id_C # uninitialized constant Nokogiri::CSS::Parser::Racc_Runtime_Core_Revision @@ -11053,1294 +7879,6 @@ # uninitialized constant Nokogiri::CSS::Parser::Racc_Runtime_Type # uninitialized constant Nokogiri::CSS::Parser::Racc_Runtime_Version # uninitialized constant Nokogiri::CSS::Parser::Racc_YY_Parse_Method -# wrong constant name _reduce_1 -# wrong constant name _reduce_11 -# wrong constant name _reduce_12 -# wrong constant name _reduce_13 -# wrong constant name _reduce_14 -# wrong constant name _reduce_15 -# wrong constant name _reduce_16 -# wrong constant name _reduce_18 -# wrong constant name _reduce_2 -# wrong constant name _reduce_20 -# wrong constant name _reduce_21 -# wrong constant name _reduce_22 -# wrong constant name _reduce_23 -# wrong constant name _reduce_25 -# wrong constant name _reduce_26 -# wrong constant name _reduce_27 -# wrong constant name _reduce_28 -# wrong constant name _reduce_29 -# wrong constant name _reduce_3 -# wrong constant name _reduce_30 -# wrong constant name _reduce_31 -# wrong constant name _reduce_32 -# wrong constant name _reduce_33 -# wrong constant name _reduce_34 -# wrong constant name _reduce_35 -# wrong constant name _reduce_36 -# wrong constant name _reduce_37 -# wrong constant name _reduce_4 -# wrong constant name _reduce_40 -# wrong constant name _reduce_41 -# wrong constant name _reduce_42 -# wrong constant name _reduce_43 -# wrong constant name _reduce_44 -# wrong constant name _reduce_45 -# wrong constant name _reduce_48 -# wrong constant name _reduce_49 -# wrong constant name _reduce_5 -# wrong constant name _reduce_50 -# wrong constant name _reduce_51 -# wrong constant name _reduce_52 -# wrong constant name _reduce_58 -# wrong constant name _reduce_59 -# wrong constant name _reduce_6 -# wrong constant name _reduce_60 -# wrong constant name _reduce_61 -# wrong constant name _reduce_63 -# wrong constant name _reduce_64 -# wrong constant name _reduce_65 -# wrong constant name _reduce_66 -# wrong constant name _reduce_67 -# wrong constant name _reduce_68 -# wrong constant name _reduce_69 -# wrong constant name _reduce_7 -# wrong constant name _reduce_70 -# wrong constant name _reduce_8 -# wrong constant name _reduce_9 -# wrong constant name _reduce_none -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name on_error -# wrong constant name parse -# wrong constant name unescape_css_identifier -# wrong constant name unescape_css_string -# wrong constant name xpath_for1 -# wrong constant name xpath_for -# wrong constant name -# wrong constant name [] -# wrong constant name []= -# wrong constant name cache_on -# wrong constant name cache_on= -# wrong constant name cache_on? -# wrong constant name clear_cache -# wrong constant name parse -# wrong constant name set_cache -# wrong constant name without_cache -# wrong constant name -# wrong constant name -# wrong constant name _next_token -# wrong constant name action -# wrong constant name filename -# wrong constant name lineno -# wrong constant name load_file -# wrong constant name next_token -# wrong constant name scan -# wrong constant name scan_file -# wrong constant name scan_setup -# wrong constant name scan_str -# wrong constant name state -# wrong constant name state= -# wrong constant name -# wrong constant name -# wrong constant name accept -# wrong constant name visit_attribute_condition -# wrong constant name visit_child_selector -# wrong constant name visit_class_condition -# wrong constant name visit_combinator -# wrong constant name visit_conditional_selector -# wrong constant name visit_descendant_selector -# wrong constant name visit_direct_adjacent_selector -# wrong constant name visit_element_name -# wrong constant name visit_following_selector -# wrong constant name visit_function -# wrong constant name visit_id -# wrong constant name visit_not -# wrong constant name visit_pseudo_class -# wrong constant name -# undefined singleton method `xpath_for1' for `Nokogiri::CSS' -# wrong constant name -# wrong constant name parse -# wrong constant name xpath_for1 -# wrong constant name xpath_for -# wrong constant name -# wrong constant name method_missing -# wrong constant name -# wrong constant name -# wrong constant name name -# wrong constant name -# wrong constant name [] -# wrong constant name alias -# wrong constant name clear_aliases! -# wrong constant name delete -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name to_html -# wrong constant name -# undefined method `meta_robots1' for class `Nokogiri::HTML::Document' -# undefined method `nofollow?1' for class `Nokogiri::HTML::Document' -# undefined method `noindex?1' for class `Nokogiri::HTML::Document' -# undefined method `serialize1' for class `Nokogiri::HTML::Document' -# uninitialized constant Nokogiri::HTML::Document::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::HTML::Document::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::HTML::Document::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::HTML::Document::COMMENT_NODE -# uninitialized constant Nokogiri::HTML::Document::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::Document::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::HTML::Document::DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::Document::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::HTML::Document::DTD_NODE -# uninitialized constant Nokogiri::HTML::Document::ELEMENT_DECL -# uninitialized constant Nokogiri::HTML::Document::ELEMENT_NODE -# uninitialized constant Nokogiri::HTML::Document::ENTITY_DECL -# uninitialized constant Nokogiri::HTML::Document::ENTITY_NODE -# uninitialized constant Nokogiri::HTML::Document::ENTITY_REF_NODE -# uninitialized constant Nokogiri::HTML::Document::Elem -# wrong constant name -# wrong constant name -# uninitialized constant Nokogiri::HTML::Document::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::Document::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::HTML::Document::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::HTML::Document::NAMESPACE_DECL -# uninitialized constant Nokogiri::HTML::Document::NCNAME_CHAR -# uninitialized constant Nokogiri::HTML::Document::NCNAME_RE -# uninitialized constant Nokogiri::HTML::Document::NCNAME_START_CHAR -# uninitialized constant Nokogiri::HTML::Document::NOTATION_NODE -# uninitialized constant Nokogiri::HTML::Document::PI_NODE -# uninitialized constant Nokogiri::HTML::Document::TEXT_NODE -# uninitialized constant Nokogiri::HTML::Document::XINCLUDE_END -# uninitialized constant Nokogiri::HTML::Document::XINCLUDE_START -# wrong constant name meta_encoding -# wrong constant name meta_encoding= -# wrong constant name meta_robots1 -# wrong constant name meta_robots -# wrong constant name nofollow?1 -# wrong constant name nofollow? -# wrong constant name noindex?1 -# wrong constant name noindex? -# wrong constant name serialize1 -# wrong constant name serialize -# wrong constant name title -# wrong constant name title= -# wrong constant name found_encoding -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name encoding_found -# wrong constant name initialize -# wrong constant name read -# wrong constant name initialize -# wrong constant name -# wrong constant name encoding -# wrong constant name -# wrong constant name -# wrong constant name detect_encoding -# wrong constant name detect_encoding_for_jruby_without_fix -# wrong constant name is_jruby_without_fix? -# wrong constant name -# uninitialized constant Nokogiri::HTML::DocumentFragment::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::HTML::DocumentFragment::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::COMMENT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::DTD_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::ELEMENT_DECL -# uninitialized constant Nokogiri::HTML::DocumentFragment::ELEMENT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::ENTITY_DECL -# uninitialized constant Nokogiri::HTML::DocumentFragment::ENTITY_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::ENTITY_REF_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::Elem -# uninitialized constant Nokogiri::HTML::DocumentFragment::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::HTML::DocumentFragment::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::HTML::DocumentFragment::NAMESPACE_DECL -# uninitialized constant Nokogiri::HTML::DocumentFragment::NOTATION_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::PI_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::TEXT_NODE -# uninitialized constant Nokogiri::HTML::DocumentFragment::XINCLUDE_END -# uninitialized constant Nokogiri::HTML::DocumentFragment::XINCLUDE_START -# undefined singleton method `parse1' for `Nokogiri::HTML::DocumentFragment' -# wrong constant name -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name block? -# wrong constant name default_sub_element -# wrong constant name deprecated? -# wrong constant name deprecated_attributes -# wrong constant name description -# wrong constant name empty? -# wrong constant name implied_end_tag? -# wrong constant name implied_start_tag? -# wrong constant name inline? -# wrong constant name name -# wrong constant name optional_attributes -# wrong constant name required_attributes -# wrong constant name save_end_tag? -# wrong constant name sub_elements -# wrong constant name -# wrong constant name [] -# wrong constant name -# wrong constant name [] -# wrong constant name get -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `parse_file1' for class `Nokogiri::HTML::SAX::Parser' -# undefined method `parse_memory1' for class `Nokogiri::HTML::SAX::Parser' -# uninitialized constant Nokogiri::HTML::SAX::Parser::ENCODINGS -# wrong constant name parse_file1 -# wrong constant name parse_file -# wrong constant name parse_memory1 -# wrong constant name parse_memory -# wrong constant name -# wrong constant name -# wrong constant name file -# wrong constant name memory -# wrong constant name -# wrong constant name -# undefined singleton method `fragment1' for `Nokogiri::HTML' -# undefined singleton method `parse1' for `Nokogiri::HTML' -# undefined singleton method `parse2' for `Nokogiri::HTML' -# undefined singleton method `parse3' for `Nokogiri::HTML' -# wrong constant name -# wrong constant name fragment1 -# wrong constant name fragment -# wrong constant name parse1 -# wrong constant name parse2 -# wrong constant name parse3 -# wrong constant name parse -# wrong constant name -# wrong constant name compiled_parser_version -# wrong constant name engine -# wrong constant name jruby? -# wrong constant name libxml2? -# wrong constant name libxml2_using_packaged? -# wrong constant name libxml2_using_system? -# wrong constant name loaded_parser_version -# wrong constant name to_hash -# wrong constant name to_markdown -# wrong constant name warnings -# wrong constant name -# wrong constant name instance -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Nokogiri::XML::Attr::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::Attr::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::Attr::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::Attr::COMMENT_NODE -# uninitialized constant Nokogiri::XML::Attr::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Attr::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::Attr::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Attr::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::Attr::DTD_NODE -# uninitialized constant Nokogiri::XML::Attr::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::Attr::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::Attr::ENTITY_DECL -# uninitialized constant Nokogiri::XML::Attr::ENTITY_NODE -# uninitialized constant Nokogiri::XML::Attr::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::Attr::Elem -# uninitialized constant Nokogiri::XML::Attr::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Attr::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::Attr::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::Attr::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::Attr::NOTATION_NODE -# uninitialized constant Nokogiri::XML::Attr::PI_NODE -# uninitialized constant Nokogiri::XML::Attr::TEXT_NODE -# uninitialized constant Nokogiri::XML::Attr::XINCLUDE_END -# uninitialized constant Nokogiri::XML::Attr::XINCLUDE_START -# wrong constant name content= -# wrong constant name value -# wrong constant name value= -# wrong constant name -# uninitialized constant Nokogiri::XML::AttributeDecl::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::AttributeDecl::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::COMMENT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::DTD_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::AttributeDecl::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::ENTITY_DECL -# uninitialized constant Nokogiri::XML::AttributeDecl::ENTITY_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::Elem -# uninitialized constant Nokogiri::XML::AttributeDecl::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::AttributeDecl::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::AttributeDecl::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::AttributeDecl::NOTATION_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::PI_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::TEXT_NODE -# uninitialized constant Nokogiri::XML::AttributeDecl::XINCLUDE_END -# uninitialized constant Nokogiri::XML::AttributeDecl::XINCLUDE_START -# wrong constant name attribute_type -# wrong constant name default -# wrong constant name enumeration -# wrong constant name -# undefined method `initialize1' for class `Nokogiri::XML::Builder' -# undefined method `initialize2' for class `Nokogiri::XML::Builder' -# wrong constant name << -# wrong constant name [] -# wrong constant name arity -# wrong constant name arity= -# wrong constant name cdata -# wrong constant name comment -# wrong constant name context -# wrong constant name context= -# wrong constant name doc -# wrong constant name doc= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name parent -# wrong constant name parent= -# wrong constant name text -# wrong constant name to_xml -# wrong constant name -# wrong constant name with -# uninitialized constant Nokogiri::XML::CDATA::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::CDATA::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::CDATA::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::CDATA::COMMENT_NODE -# uninitialized constant Nokogiri::XML::CDATA::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CDATA::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::CDATA::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CDATA::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::CDATA::DTD_NODE -# uninitialized constant Nokogiri::XML::CDATA::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::CDATA::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::CDATA::ENTITY_DECL -# uninitialized constant Nokogiri::XML::CDATA::ENTITY_NODE -# uninitialized constant Nokogiri::XML::CDATA::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::CDATA::Elem -# uninitialized constant Nokogiri::XML::CDATA::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CDATA::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::CDATA::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::CDATA::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::CDATA::NOTATION_NODE -# uninitialized constant Nokogiri::XML::CDATA::PI_NODE -# uninitialized constant Nokogiri::XML::CDATA::TEXT_NODE -# uninitialized constant Nokogiri::XML::CDATA::XINCLUDE_END -# uninitialized constant Nokogiri::XML::CDATA::XINCLUDE_START -# wrong constant name -# uninitialized constant Nokogiri::XML::CharacterData::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::CharacterData::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::CharacterData::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::CharacterData::COMMENT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::CharacterData::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::CharacterData::DTD_NODE -# uninitialized constant Nokogiri::XML::CharacterData::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::CharacterData::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::ENTITY_DECL -# uninitialized constant Nokogiri::XML::CharacterData::ENTITY_NODE -# uninitialized constant Nokogiri::XML::CharacterData::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::CharacterData::Elem -# uninitialized constant Nokogiri::XML::CharacterData::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::CharacterData::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::CharacterData::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::CharacterData::NOTATION_NODE -# uninitialized constant Nokogiri::XML::CharacterData::PI_NODE -# uninitialized constant Nokogiri::XML::CharacterData::TEXT_NODE -# uninitialized constant Nokogiri::XML::CharacterData::XINCLUDE_END -# uninitialized constant Nokogiri::XML::CharacterData::XINCLUDE_START -# wrong constant name -# uninitialized constant Nokogiri::XML::Comment::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::Comment::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::Comment::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::Comment::COMMENT_NODE -# uninitialized constant Nokogiri::XML::Comment::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Comment::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::Comment::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Comment::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::Comment::DTD_NODE -# uninitialized constant Nokogiri::XML::Comment::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::Comment::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::Comment::ENTITY_DECL -# uninitialized constant Nokogiri::XML::Comment::ENTITY_NODE -# uninitialized constant Nokogiri::XML::Comment::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::Comment::Elem -# uninitialized constant Nokogiri::XML::Comment::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Comment::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::Comment::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::Comment::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::Comment::NOTATION_NODE -# uninitialized constant Nokogiri::XML::Comment::PI_NODE -# uninitialized constant Nokogiri::XML::Comment::TEXT_NODE -# uninitialized constant Nokogiri::XML::Comment::XINCLUDE_END -# uninitialized constant Nokogiri::XML::Comment::XINCLUDE_START -# wrong constant name -# uninitialized constant Nokogiri::XML::DTD::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::DTD::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::DTD::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::DTD::COMMENT_NODE -# uninitialized constant Nokogiri::XML::DTD::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DTD::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::DTD::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DTD::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::DTD::DTD_NODE -# uninitialized constant Nokogiri::XML::DTD::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::DTD::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::DTD::ENTITY_DECL -# uninitialized constant Nokogiri::XML::DTD::ENTITY_NODE -# uninitialized constant Nokogiri::XML::DTD::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::DTD::Elem -# uninitialized constant Nokogiri::XML::DTD::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DTD::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::DTD::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::DTD::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::DTD::NOTATION_NODE -# uninitialized constant Nokogiri::XML::DTD::PI_NODE -# uninitialized constant Nokogiri::XML::DTD::TEXT_NODE -# uninitialized constant Nokogiri::XML::DTD::XINCLUDE_END -# uninitialized constant Nokogiri::XML::DTD::XINCLUDE_START -# wrong constant name entities -# wrong constant name external_id -# wrong constant name html5_dtd? -# wrong constant name html_dtd? -# wrong constant name notations -# wrong constant name system_id -# wrong constant name validate -# wrong constant name -# undefined method `fragment1' for class `Nokogiri::XML::Document' -# uninitialized constant Nokogiri::XML::Document::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::Document::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::Document::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::Document::COMMENT_NODE -# uninitialized constant Nokogiri::XML::Document::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Document::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::Document::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Document::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::Document::DTD_NODE -# uninitialized constant Nokogiri::XML::Document::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::Document::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::Document::ENTITY_DECL -# uninitialized constant Nokogiri::XML::Document::ENTITY_NODE -# uninitialized constant Nokogiri::XML::Document::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::Document::Elem -# uninitialized constant Nokogiri::XML::Document::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Document::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::Document::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::Document::NOTATION_NODE -# uninitialized constant Nokogiri::XML::Document::PI_NODE -# uninitialized constant Nokogiri::XML::Document::TEXT_NODE -# uninitialized constant Nokogiri::XML::Document::XINCLUDE_END -# uninitialized constant Nokogiri::XML::Document::XINCLUDE_START -# wrong constant name canonicalize -# wrong constant name collect_namespaces -# wrong constant name create_cdata -# wrong constant name create_comment -# wrong constant name create_element -# wrong constant name create_entity -# wrong constant name create_text_node -# wrong constant name decorate -# wrong constant name decorators -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name errors -# wrong constant name errors= -# wrong constant name fragment1 -# wrong constant name fragment -# wrong constant name initialize -# wrong constant name remove_namespaces! -# wrong constant name root -# wrong constant name root= -# wrong constant name slop! -# wrong constant name to_java -# wrong constant name to_xml -# wrong constant name url -# wrong constant name validate -# wrong constant name version -# undefined singleton method `parse1' for `Nokogiri::XML::Document' -# undefined singleton method `parse2' for `Nokogiri::XML::Document' -# undefined singleton method `parse3' for `Nokogiri::XML::Document' -# wrong constant name -# wrong constant name empty_doc? -# wrong constant name parse1 -# wrong constant name parse2 -# wrong constant name parse3 -# wrong constant name parse -# wrong constant name read_io -# wrong constant name read_memory -# wrong constant name wrap -# undefined method `initialize1' for class `Nokogiri::XML::DocumentFragment' -# undefined method `initialize2' for class `Nokogiri::XML::DocumentFragment' -# uninitialized constant Nokogiri::XML::DocumentFragment::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::DocumentFragment::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::COMMENT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::DTD_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::DocumentFragment::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::ENTITY_DECL -# uninitialized constant Nokogiri::XML::DocumentFragment::ENTITY_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::Elem -# uninitialized constant Nokogiri::XML::DocumentFragment::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::DocumentFragment::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::DocumentFragment::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::DocumentFragment::NOTATION_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::PI_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::TEXT_NODE -# uninitialized constant Nokogiri::XML::DocumentFragment::XINCLUDE_END -# uninitialized constant Nokogiri::XML::DocumentFragment::XINCLUDE_START -# wrong constant name dup -# wrong constant name errors -# wrong constant name errors= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name search -# wrong constant name serialize -# wrong constant name to_html -# wrong constant name to_xhtml -# wrong constant name to_xml -# wrong constant name -# wrong constant name parse -# uninitialized constant Nokogiri::XML::Element::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::Element::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::Element::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::Element::COMMENT_NODE -# uninitialized constant Nokogiri::XML::Element::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Element::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::Element::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Element::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::Element::DTD_NODE -# uninitialized constant Nokogiri::XML::Element::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::Element::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::Element::ENTITY_DECL -# uninitialized constant Nokogiri::XML::Element::ENTITY_NODE -# uninitialized constant Nokogiri::XML::Element::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::Element::Elem -# uninitialized constant Nokogiri::XML::Element::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Element::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::Element::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::Element::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::Element::NOTATION_NODE -# uninitialized constant Nokogiri::XML::Element::PI_NODE -# uninitialized constant Nokogiri::XML::Element::TEXT_NODE -# uninitialized constant Nokogiri::XML::Element::XINCLUDE_END -# uninitialized constant Nokogiri::XML::Element::XINCLUDE_START -# wrong constant name -# wrong constant name children -# wrong constant name document -# wrong constant name name -# wrong constant name occur -# wrong constant name prefix -# wrong constant name type -# wrong constant name -# uninitialized constant Nokogiri::XML::ElementDecl::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::ElementDecl::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::COMMENT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::DTD_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::ElementDecl::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::ENTITY_DECL -# uninitialized constant Nokogiri::XML::ElementDecl::ENTITY_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::Elem -# uninitialized constant Nokogiri::XML::ElementDecl::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::ElementDecl::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::ElementDecl::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::ElementDecl::NOTATION_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::PI_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::TEXT_NODE -# uninitialized constant Nokogiri::XML::ElementDecl::XINCLUDE_END -# uninitialized constant Nokogiri::XML::ElementDecl::XINCLUDE_START -# wrong constant name element_type -# wrong constant name prefix -# wrong constant name -# uninitialized constant Nokogiri::XML::EntityDecl::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::EntityDecl::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::COMMENT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::DTD_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::EntityDecl::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::ENTITY_DECL -# uninitialized constant Nokogiri::XML::EntityDecl::ENTITY_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::Elem -# uninitialized constant Nokogiri::XML::EntityDecl::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::EntityDecl::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::EntityDecl::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::EntityDecl::NOTATION_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::PI_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::TEXT_NODE -# uninitialized constant Nokogiri::XML::EntityDecl::XINCLUDE_END -# uninitialized constant Nokogiri::XML::EntityDecl::XINCLUDE_START -# wrong constant name entity_type -# wrong constant name external_id -# wrong constant name original_content -# wrong constant name system_id -# wrong constant name -# wrong constant name new -# uninitialized constant Nokogiri::XML::EntityReference::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::EntityReference::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::EntityReference::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::EntityReference::COMMENT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::EntityReference::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::EntityReference::DTD_NODE -# uninitialized constant Nokogiri::XML::EntityReference::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::EntityReference::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::ENTITY_DECL -# uninitialized constant Nokogiri::XML::EntityReference::ENTITY_NODE -# uninitialized constant Nokogiri::XML::EntityReference::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::EntityReference::Elem -# uninitialized constant Nokogiri::XML::EntityReference::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::EntityReference::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::EntityReference::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::EntityReference::NOTATION_NODE -# uninitialized constant Nokogiri::XML::EntityReference::PI_NODE -# uninitialized constant Nokogiri::XML::EntityReference::TEXT_NODE -# uninitialized constant Nokogiri::XML::EntityReference::XINCLUDE_END -# uninitialized constant Nokogiri::XML::EntityReference::XINCLUDE_START -# wrong constant name -# wrong constant name document -# wrong constant name href -# wrong constant name prefix -# wrong constant name -# undefined method `ancestors1' for class `Nokogiri::XML::Node' -# undefined method `canonicalize1' for class `Nokogiri::XML::Node' -# undefined method `canonicalize2' for class `Nokogiri::XML::Node' -# undefined method `canonicalize3' for class `Nokogiri::XML::Node' -# undefined method `do_xinclude1' for class `Nokogiri::XML::Node' -# undefined method `parse1' for class `Nokogiri::XML::Node' -# undefined method `remove_class1' for class `Nokogiri::XML::Node' -# undefined method `to_html1' for class `Nokogiri::XML::Node' -# undefined method `to_xhtml1' for class `Nokogiri::XML::Node' -# undefined method `to_xml1' for class `Nokogiri::XML::Node' -# undefined method `write_html_to1' for class `Nokogiri::XML::Node' -# undefined method `write_xhtml_to1' for class `Nokogiri::XML::Node' -# undefined method `write_xml_to1' for class `Nokogiri::XML::Node' -# wrong constant name << -# wrong constant name <=> -# wrong constant name == -# wrong constant name > -# uninitialized constant Nokogiri::XML::Node::Elem -# uninitialized constant Nokogiri::XML::Node::LOOKS_LIKE_XPATH -# wrong constant name [] -# wrong constant name []= -# wrong constant name accept -# wrong constant name add_child -# wrong constant name add_class -# wrong constant name add_namespace -# wrong constant name add_namespace_definition -# wrong constant name add_next_sibling -# wrong constant name add_previous_sibling -# wrong constant name after -# wrong constant name ancestors1 -# wrong constant name ancestors -# wrong constant name append_class -# wrong constant name attr -# wrong constant name attribute -# wrong constant name attribute_nodes -# wrong constant name attribute_with_ns -# wrong constant name attributes -# wrong constant name before -# wrong constant name canonicalize1 -# wrong constant name canonicalize2 -# wrong constant name canonicalize3 -# wrong constant name canonicalize -# wrong constant name cdata? -# wrong constant name child -# wrong constant name children -# wrong constant name children= -# wrong constant name classes -# wrong constant name comment? -# wrong constant name content -# wrong constant name content= -# wrong constant name create_external_subset -# wrong constant name create_internal_subset -# wrong constant name css_path -# wrong constant name decorate! -# wrong constant name default_namespace= -# wrong constant name delete -# wrong constant name description -# wrong constant name do_xinclude1 -# wrong constant name do_xinclude -# wrong constant name document -# wrong constant name document? -# wrong constant name dup -# wrong constant name each -# wrong constant name elem? -# wrong constant name element? -# wrong constant name element_children -# wrong constant name elements -# wrong constant name encode_special_chars -# wrong constant name external_subset -# wrong constant name first_element_child -# wrong constant name fragment -# wrong constant name fragment? -# wrong constant name get_attribute -# wrong constant name has_attribute? -# wrong constant name html? -# wrong constant name initialize -# wrong constant name inner_html -# wrong constant name inner_html= -# wrong constant name inner_text -# wrong constant name internal_subset -# wrong constant name key? -# wrong constant name keys -# wrong constant name lang -# wrong constant name lang= -# wrong constant name last_element_child -# wrong constant name line -# wrong constant name matches? -# wrong constant name name -# wrong constant name name= -# wrong constant name namespace -# wrong constant name namespace= -# wrong constant name namespace_definitions -# wrong constant name namespace_scopes -# wrong constant name namespaced_key? -# wrong constant name namespaces -# wrong constant name native_content= -# wrong constant name next -# wrong constant name next= -# wrong constant name next_element -# wrong constant name next_sibling -# wrong constant name node_name -# wrong constant name node_name= -# wrong constant name node_type -# wrong constant name parent -# wrong constant name parent= -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name path -# wrong constant name pointer_id -# wrong constant name prepend_child -# wrong constant name previous -# wrong constant name previous= -# wrong constant name previous_element -# wrong constant name previous_sibling -# wrong constant name processing_instruction? -# wrong constant name read_only? -# wrong constant name remove -# wrong constant name remove_attribute -# wrong constant name remove_class1 -# wrong constant name remove_class -# wrong constant name replace -# wrong constant name serialize -# wrong constant name set_attribute -# wrong constant name swap -# wrong constant name text -# wrong constant name text? -# wrong constant name to_html1 -# wrong constant name to_html -# wrong constant name to_str -# wrong constant name to_xhtml1 -# wrong constant name to_xhtml -# wrong constant name to_xml1 -# wrong constant name to_xml -# wrong constant name traverse -# wrong constant name type -# wrong constant name unlink -# wrong constant name values -# wrong constant name wrap -# wrong constant name write_html_to1 -# wrong constant name write_html_to -# wrong constant name write_to -# wrong constant name write_xhtml_to1 -# wrong constant name write_xhtml_to -# wrong constant name write_xml_to1 -# wrong constant name write_xml_to -# wrong constant name xml? -# wrong constant name -# undefined method `attr1' for class `Nokogiri::XML::NodeSet' -# undefined method `attribute1' for class `Nokogiri::XML::NodeSet' -# undefined method `first1' for class `Nokogiri::XML::NodeSet' -# undefined method `index1' for class `Nokogiri::XML::NodeSet' -# undefined method `initialize1' for class `Nokogiri::XML::NodeSet' -# undefined method `remove_class1' for class `Nokogiri::XML::NodeSet' -# undefined method `set1' for class `Nokogiri::XML::NodeSet' -# wrong constant name & -# wrong constant name + -# wrong constant name - -# wrong constant name << -# wrong constant name == -# wrong constant name > -# uninitialized constant Nokogiri::XML::NodeSet::Elem -# uninitialized constant Nokogiri::XML::NodeSet::LOOKS_LIKE_XPATH -# wrong constant name [] -# wrong constant name add_class -# wrong constant name after -# wrong constant name append_class -# wrong constant name attr1 -# wrong constant name attr -# wrong constant name attribute1 -# wrong constant name attribute -# wrong constant name before -# wrong constant name children -# wrong constant name clone -# wrong constant name delete -# wrong constant name document -# wrong constant name document= -# wrong constant name each -# wrong constant name empty? -# wrong constant name filter -# wrong constant name first1 -# wrong constant name first -# wrong constant name index1 -# wrong constant name index -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name inner_html -# wrong constant name inner_text -# wrong constant name last -# wrong constant name length -# wrong constant name pop -# wrong constant name push -# wrong constant name remove -# wrong constant name remove_attr -# wrong constant name remove_attribute -# wrong constant name remove_class1 -# wrong constant name remove_class -# wrong constant name reverse -# wrong constant name set1 -# wrong constant name set -# wrong constant name shift -# wrong constant name size -# wrong constant name slice -# wrong constant name text -# wrong constant name to_a -# wrong constant name to_ary -# wrong constant name to_html -# wrong constant name to_xhtml -# wrong constant name to_xml -# wrong constant name unlink -# wrong constant name wrap -# wrong constant name | -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name inspect -# wrong constant name pretty_print -# wrong constant name -# wrong constant name inspect -# wrong constant name pretty_print -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Nokogiri::XML::ParseOptions' -# wrong constant name compact -# wrong constant name compact? -# wrong constant name default_html -# wrong constant name default_html? -# wrong constant name default_xml -# wrong constant name default_xml? -# wrong constant name dtdattr -# wrong constant name dtdattr? -# wrong constant name dtdload -# wrong constant name dtdload? -# wrong constant name dtdvalid -# wrong constant name dtdvalid? -# wrong constant name huge -# wrong constant name huge? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name nobasefix -# wrong constant name nobasefix? -# wrong constant name noblanks -# wrong constant name noblanks? -# wrong constant name nocdata -# wrong constant name nocdata? -# wrong constant name nocompact -# wrong constant name nodefault_html -# wrong constant name nodefault_xml -# wrong constant name nodict -# wrong constant name nodict? -# wrong constant name nodtdattr -# wrong constant name nodtdload -# wrong constant name nodtdvalid -# wrong constant name noent -# wrong constant name noent? -# wrong constant name noerror -# wrong constant name noerror? -# wrong constant name nohuge -# wrong constant name nonet -# wrong constant name nonet? -# wrong constant name nonobasefix -# wrong constant name nonoblanks -# wrong constant name nonocdata -# wrong constant name nonodict -# wrong constant name nonoent -# wrong constant name nonoerror -# wrong constant name nononet -# wrong constant name nonowarning -# wrong constant name nonoxincnode -# wrong constant name nonsclean -# wrong constant name noold10 -# wrong constant name nopedantic -# wrong constant name norecover -# wrong constant name nosax1 -# wrong constant name nowarning -# wrong constant name nowarning? -# wrong constant name noxinclude -# wrong constant name noxincnode -# wrong constant name noxincnode? -# wrong constant name nsclean -# wrong constant name nsclean? -# wrong constant name old10 -# wrong constant name old10? -# wrong constant name options -# wrong constant name options= -# wrong constant name pedantic -# wrong constant name pedantic? -# wrong constant name recover -# wrong constant name recover? -# wrong constant name sax1 -# wrong constant name sax1? -# wrong constant name strict -# wrong constant name strict? -# wrong constant name to_i -# wrong constant name xinclude -# wrong constant name xinclude? -# wrong constant name -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::COMMENT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::DTD_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ENTITY_DECL -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ENTITY_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::Elem -# uninitialized constant Nokogiri::XML::ProcessingInstruction::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::ProcessingInstruction::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::ProcessingInstruction::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::ProcessingInstruction::NOTATION_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::PI_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::TEXT_NODE -# uninitialized constant Nokogiri::XML::ProcessingInstruction::XINCLUDE_END -# uninitialized constant Nokogiri::XML::ProcessingInstruction::XINCLUDE_START -# wrong constant name initialize -# wrong constant name -# undefined method `initialize1' for class `Nokogiri::XML::Reader' -# undefined method `initialize2' for class `Nokogiri::XML::Reader' -# uninitialized constant Nokogiri::XML::Reader::Elem -# wrong constant name attribute -# wrong constant name attribute_at -# wrong constant name attribute_count -# wrong constant name attribute_nodes -# wrong constant name attributes -# wrong constant name attributes? -# wrong constant name base_uri -# wrong constant name default? -# wrong constant name depth -# wrong constant name each -# wrong constant name empty_element? -# wrong constant name encoding -# wrong constant name errors -# wrong constant name errors= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name inner_xml -# wrong constant name lang -# wrong constant name local_name -# wrong constant name name -# wrong constant name namespace_uri -# wrong constant name namespaces -# wrong constant name node_type -# wrong constant name outer_xml -# wrong constant name prefix -# wrong constant name read -# wrong constant name self_closing? -# wrong constant name source -# wrong constant name state -# wrong constant name value -# wrong constant name value? -# wrong constant name xml_version -# wrong constant name -# wrong constant name from_io -# wrong constant name from_memory -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `end_element_namespace1' for class `Nokogiri::XML::SAX::Document' -# undefined method `end_element_namespace2' for class `Nokogiri::XML::SAX::Document' -# undefined method `start_element1' for class `Nokogiri::XML::SAX::Document' -# undefined method `start_element_namespace1' for class `Nokogiri::XML::SAX::Document' -# undefined method `start_element_namespace2' for class `Nokogiri::XML::SAX::Document' -# undefined method `start_element_namespace3' for class `Nokogiri::XML::SAX::Document' -# undefined method `start_element_namespace4' for class `Nokogiri::XML::SAX::Document' -# wrong constant name cdata_block -# wrong constant name characters -# wrong constant name comment -# wrong constant name end_document -# wrong constant name end_element -# wrong constant name end_element_namespace1 -# wrong constant name end_element_namespace2 -# wrong constant name end_element_namespace -# wrong constant name error -# wrong constant name processing_instruction -# wrong constant name start_document -# wrong constant name start_element1 -# wrong constant name start_element -# wrong constant name start_element_namespace1 -# wrong constant name start_element_namespace2 -# wrong constant name start_element_namespace3 -# wrong constant name start_element_namespace4 -# wrong constant name start_element_namespace -# wrong constant name warning -# wrong constant name xmldecl -# wrong constant name -# undefined method `initialize1' for class `Nokogiri::XML::SAX::Parser' -# undefined method `initialize2' for class `Nokogiri::XML::SAX::Parser' -# undefined method `parse_io1' for class `Nokogiri::XML::SAX::Parser' -# wrong constant name document -# wrong constant name document= -# wrong constant name encoding -# wrong constant name encoding= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name parse -# wrong constant name parse_file -# wrong constant name parse_io1 -# wrong constant name parse_io -# wrong constant name parse_memory -# wrong constant name -# wrong constant name column -# wrong constant name line -# wrong constant name parse_with -# wrong constant name recovery -# wrong constant name recovery= -# wrong constant name replace_entities -# wrong constant name replace_entities= -# undefined singleton method `new1' for `Nokogiri::XML::SAX::ParserContext' -# wrong constant name -# wrong constant name file -# wrong constant name io -# wrong constant name memory -# wrong constant name new1 -# wrong constant name new -# undefined method `<<1' for class `Nokogiri::XML::SAX::PushParser' -# undefined method `initialize1' for class `Nokogiri::XML::SAX::PushParser' -# undefined method `initialize2' for class `Nokogiri::XML::SAX::PushParser' -# undefined method `initialize3' for class `Nokogiri::XML::SAX::PushParser' -# undefined method `write1' for class `Nokogiri::XML::SAX::PushParser' -# wrong constant name <<1 -# wrong constant name << -# wrong constant name document -# wrong constant name document= -# wrong constant name finish -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name options -# wrong constant name options= -# wrong constant name replace_entities -# wrong constant name replace_entities= -# wrong constant name write1 -# wrong constant name write -# wrong constant name -# wrong constant name -# wrong constant name errors -# wrong constant name errors= -# wrong constant name valid? -# wrong constant name validate -# wrong constant name -# wrong constant name from_document -# wrong constant name new -# wrong constant name read_memory -# wrong constant name % -# wrong constant name / -# wrong constant name at -# wrong constant name at_css -# wrong constant name at_xpath -# wrong constant name css -# wrong constant name search -# wrong constant name xpath -# wrong constant name -# wrong constant name code -# wrong constant name column -# wrong constant name domain -# wrong constant name error? -# wrong constant name fatal? -# wrong constant name file -# wrong constant name int1 -# wrong constant name level -# wrong constant name line -# wrong constant name none? -# wrong constant name str1 -# wrong constant name str2 -# wrong constant name str3 -# wrong constant name warning? -# wrong constant name -# uninitialized constant Nokogiri::XML::Text::ATTRIBUTE_DECL -# uninitialized constant Nokogiri::XML::Text::ATTRIBUTE_NODE -# uninitialized constant Nokogiri::XML::Text::CDATA_SECTION_NODE -# uninitialized constant Nokogiri::XML::Text::COMMENT_NODE -# uninitialized constant Nokogiri::XML::Text::DOCB_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Text::DOCUMENT_FRAG_NODE -# uninitialized constant Nokogiri::XML::Text::DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Text::DOCUMENT_TYPE_NODE -# uninitialized constant Nokogiri::XML::Text::DTD_NODE -# uninitialized constant Nokogiri::XML::Text::ELEMENT_DECL -# uninitialized constant Nokogiri::XML::Text::ELEMENT_NODE -# uninitialized constant Nokogiri::XML::Text::ENTITY_DECL -# uninitialized constant Nokogiri::XML::Text::ENTITY_NODE -# uninitialized constant Nokogiri::XML::Text::ENTITY_REF_NODE -# uninitialized constant Nokogiri::XML::Text::Elem -# uninitialized constant Nokogiri::XML::Text::HTML_DOCUMENT_NODE -# uninitialized constant Nokogiri::XML::Text::IMPLIED_XPATH_CONTEXTS -# uninitialized constant Nokogiri::XML::Text::LOOKS_LIKE_XPATH -# uninitialized constant Nokogiri::XML::Text::NAMESPACE_DECL -# uninitialized constant Nokogiri::XML::Text::NOTATION_NODE -# uninitialized constant Nokogiri::XML::Text::PI_NODE -# uninitialized constant Nokogiri::XML::Text::TEXT_NODE -# uninitialized constant Nokogiri::XML::Text::XINCLUDE_END -# uninitialized constant Nokogiri::XML::Text::XINCLUDE_START -# wrong constant name -# wrong constant name -# wrong constant name document -# wrong constant name document= -# wrong constant name -# wrong constant name -# wrong constant name evaluate -# wrong constant name register_namespaces -# wrong constant name register_ns -# wrong constant name register_variable -# wrong constant name -# wrong constant name new -# undefined singleton method `Reader1' for `Nokogiri::XML' -# undefined singleton method `Reader2' for `Nokogiri::XML' -# undefined singleton method `Reader3' for `Nokogiri::XML' -# undefined singleton method `parse1' for `Nokogiri::XML' -# undefined singleton method `parse2' for `Nokogiri::XML' -# undefined singleton method `parse3' for `Nokogiri::XML' -# wrong constant name -# wrong constant name Reader1 -# wrong constant name Reader2 -# wrong constant name Reader3 -# wrong constant name fragment -# wrong constant name parse1 -# wrong constant name parse2 -# wrong constant name parse3 -# wrong constant name parse -# wrong constant name -# undefined method `apply_to1' for class `Nokogiri::XSLT::Stylesheet' -# wrong constant name apply_to1 -# wrong constant name apply_to -# wrong constant name serialize -# wrong constant name transform -# wrong constant name -# wrong constant name parse_stylesheet_doc -# undefined singleton method `parse1' for `Nokogiri::XSLT' -# wrong constant name -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name quote_params -# wrong constant name register -# undefined singleton method `HTML1' for `Nokogiri' -# undefined singleton method `HTML2' for `Nokogiri' -# undefined singleton method `HTML3' for `Nokogiri' -# undefined singleton method `XML1' for `Nokogiri' -# undefined singleton method `XML2' for `Nokogiri' -# undefined singleton method `XML3' for `Nokogiri' -# undefined singleton method `XSLT1' for `Nokogiri' -# undefined singleton method `make1' for `Nokogiri' -# undefined singleton method `make2' for `Nokogiri' -# undefined singleton method `parse1' for `Nokogiri' -# undefined singleton method `parse2' for `Nokogiri' -# undefined singleton method `parse3' for `Nokogiri' -# wrong constant name -# wrong constant name HTML1 -# wrong constant name HTML2 -# wrong constant name HTML3 -# uninitialized constant Nokogiri::Slop -# wrong constant name XML1 -# wrong constant name XML2 -# wrong constant name XML3 -# wrong constant name XSLT1 -# wrong constant name install_default_aliases -# wrong constant name jruby? -# wrong constant name make1 -# wrong constant name make2 -# wrong constant name make -# wrong constant name parse1 -# wrong constant name parse2 -# wrong constant name parse3 -# wrong constant name parse -# wrong constant name uses_libxml? # wrong constant name byte # wrong constant name bytes # wrong constant name day @@ -12378,7 +7916,6 @@ # wrong constant name as_json1 # wrong constant name as_json # wrong constant name blank? -# wrong constant name dclone # wrong constant name duplicable? # wrong constant name html_safe? # wrong constant name instance_values @@ -12450,737 +7987,6 @@ # uninitialized constant PStore # uninitialized constant PTY # uninitialized constant PTY -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name exception -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name next -# wrong constant name pack -# wrong constant name size -# wrong constant name unpack -# wrong constant name -# wrong constant name -# wrong constant name physical_processor_count -# wrong constant name processor_count -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name kill -# wrong constant name kill_on_ctrl_c -# wrong constant name close_pipes -# wrong constant name initialize -# wrong constant name pid -# wrong constant name read -# wrong constant name stop -# wrong constant name thread -# wrong constant name thread= -# wrong constant name work -# wrong constant name write -# wrong constant name -# undefined singleton method `each1' for `Parallel' -# undefined singleton method `each_with_index1' for `Parallel' -# undefined singleton method `in_processes1' for `Parallel' -# undefined singleton method `in_threads1' for `Parallel' -# undefined singleton method `map1' for `Parallel' -# undefined singleton method `map_with_index1' for `Parallel' -# wrong constant name -# wrong constant name all? -# wrong constant name any? -# wrong constant name each1 -# wrong constant name each -# wrong constant name each_with_index1 -# wrong constant name each_with_index -# wrong constant name flat_map -# wrong constant name in_processes1 -# wrong constant name in_processes -# wrong constant name in_threads1 -# wrong constant name in_threads -# wrong constant name map1 -# wrong constant name map -# wrong constant name map_with_index1 -# wrong constant name map_with_index -# wrong constant name worker_number -# wrong constant name worker_number= -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name run -# wrong constant name -# undefined singleton method `by_scenarios1' for `ParallelTests::Grouper' -# undefined singleton method `in_even_groups_by_size1' for `ParallelTests::Grouper' -# wrong constant name -# wrong constant name by_scenarios1 -# wrong constant name by_scenarios -# wrong constant name by_steps -# wrong constant name in_even_groups_by_size1 -# wrong constant name in_even_groups_by_size -# wrong constant name add -# wrong constant name all -# wrong constant name count -# wrong constant name delete -# wrong constant name file_path -# wrong constant name initialize -# wrong constant name mutex -# wrong constant name -# wrong constant name -# wrong constant name bundler_enabled? -# wrong constant name delta -# wrong constant name determine_number_of_processes -# wrong constant name first_process? -# wrong constant name last_process? -# wrong constant name now -# wrong constant name number_of_running_processes -# wrong constant name pid_file_path -# wrong constant name pids -# wrong constant name stop_all_processes -# wrong constant name wait_for_other_processes_to_finish -# wrong constant name with_pid_file -# wrong constant name with_ruby_binary -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name loc -# wrong constant name location -# wrong constant name -# wrong constant name on_alias -# wrong constant name on_and -# wrong constant name on_and_asgn -# wrong constant name on_arg -# wrong constant name on_arg_expr -# wrong constant name on_args -# wrong constant name on_argument -# wrong constant name on_array -# wrong constant name on_array_pattern -# wrong constant name on_array_pattern_with_tail -# wrong constant name on_back_ref -# wrong constant name on_begin -# wrong constant name on_block -# wrong constant name on_block_pass -# wrong constant name on_blockarg -# wrong constant name on_blockarg_expr -# wrong constant name on_break -# wrong constant name on_case -# wrong constant name on_case_match -# wrong constant name on_casgn -# wrong constant name on_class -# wrong constant name on_const -# wrong constant name on_const_pattern -# wrong constant name on_csend -# wrong constant name on_cvar -# wrong constant name on_cvasgn -# wrong constant name on_def -# wrong constant name on_def_e -# wrong constant name on_defined? -# wrong constant name on_defs -# wrong constant name on_defs_e -# wrong constant name on_dstr -# wrong constant name on_dsym -# wrong constant name on_eflipflop -# wrong constant name on_empty_else -# wrong constant name on_ensure -# wrong constant name on_erange -# wrong constant name on_for -# wrong constant name on_gvar -# wrong constant name on_gvasgn -# wrong constant name on_hash -# wrong constant name on_hash_pattern -# wrong constant name on_if -# wrong constant name on_if_guard -# wrong constant name on_iflipflop -# wrong constant name on_in_match -# wrong constant name on_in_pattern -# wrong constant name on_index -# wrong constant name on_indexasgn -# wrong constant name on_irange -# wrong constant name on_ivar -# wrong constant name on_ivasgn -# wrong constant name on_kwarg -# wrong constant name on_kwbegin -# wrong constant name on_kwoptarg -# wrong constant name on_kwrestarg -# wrong constant name on_kwsplat -# wrong constant name on_lambda -# wrong constant name on_lvar -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_match_alt -# wrong constant name on_match_as -# wrong constant name on_match_current_line -# wrong constant name on_match_rest -# wrong constant name on_match_var -# wrong constant name on_match_with_lvasgn -# wrong constant name on_mlhs -# wrong constant name on_module -# wrong constant name on_mrasgn -# wrong constant name on_next -# wrong constant name on_not -# wrong constant name on_nth_ref -# wrong constant name on_numblock -# wrong constant name on_op_asgn -# wrong constant name on_optarg -# wrong constant name on_or -# wrong constant name on_or_asgn -# wrong constant name on_pair -# wrong constant name on_pin -# wrong constant name on_postexe -# wrong constant name on_preexe -# wrong constant name on_procarg0 -# wrong constant name on_rasgn -# wrong constant name on_redo -# wrong constant name on_regexp -# wrong constant name on_resbody -# wrong constant name on_rescue -# wrong constant name on_restarg -# wrong constant name on_restarg_expr -# wrong constant name on_retry -# wrong constant name on_return -# wrong constant name on_sclass -# wrong constant name on_send -# wrong constant name on_shadowarg -# wrong constant name on_splat -# wrong constant name on_super -# wrong constant name on_undef -# wrong constant name on_unless_guard -# wrong constant name on_until -# wrong constant name on_until_post -# wrong constant name on_var -# wrong constant name on_vasgn -# wrong constant name on_when -# wrong constant name on_while -# wrong constant name on_while_post -# wrong constant name on_xstr -# wrong constant name on_yield -# wrong constant name process_argument_node -# wrong constant name process_regular_node -# wrong constant name process_var_asgn_node -# wrong constant name process_variable_node -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Parser::Base' -# undefined method `tokenize1' for class `Parser::Base' -# uninitialized constant Parser::Base::Racc_Main_Parsing_Routine -# uninitialized constant Parser::Base::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Base::Racc_Runtime_Core_Revision -# uninitialized constant Parser::Base::Racc_Runtime_Core_Revision_C -# uninitialized constant Parser::Base::Racc_Runtime_Core_Revision_R -# uninitialized constant Parser::Base::Racc_Runtime_Core_Version -# uninitialized constant Parser::Base::Racc_Runtime_Core_Version_C -# uninitialized constant Parser::Base::Racc_Runtime_Core_Version_R -# uninitialized constant Parser::Base::Racc_Runtime_Revision -# uninitialized constant Parser::Base::Racc_Runtime_Type -# uninitialized constant Parser::Base::Racc_Runtime_Version -# uninitialized constant Parser::Base::Racc_YY_Parse_Method -# wrong constant name builder -# wrong constant name context -# wrong constant name current_arg_stack -# wrong constant name diagnostics -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name max_numparam_stack -# wrong constant name parse -# wrong constant name parse_with_comments -# wrong constant name pattern_hash_keys -# wrong constant name pattern_variables -# wrong constant name reset -# wrong constant name source_buffer -# wrong constant name static_env -# wrong constant name tokenize1 -# wrong constant name tokenize -# undefined singleton method `parse1' for `Parser::Base' -# undefined singleton method `parse2' for `Parser::Base' -# undefined singleton method `parse_with_comments1' for `Parser::Base' -# undefined singleton method `parse_with_comments2' for `Parser::Base' -# wrong constant name -# wrong constant name default_parser -# wrong constant name parse1 -# wrong constant name parse2 -# wrong constant name parse -# wrong constant name parse_file -# wrong constant name parse_file_with_comments -# wrong constant name parse_with_comments1 -# wrong constant name parse_with_comments2 -# wrong constant name parse_with_comments -# wrong constant name -# undefined method `args1' for class `Parser::Builders::Default' -# undefined method `begin_body1' for class `Parser::Builders::Default' -# undefined method `begin_body2' for class `Parser::Builders::Default' -# undefined method `begin_body3' for class `Parser::Builders::Default' -# undefined method `begin_body4' for class `Parser::Builders::Default' -# undefined method `begin_body5' for class `Parser::Builders::Default' -# undefined method `call_method1' for class `Parser::Builders::Default' -# undefined method `call_method2' for class `Parser::Builders::Default' -# undefined method `call_method3' for class `Parser::Builders::Default' -# undefined method `keyword_cmd1' for class `Parser::Builders::Default' -# undefined method `keyword_cmd2' for class `Parser::Builders::Default' -# undefined method `keyword_cmd3' for class `Parser::Builders::Default' -# undefined method `kwrestarg1' for class `Parser::Builders::Default' -# undefined method `match_rest1' for class `Parser::Builders::Default' -# undefined method `not_op1' for class `Parser::Builders::Default' -# undefined method `not_op2' for class `Parser::Builders::Default' -# undefined method `not_op3' for class `Parser::Builders::Default' -# undefined method `objc_restarg1' for class `Parser::Builders::Default' -# undefined method `restarg1' for class `Parser::Builders::Default' -# undefined method `restarg_expr1' for class `Parser::Builders::Default' -# undefined method `splat1' for class `Parser::Builders::Default' -# wrong constant name __ENCODING__ -# wrong constant name __FILE__ -# wrong constant name __LINE__ -# wrong constant name accessible -# wrong constant name alias -# wrong constant name arg -# wrong constant name arg_expr -# wrong constant name args1 -# wrong constant name args -# wrong constant name array -# wrong constant name array_pattern -# wrong constant name assign -# wrong constant name assignable -# wrong constant name associate -# wrong constant name attr_asgn -# wrong constant name back_ref -# wrong constant name begin -# wrong constant name begin_body1 -# wrong constant name begin_body2 -# wrong constant name begin_body3 -# wrong constant name begin_body4 -# wrong constant name begin_body5 -# wrong constant name begin_body -# wrong constant name begin_keyword -# wrong constant name binary_op -# wrong constant name block -# wrong constant name block_pass -# wrong constant name blockarg -# wrong constant name blockarg_expr -# wrong constant name call_lambda -# wrong constant name call_method1 -# wrong constant name call_method2 -# wrong constant name call_method3 -# wrong constant name call_method -# wrong constant name call_type_for_dot -# wrong constant name case -# wrong constant name case_match -# wrong constant name character -# wrong constant name complex -# wrong constant name compstmt -# wrong constant name condition -# wrong constant name condition_mod -# wrong constant name const -# wrong constant name const_fetch -# wrong constant name const_global -# wrong constant name const_op_assignable -# wrong constant name const_pattern -# wrong constant name cvar -# wrong constant name dedent_string -# wrong constant name def_class -# wrong constant name def_endless_method -# wrong constant name def_endless_singleton -# wrong constant name def_method -# wrong constant name def_module -# wrong constant name def_sclass -# wrong constant name def_singleton -# wrong constant name emit_file_line_as_literals -# wrong constant name emit_file_line_as_literals= -# wrong constant name false -# wrong constant name float -# wrong constant name for -# wrong constant name forward_args -# wrong constant name forwarded_args -# wrong constant name gvar -# wrong constant name hash_pattern -# wrong constant name ident -# wrong constant name if_guard -# wrong constant name in_match -# wrong constant name in_pattern -# wrong constant name index -# wrong constant name index_asgn -# wrong constant name integer -# wrong constant name ivar -# wrong constant name keyword_cmd1 -# wrong constant name keyword_cmd2 -# wrong constant name keyword_cmd3 -# wrong constant name keyword_cmd -# wrong constant name kwarg -# wrong constant name kwnilarg -# wrong constant name kwoptarg -# wrong constant name kwrestarg1 -# wrong constant name kwrestarg -# wrong constant name kwsplat -# wrong constant name logical_op -# wrong constant name loop -# wrong constant name loop_mod -# wrong constant name match_alt -# wrong constant name match_as -# wrong constant name match_hash_var -# wrong constant name match_hash_var_from_str -# wrong constant name match_label -# wrong constant name match_nil_pattern -# wrong constant name match_op -# wrong constant name match_pair -# wrong constant name match_rest1 -# wrong constant name match_rest -# wrong constant name match_var -# wrong constant name match_with_trailing_comma -# wrong constant name multi_assign -# wrong constant name multi_lhs -# wrong constant name multi_rassign -# wrong constant name nil -# wrong constant name not_op1 -# wrong constant name not_op2 -# wrong constant name not_op3 -# wrong constant name not_op -# wrong constant name nth_ref -# wrong constant name numargs -# wrong constant name objc_kwarg -# wrong constant name objc_restarg1 -# wrong constant name objc_restarg -# wrong constant name objc_varargs -# wrong constant name op_assign -# wrong constant name optarg -# wrong constant name pair -# wrong constant name pair_keyword -# wrong constant name pair_list_18 -# wrong constant name pair_quoted -# wrong constant name parser -# wrong constant name parser= -# wrong constant name pin -# wrong constant name postexe -# wrong constant name preexe -# wrong constant name procarg0 -# wrong constant name range_exclusive -# wrong constant name range_inclusive -# wrong constant name rassign -# wrong constant name rational -# wrong constant name regexp_compose -# wrong constant name regexp_options -# wrong constant name rescue_body -# wrong constant name restarg1 -# wrong constant name restarg -# wrong constant name restarg_expr1 -# wrong constant name restarg_expr -# wrong constant name self -# wrong constant name shadowarg -# wrong constant name splat1 -# wrong constant name splat -# wrong constant name string -# wrong constant name string_compose -# wrong constant name string_internal -# wrong constant name symbol -# wrong constant name symbol_compose -# wrong constant name symbol_internal -# wrong constant name symbols_compose -# wrong constant name ternary -# wrong constant name true -# wrong constant name unary_num -# wrong constant name unary_op -# wrong constant name undef_method -# wrong constant name unless_guard -# wrong constant name when -# wrong constant name word -# wrong constant name words_compose -# wrong constant name xstring_compose -# wrong constant name -# wrong constant name emit_arg_inside_procarg0 -# wrong constant name emit_arg_inside_procarg0= -# wrong constant name emit_encoding -# wrong constant name emit_encoding= -# wrong constant name emit_index -# wrong constant name emit_index= -# wrong constant name emit_lambda -# wrong constant name emit_lambda= -# wrong constant name emit_procarg0 -# wrong constant name emit_procarg0= -# wrong constant name modernize -# wrong constant name -# wrong constant name -# wrong constant name class_definition_allowed? -# wrong constant name dynamic_const_definition_allowed? -# wrong constant name in_block? -# wrong constant name in_class? -# wrong constant name in_dynamic_block? -# wrong constant name in_lambda? -# wrong constant name indirectly_in_def? -# wrong constant name module_definition_allowed? -# wrong constant name pop -# wrong constant name push -# wrong constant name reset -# wrong constant name stack -# wrong constant name -# wrong constant name pop -# wrong constant name push -# wrong constant name reset -# wrong constant name set -# wrong constant name stack -# wrong constant name top -# wrong constant name -# wrong constant name warn_of_deprecation -# wrong constant name warned_of_deprecation= -# wrong constant name -# undefined method `initialize1' for class `Parser::Diagnostic' -# wrong constant name -# wrong constant name arguments -# wrong constant name highlights -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name level -# wrong constant name location -# wrong constant name message -# wrong constant name reason -# wrong constant name render -# undefined method `initialize1' for class `Parser::Diagnostic::Engine' -# wrong constant name all_errors_are_fatal -# wrong constant name all_errors_are_fatal= -# wrong constant name consumer -# wrong constant name consumer= -# wrong constant name ignore? -# wrong constant name ignore_warnings -# wrong constant name ignore_warnings= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name process -# wrong constant name raise? -# wrong constant name -# wrong constant name -# undefined method `diagnostic1' for class `Parser::Lexer' -# undefined method `diagnostic2' for class `Parser::Lexer' -# undefined method `diagnostic3' for class `Parser::Lexer' -# undefined method `emit1' for class `Parser::Lexer' -# undefined method `emit2' for class `Parser::Lexer' -# undefined method `emit3' for class `Parser::Lexer' -# undefined method `emit_comment1' for class `Parser::Lexer' -# undefined method `emit_comment2' for class `Parser::Lexer' -# undefined method `emit_do1' for class `Parser::Lexer' -# undefined method `emit_table1' for class `Parser::Lexer' -# undefined method `emit_table2' for class `Parser::Lexer' -# undefined method `range1' for class `Parser::Lexer' -# undefined method `range2' for class `Parser::Lexer' -# undefined method `reset1' for class `Parser::Lexer' -# undefined method `tok1' for class `Parser::Lexer' -# undefined method `tok2' for class `Parser::Lexer' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name advance -# wrong constant name arg_or_cmdarg -# wrong constant name cmdarg -# wrong constant name cmdarg= -# wrong constant name command_start -# wrong constant name command_start= -# wrong constant name comments -# wrong constant name comments= -# wrong constant name cond -# wrong constant name cond= -# wrong constant name context -# wrong constant name context= -# wrong constant name dedent_level -# wrong constant name diagnostic1 -# wrong constant name diagnostic2 -# wrong constant name diagnostic3 -# wrong constant name diagnostic -# wrong constant name diagnostics -# wrong constant name diagnostics= -# wrong constant name emit1 -# wrong constant name emit2 -# wrong constant name emit3 -# wrong constant name emit -# wrong constant name emit_comment1 -# wrong constant name emit_comment2 -# wrong constant name emit_comment -# wrong constant name emit_do1 -# wrong constant name emit_do -# wrong constant name emit_table1 -# wrong constant name emit_table2 -# wrong constant name emit_table -# wrong constant name encode_escape -# wrong constant name encoding -# wrong constant name eof_codepoint? -# wrong constant name force_utf32 -# wrong constant name force_utf32= -# wrong constant name in_kwarg -# wrong constant name in_kwarg= -# wrong constant name initialize -# wrong constant name literal -# wrong constant name next_state_for_literal -# wrong constant name pop_cmdarg -# wrong constant name pop_cond -# wrong constant name pop_literal -# wrong constant name push_cmdarg -# wrong constant name push_cond -# wrong constant name push_literal -# wrong constant name range1 -# wrong constant name range2 -# wrong constant name range -# wrong constant name reset1 -# wrong constant name reset -# wrong constant name source_buffer -# wrong constant name source_buffer= -# wrong constant name stack_pop -# wrong constant name state -# wrong constant name state= -# wrong constant name static_env -# wrong constant name static_env= -# wrong constant name tok1 -# wrong constant name tok2 -# wrong constant name tok -# wrong constant name tokens -# wrong constant name tokens= -# wrong constant name version? -# wrong constant name dedent -# wrong constant name initialize -# wrong constant name interrupt -# wrong constant name -# undefined method `initialize1' for class `Parser::Lexer::Literal' -# undefined method `initialize2' for class `Parser::Lexer::Literal' -# undefined method `initialize3' for class `Parser::Lexer::Literal' -# undefined method `initialize4' for class `Parser::Lexer::Literal' -# undefined method `nest_and_try_closing1' for class `Parser::Lexer::Literal' -# wrong constant name backslash_delimited? -# wrong constant name clear_buffer -# wrong constant name coerce_encoding -# wrong constant name dedent_level -# wrong constant name delimiter? -# wrong constant name emit -# wrong constant name emit_start_tok -# wrong constant name end_interp_brace_and_try_closing -# wrong constant name extend_content -# wrong constant name extend_space -# wrong constant name extend_string -# wrong constant name flush_string -# wrong constant name heredoc? -# wrong constant name heredoc_e -# wrong constant name infer_indent_level -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize -# wrong constant name interpolate? -# wrong constant name munge_escape? -# wrong constant name nest_and_try_closing1 -# wrong constant name nest_and_try_closing -# wrong constant name plain_heredoc? -# wrong constant name regexp? -# wrong constant name saved_herebody_s -# wrong constant name saved_herebody_s= -# wrong constant name squiggly_heredoc? -# wrong constant name start_interp_brace -# wrong constant name str_s -# wrong constant name supports_line_continuation_via_slash? -# wrong constant name type -# wrong constant name words? -# wrong constant name -# wrong constant name active? -# wrong constant name clear -# wrong constant name empty? -# wrong constant name initialize -# wrong constant name lexpop -# wrong constant name pop -# wrong constant name push -# wrong constant name -# wrong constant name -# wrong constant name lex_en_expr_arg -# wrong constant name lex_en_expr_arg= -# wrong constant name lex_en_expr_beg -# wrong constant name lex_en_expr_beg= -# wrong constant name lex_en_expr_cmdarg -# wrong constant name lex_en_expr_cmdarg= -# wrong constant name lex_en_expr_dot -# wrong constant name lex_en_expr_dot= -# wrong constant name lex_en_expr_end -# wrong constant name lex_en_expr_end= -# wrong constant name lex_en_expr_endarg -# wrong constant name lex_en_expr_endarg= -# wrong constant name lex_en_expr_endfn -# wrong constant name lex_en_expr_endfn= -# wrong constant name lex_en_expr_fname -# wrong constant name lex_en_expr_fname= -# wrong constant name lex_en_expr_labelarg -# wrong constant name lex_en_expr_labelarg= -# wrong constant name lex_en_expr_mid -# wrong constant name lex_en_expr_mid= -# wrong constant name lex_en_expr_value -# wrong constant name lex_en_expr_value= -# wrong constant name lex_en_expr_variable -# wrong constant name lex_en_expr_variable= -# wrong constant name lex_en_interp_backslash_delimited -# wrong constant name lex_en_interp_backslash_delimited= -# wrong constant name lex_en_interp_backslash_delimited_words -# wrong constant name lex_en_interp_backslash_delimited_words= -# wrong constant name lex_en_interp_string -# wrong constant name lex_en_interp_string= -# wrong constant name lex_en_interp_words -# wrong constant name lex_en_interp_words= -# wrong constant name lex_en_leading_dot -# wrong constant name lex_en_leading_dot= -# wrong constant name lex_en_line_begin -# wrong constant name lex_en_line_begin= -# wrong constant name lex_en_line_comment -# wrong constant name lex_en_line_comment= -# wrong constant name lex_en_plain_backslash_delimited -# wrong constant name lex_en_plain_backslash_delimited= -# wrong constant name lex_en_plain_backslash_delimited_words -# wrong constant name lex_en_plain_backslash_delimited_words= -# wrong constant name lex_en_plain_string -# wrong constant name lex_en_plain_string= -# wrong constant name lex_en_plain_words -# wrong constant name lex_en_plain_words= -# wrong constant name lex_en_regexp_modifiers -# wrong constant name lex_en_regexp_modifiers= -# wrong constant name lex_error -# wrong constant name lex_error= -# wrong constant name lex_start -# wrong constant name lex_start= -# wrong constant name has_numparams? -# wrong constant name has_ordinary_params! -# wrong constant name has_ordinary_params? -# wrong constant name pop -# wrong constant name push -# wrong constant name register -# wrong constant name stack -# wrong constant name top -# wrong constant name -# wrong constant name -# wrong constant name compile -# wrong constant name -# wrong constant name assignment? -# wrong constant name initialize -# wrong constant name insert_after -# wrong constant name insert_before -# wrong constant name remove -# wrong constant name replace -# wrong constant name rewrite -# wrong constant name wrap -# wrong constant name # uninitialized constant Parser::Ruby24::Racc_Main_Parsing_Routine # uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Id_C # uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Revision @@ -14079,333 +8885,6 @@ # wrong constant name default_encoding # wrong constant name version # wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Parser::Source::Buffer' -# undefined method `initialize2' for class `Parser::Source::Buffer' -# wrong constant name column_for_position -# wrong constant name decompose_position -# wrong constant name first_line -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name last_line -# wrong constant name line_for_position -# wrong constant name line_range -# wrong constant name name -# wrong constant name raw_source= -# wrong constant name read -# wrong constant name slice -# wrong constant name source -# wrong constant name source= -# wrong constant name source_line -# wrong constant name source_lines -# wrong constant name source_range -# wrong constant name -# wrong constant name recognize_encoding -# wrong constant name reencode_string -# wrong constant name == -# wrong constant name -# wrong constant name document? -# wrong constant name initialize -# wrong constant name inline? -# wrong constant name loc -# wrong constant name location -# wrong constant name text -# wrong constant name type -# wrong constant name associate -# wrong constant name associate_locations -# wrong constant name initialize -# wrong constant name skip_directives -# wrong constant name skip_directives= -# wrong constant name -# wrong constant name -# wrong constant name associate -# wrong constant name associate_locations -# wrong constant name == -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name column -# wrong constant name expression -# wrong constant name first_line -# wrong constant name initialize -# wrong constant name last_column -# wrong constant name last_line -# wrong constant name line -# wrong constant name node -# wrong constant name node= -# wrong constant name to_hash -# wrong constant name update_expression -# wrong constant name with -# wrong constant name with_expression -# wrong constant name begin -# wrong constant name end -# wrong constant name initialize -# wrong constant name -# wrong constant name begin -# wrong constant name else -# wrong constant name end -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name -# wrong constant name double_colon -# wrong constant name initialize -# wrong constant name name -# wrong constant name operator -# wrong constant name update_operator -# wrong constant name with_operator -# wrong constant name -# wrong constant name end -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name name -# wrong constant name operator -# wrong constant name -# wrong constant name assignment -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name name -# wrong constant name operator -# wrong constant name -# wrong constant name begin -# wrong constant name end -# wrong constant name in -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name -# wrong constant name heredoc_body -# wrong constant name heredoc_end -# wrong constant name initialize -# wrong constant name -# wrong constant name begin -# wrong constant name end -# wrong constant name initialize -# wrong constant name operator -# wrong constant name update_operator -# wrong constant name with_operator -# wrong constant name -# wrong constant name begin -# wrong constant name end -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name -# wrong constant name argument -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name operator -# wrong constant name -# wrong constant name initialize -# wrong constant name operator -# wrong constant name -# wrong constant name assoc -# wrong constant name begin -# wrong constant name initialize -# wrong constant name keyword -# wrong constant name -# wrong constant name begin -# wrong constant name dot -# wrong constant name end -# wrong constant name initialize -# wrong constant name operator -# wrong constant name selector -# wrong constant name update_operator -# wrong constant name with_operator -# wrong constant name -# wrong constant name colon -# wrong constant name initialize -# wrong constant name question -# wrong constant name -# undefined method `initialize1' for class `Parser::Source::Map::Variable' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name name -# wrong constant name operator -# wrong constant name update_operator -# wrong constant name with_operator -# wrong constant name -# wrong constant name -# undefined method `adjust1' for class `Parser::Source::Range' -# undefined method `adjust2' for class `Parser::Source::Range' -# undefined method `with1' for class `Parser::Source::Range' -# undefined method `with2' for class `Parser::Source::Range' -# wrong constant name <=> -# wrong constant name adjust1 -# wrong constant name adjust2 -# wrong constant name adjust -# wrong constant name begin -# wrong constant name begin_pos -# wrong constant name column -# wrong constant name column_range -# wrong constant name contained? -# wrong constant name contains? -# wrong constant name crossing? -# wrong constant name disjoint? -# wrong constant name empty? -# wrong constant name end -# wrong constant name end_pos -# wrong constant name first_line -# wrong constant name initialize -# wrong constant name intersect -# wrong constant name is? -# wrong constant name join -# wrong constant name last_column -# wrong constant name last_line -# wrong constant name length -# wrong constant name line -# wrong constant name overlaps? -# wrong constant name resize -# wrong constant name size -# wrong constant name source -# wrong constant name source_buffer -# wrong constant name source_line -# wrong constant name to_a -# wrong constant name to_range -# wrong constant name with1 -# wrong constant name with2 -# wrong constant name with -# wrong constant name -# wrong constant name -# wrong constant name diagnostics -# wrong constant name initialize -# wrong constant name insert_after -# wrong constant name insert_after_multi -# wrong constant name insert_before -# wrong constant name insert_before_multi -# wrong constant name process -# wrong constant name remove -# wrong constant name replace -# wrong constant name source_buffer -# wrong constant name transaction -# wrong constant name wrap -# undefined method `initialize1' for class `Parser::Source::Rewriter::Action' -# undefined method `initialize2' for class `Parser::Source::Rewriter::Action' -# undefined method `initialize3' for class `Parser::Source::Rewriter::Action' -# wrong constant name <=> -# wrong constant name allow_multiple_insertions -# wrong constant name allow_multiple_insertions? -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name order -# wrong constant name range -# wrong constant name replacement -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Parser::Source::TreeRewriter' -# undefined method `initialize2' for class `Parser::Source::TreeRewriter' -# undefined method `initialize3' for class `Parser::Source::TreeRewriter' -# wrong constant name -# wrong constant name action_root -# wrong constant name diagnostics -# wrong constant name empty? -# wrong constant name in_transaction? -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name insert_after -# wrong constant name insert_after_multi -# wrong constant name insert_before -# wrong constant name insert_before_multi -# wrong constant name merge -# wrong constant name merge! -# wrong constant name process -# wrong constant name remove -# wrong constant name replace -# wrong constant name source_buffer -# wrong constant name transaction -# wrong constant name wrap -# undefined method `bsearch_child_index1' for class `Parser::Source::TreeRewriter::Action' -# undefined method `initialize1' for class `Parser::Source::TreeRewriter::Action' -# undefined method `initialize2' for class `Parser::Source::TreeRewriter::Action' -# undefined method `initialize3' for class `Parser::Source::TreeRewriter::Action' -# undefined method `initialize4' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with1' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with2' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with3' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with4' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with5' for class `Parser::Source::TreeRewriter::Action' -# undefined method `with6' for class `Parser::Source::TreeRewriter::Action' -# wrong constant name analyse_hierarchy -# wrong constant name bsearch_child_index1 -# wrong constant name bsearch_child_index -# wrong constant name call_enforcer_for_merge -# wrong constant name check_fusible -# wrong constant name children -# wrong constant name combine -# wrong constant name combine_children -# wrong constant name do_combine -# wrong constant name empty? -# wrong constant name fuse_deletions -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize -# wrong constant name insert_after -# wrong constant name insert_before -# wrong constant name insertion? -# wrong constant name merge -# wrong constant name ordered_replacements -# wrong constant name place_in_hierarchy -# wrong constant name range -# wrong constant name replacement -# wrong constant name swallow -# wrong constant name with1 -# wrong constant name with2 -# wrong constant name with3 -# wrong constant name with4 -# wrong constant name with5 -# wrong constant name with6 -# wrong constant name with -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name declare -# wrong constant name declare_forward_args -# wrong constant name declared? -# wrong constant name declared_forward_args? -# wrong constant name extend_dynamic -# wrong constant name extend_static -# wrong constant name reset -# wrong constant name unextend -# wrong constant name -# wrong constant name diagnostic -# wrong constant name initialize -# wrong constant name -# wrong constant name assignment? -# wrong constant name insert_after -# wrong constant name insert_before -# wrong constant name remove -# wrong constant name replace -# wrong constant name rewrite -# wrong constant name wrap -# wrong constant name -# wrong constant name declare -# wrong constant name declared? -# wrong constant name pop -# wrong constant name push -# wrong constant name reset -# wrong constant name -# wrong constant name # undefined method `children1' for class `Pathname' # undefined method `find1' for class `Pathname' # wrong constant name children1 @@ -14413,81 +8892,6 @@ # wrong constant name fnmatch? # wrong constant name glob # wrong constant name make_symlink -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `save_plist1' for module `Plist::Emit' -# undefined method `to_plist1' for module `Plist::Emit' -# undefined method `to_plist2' for module `Plist::Emit' -# wrong constant name save_plist1 -# wrong constant name save_plist -# wrong constant name to_plist1 -# wrong constant name to_plist2 -# wrong constant name to_plist -# undefined singleton method `dump1' for `Plist::Emit' -# undefined singleton method `dump2' for `Plist::Emit' -# undefined singleton method `plist_node1' for `Plist::Emit' -# undefined singleton method `save_plist1' for `Plist::Emit' -# undefined singleton method `tag1' for `Plist::Emit' -# undefined singleton method `tag2' for `Plist::Emit' -# wrong constant name -# wrong constant name comment -# wrong constant name dump1 -# wrong constant name dump2 -# wrong constant name dump -# wrong constant name element_type -# wrong constant name plist_node1 -# wrong constant name plist_node -# wrong constant name save_plist1 -# wrong constant name save_plist -# wrong constant name tag1 -# wrong constant name tag2 -# wrong constant name tag -# wrong constant name wrap -# wrong constant name open -# wrong constant name open= -# wrong constant name result -# wrong constant name result= -# wrong constant name tag_end -# wrong constant name tag_start -# wrong constant name text -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name children -# wrong constant name children= -# wrong constant name text -# wrong constant name text= -# wrong constant name to_ruby -# wrong constant name -# wrong constant name inherited -# wrong constant name mappings -# wrong constant name -# wrong constant name initialize -# wrong constant name parse -# wrong constant name -# wrong constant name -# wrong constant name parse_xml # uninitialized constant Prime # uninitialized constant Prime # wrong constant name << @@ -14515,307 +8919,6 @@ # uninitialized constant Proc8 # uninitialized constant Proc9 # uninitialized constant Proc9 -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Base' -# undefined method `start1' for class `ProgressBar::Base' -# undefined method `to_s1' for class `ProgressBar::Base' -# wrong constant name autofinish -# wrong constant name autofinish= -# wrong constant name autostart -# wrong constant name autostart= -# wrong constant name bar -# wrong constant name bar= -# wrong constant name clear -# wrong constant name decrement -# wrong constant name finish -# wrong constant name finished -# wrong constant name finished= -# wrong constant name finished? -# wrong constant name format -# wrong constant name format= -# wrong constant name increment -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name log -# wrong constant name output -# wrong constant name output= -# wrong constant name pause -# wrong constant name paused? -# wrong constant name percentage -# wrong constant name percentage= -# wrong constant name progress -# wrong constant name progress= -# wrong constant name progress_mark= -# wrong constant name progressable -# wrong constant name progressable= -# wrong constant name rate -# wrong constant name rate= -# wrong constant name refresh -# wrong constant name remainder_mark= -# wrong constant name reset -# wrong constant name resume -# wrong constant name start1 -# wrong constant name start -# wrong constant name started? -# wrong constant name stop -# wrong constant name stopped? -# wrong constant name time -# wrong constant name time= -# wrong constant name timer -# wrong constant name timer= -# wrong constant name title -# wrong constant name title= -# wrong constant name title_comp -# wrong constant name title_comp= -# wrong constant name to_h -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name total -# wrong constant name total= -# wrong constant name update_progress -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Calculators::Length' -# wrong constant name calculate_length -# wrong constant name current_length -# wrong constant name current_length= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name length -# wrong constant name length_changed? -# wrong constant name length_override -# wrong constant name length_override= -# wrong constant name output -# wrong constant name output= -# wrong constant name reset_length -# wrong constant name -# wrong constant name -# wrong constant name calculate -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Components::Bar' -# undefined method `to_s1' for class `ProgressBar::Components::Bar' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name length -# wrong constant name length= -# wrong constant name progress -# wrong constant name progress= -# wrong constant name progress_mark -# wrong constant name progress_mark= -# wrong constant name remainder_mark -# wrong constant name remainder_mark= -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name upa_steps -# wrong constant name upa_steps= -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Components::Percentage' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name progress -# wrong constant name progress= -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Components::Rate' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name progress -# wrong constant name progress= -# wrong constant name rate_scale -# wrong constant name rate_scale= -# wrong constant name started_at -# wrong constant name started_at= -# wrong constant name stopped_at -# wrong constant name stopped_at= -# wrong constant name timer -# wrong constant name timer= -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Components::Time' -# wrong constant name elapsed_with_label -# wrong constant name estimated_with_friendly_oob -# wrong constant name estimated_with_label -# wrong constant name estimated_with_no_oob -# wrong constant name estimated_with_unknown_oob -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name out_of_bounds_time_format -# wrong constant name out_of_bounds_time_format= -# wrong constant name progress -# wrong constant name progress= -# wrong constant name timer -# wrong constant name timer= -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Components::Title' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name title -# wrong constant name title= -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name process -# undefined method `lookup_value1' for class `ProgressBar::Format::Molecule' -# wrong constant name bar_molecule? -# wrong constant name full_key -# wrong constant name initialize -# wrong constant name key -# wrong constant name key= -# wrong constant name lookup_value1 -# wrong constant name lookup_value -# wrong constant name method_name -# wrong constant name method_name= -# wrong constant name non_bar_molecule? -# wrong constant name -# uninitialized constant ProgressBar::Format::String::BLANK_RE -# uninitialized constant ProgressBar::Format::String::ENCODED_BLANKS -# wrong constant name bar_molecule_placeholder_length -# wrong constant name bar_molecules -# wrong constant name displayable_length -# wrong constant name molecules -# wrong constant name non_bar_molecules -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Output' -# undefined method `refresh1' for class `ProgressBar::Output' -# wrong constant name bar -# wrong constant name bar= -# wrong constant name clear_string -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name length -# wrong constant name length_calculator -# wrong constant name length_calculator= -# wrong constant name log -# wrong constant name refresh1 -# wrong constant name refresh -# wrong constant name stream -# wrong constant name stream= -# wrong constant name throttle -# wrong constant name throttle= -# wrong constant name with_refresh -# undefined singleton method `detect1' for `ProgressBar::Output' -# wrong constant name -# wrong constant name detect1 -# wrong constant name detect -# wrong constant name -# wrong constant name -# uninitialized constant ProgressBar::Outputs::NonTty::DEFAULT_OUTPUT_STREAM -# wrong constant name bar_update_string -# wrong constant name clear -# wrong constant name default_format -# wrong constant name eol -# wrong constant name last_update_length -# wrong constant name last_update_length= -# wrong constant name refresh_with_format_change -# wrong constant name resolve_format -# wrong constant name -# uninitialized constant ProgressBar::Outputs::Tty::DEFAULT_OUTPUT_STREAM -# wrong constant name bar_update_string -# wrong constant name clear -# wrong constant name default_format -# wrong constant name eol -# wrong constant name refresh_with_format_change -# wrong constant name resolve_format -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Progress' -# undefined method `start1' for class `ProgressBar::Progress' -# wrong constant name absolute -# wrong constant name decrement -# wrong constant name finish -# wrong constant name finished? -# wrong constant name increment -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name none? -# wrong constant name percentage_completed -# wrong constant name percentage_completed_with_precision -# wrong constant name progress -# wrong constant name progress= -# wrong constant name reset -# wrong constant name running_average -# wrong constant name running_average= -# wrong constant name smoothing -# wrong constant name smoothing= -# wrong constant name start1 -# wrong constant name start -# wrong constant name starting_position -# wrong constant name starting_position= -# wrong constant name total -# wrong constant name total= -# wrong constant name total_with_unknown_indicator -# wrong constant name unknown? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `choke1' for class `ProgressBar::Throttle' -# undefined method `initialize1' for class `ProgressBar::Throttle' -# wrong constant name choke1 -# wrong constant name choke -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name rate -# wrong constant name rate= -# wrong constant name started_at -# wrong constant name started_at= -# wrong constant name stopped_at -# wrong constant name stopped_at= -# wrong constant name timer -# wrong constant name timer= -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Time' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name now -# wrong constant name time -# wrong constant name time= -# wrong constant name unmocked_time_method -# wrong constant name -# undefined method `initialize1' for class `ProgressBar::Timer' -# wrong constant name divide_seconds -# wrong constant name elapsed_seconds -# wrong constant name elapsed_whole_seconds -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name pause -# wrong constant name reset -# wrong constant name reset? -# wrong constant name restart -# wrong constant name resume -# wrong constant name start -# wrong constant name started? -# wrong constant name started_at -# wrong constant name started_at= -# wrong constant name stop -# wrong constant name stopped? -# wrong constant name stopped_at -# wrong constant name stopped_at= -# wrong constant name time -# wrong constant name time= -# wrong constant name -# wrong constant name -# wrong constant name create # undefined method `eval1' for class `Pry' # undefined method `initialize1' for class `Pry' # undefined method `push_initial_binding1' for class `Pry' @@ -16695,179 +10798,14 @@ # wrong constant name # uninitialized constant RDoc # uninitialized constant RDoc -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Attribute' -# undefined method `initialize2' for class `REXML::Attribute' -# uninitialized constant REXML::Attribute::NAME -# uninitialized constant REXML::Attribute::NAMECHAR -# uninitialized constant REXML::Attribute::NAMESPLIT -# uninitialized constant REXML::Attribute::NAME_CHAR -# uninitialized constant REXML::Attribute::NAME_START_CHAR -# uninitialized constant REXML::Attribute::NAME_STR -# uninitialized constant REXML::Attribute::NCNAME_STR -# uninitialized constant REXML::Attribute::NMTOKEN -# uninitialized constant REXML::Attribute::NMTOKENS -# uninitialized constant REXML::Attribute::REFERENCE -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# uninitialized constant REXML::Attributes::DEFAULT_INDENT -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::CData' -# undefined method `initialize2' for class `REXML::CData' -# uninitialized constant REXML::CData::EREFERENCE -# uninitialized constant REXML::CData::NEEDS_A_SECOND_CHECK -# uninitialized constant REXML::CData::NUMERICENTITY -# uninitialized constant REXML::CData::REFERENCE -# uninitialized constant REXML::CData::SETUTITSBUS -# uninitialized constant REXML::CData::SLAICEPS -# uninitialized constant REXML::CData::SPECIALS -# uninitialized constant REXML::CData::SUBSTITUTES -# uninitialized constant REXML::CData::VALID_CHAR -# uninitialized constant REXML::CData::VALID_XML_CHARS -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Child' -# wrong constant name initialize1 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Comment' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::DocType' -# uninitialized constant REXML::DocType::NAME -# uninitialized constant REXML::DocType::NAMECHAR -# uninitialized constant REXML::DocType::NAME_CHAR -# uninitialized constant REXML::DocType::NAME_START_CHAR -# uninitialized constant REXML::DocType::NAME_STR -# uninitialized constant REXML::DocType::NCNAME_STR -# uninitialized constant REXML::DocType::NMTOKEN -# uninitialized constant REXML::DocType::NMTOKENS -# uninitialized constant REXML::DocType::REFERENCE -# wrong constant name initialize1 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Document' -# undefined method `initialize2' for class `REXML::Document' -# uninitialized constant REXML::Document::NAME -# uninitialized constant REXML::Document::NAMECHAR -# uninitialized constant REXML::Document::NAMESPLIT -# uninitialized constant REXML::Document::NAME_CHAR -# uninitialized constant REXML::Document::NAME_START_CHAR -# uninitialized constant REXML::Document::NAME_STR -# uninitialized constant REXML::Document::NCNAME_STR -# uninitialized constant REXML::Document::NMTOKEN -# uninitialized constant REXML::Document::NMTOKENS -# uninitialized constant REXML::Document::REFERENCE -# uninitialized constant REXML::Document::UNDEFINED -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Element' -# undefined method `initialize2' for class `REXML::Element' -# undefined method `initialize3' for class `REXML::Element' -# uninitialized constant REXML::Element::NAME -# uninitialized constant REXML::Element::NAMECHAR -# uninitialized constant REXML::Element::NAMESPLIT -# uninitialized constant REXML::Element::NAME_CHAR -# uninitialized constant REXML::Element::NAME_START_CHAR -# uninitialized constant REXML::Element::NAME_STR -# uninitialized constant REXML::Element::NCNAME_STR -# uninitialized constant REXML::Element::NMTOKEN -# uninitialized constant REXML::Element::NMTOKENS -# uninitialized constant REXML::Element::REFERENCE -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Entity' -# undefined method `initialize2' for class `REXML::Entity' -# undefined method `initialize3' for class `REXML::Entity' -# uninitialized constant REXML::Entity::NAME -# uninitialized constant REXML::Entity::NAMECHAR -# uninitialized constant REXML::Entity::NAME_CHAR -# uninitialized constant REXML::Entity::NAME_START_CHAR -# uninitialized constant REXML::Entity::NAME_STR -# uninitialized constant REXML::Entity::NCNAME_STR -# uninitialized constant REXML::Entity::NMTOKEN -# uninitialized constant REXML::Entity::NMTOKENS -# uninitialized constant REXML::Entity::REFERENCE -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Formatters::Default' -# wrong constant name initialize1 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Formatters::Pretty' -# undefined method `initialize2' for class `REXML::Formatters::Pretty' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::IOSource' -# undefined method `initialize2' for class `REXML::IOSource' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Instruction' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Output' -# wrong constant name initialize1 -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::ParseException' -# undefined method `initialize2' for class `REXML::ParseException' -# undefined method `initialize3' for class `REXML::ParseException' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::Parsers::TreeParser' -# wrong constant name initialize1 -# wrong constant name initialize -# uninitialized constant REXML::Parsers::XPathParser::NAME -# uninitialized constant REXML::Parsers::XPathParser::NAMECHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_CHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_START_CHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_STR -# uninitialized constant REXML::Parsers::XPathParser::NCNAME_STR -# uninitialized constant REXML::Parsers::XPathParser::NMTOKEN -# uninitialized constant REXML::Parsers::XPathParser::NMTOKENS -# uninitialized constant REXML::Parsers::XPathParser::REFERENCE # uninitialized constant REXML::QuickPath # uninitialized constant REXML::QuickPath # uninitialized constant REXML::SAX2Listener # uninitialized constant REXML::SAX2Listener -# undefined method `initialize1' for class `REXML::Source' -# wrong constant name initialize1 -# wrong constant name initialize # uninitialized constant REXML::SyncEnumerator # uninitialized constant REXML::SyncEnumerator -# undefined method `initialize1' for class `REXML::Text' -# undefined method `initialize2' for class `REXML::Text' -# undefined method `initialize3' for class `REXML::Text' -# undefined method `initialize4' for class `REXML::Text' -# undefined method `initialize5' for class `REXML::Text' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize5 # wrong constant name initialize # wrong constant name initialize -# wrong constant name initialize -# undefined method `initialize1' for class `REXML::XMLDecl' -# undefined method `initialize2' for class `REXML::XMLDecl' -# undefined method `initialize3' for class `REXML::XMLDecl' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize # undefined singleton method `match1' for `REXML::XPath' # undefined singleton method `match2' for `REXML::XPath' # undefined singleton method `match3' for `REXML::XPath' @@ -16877,14 +10815,6 @@ # wrong constant name match3 # wrong constant name match4 # wrong constant name match -# undefined method `initialize1' for class `REXML::XPathNode' -# wrong constant name context -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name position -# wrong constant name raw_node -# wrong constant name -# undefined method `initialize1' for class `REXML::XPathParser' # uninitialized constant REXML::XPathParser::NAME # uninitialized constant REXML::XPathParser::NAMECHAR # uninitialized constant REXML::XPathParser::NAME_CHAR @@ -16894,914 +10824,33 @@ # uninitialized constant REXML::XPathParser::NMTOKEN # uninitialized constant REXML::XPathParser::NMTOKENS # uninitialized constant REXML::XPathParser::REFERENCE -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined singleton method `first_non_rspec_line1' for `RSpec::CallerFilter' -# undefined singleton method `first_non_rspec_line2' for `RSpec::CallerFilter' -# wrong constant name -# wrong constant name first_non_rspec_line1 -# wrong constant name first_non_rspec_line2 -# wrong constant name first_non_rspec_line -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Core::AnonymousExampleGroup::BE_PREDICATE_REGEX -# uninitialized constant RSpec::Core::AnonymousExampleGroup::DYNAMIC_MATCHER_REGEX -# uninitialized constant RSpec::Core::AnonymousExampleGroup::HAS_REGEX -# uninitialized constant RSpec::Core::AnonymousExampleGroup::INSTANCE_VARIABLE_TO_IGNORE -# uninitialized constant RSpec::Core::AnonymousExampleGroup::NOT_YET_IMPLEMENTED -# uninitialized constant RSpec::Core::AnonymousExampleGroup::NO_REASON_GIVEN -# wrong constant name -# undefined method `format_backtrace1' for class `RSpec::Core::BacktraceFormatter' -# wrong constant name backtrace_line -# wrong constant name exclude? -# wrong constant name exclusion_patterns -# wrong constant name exclusion_patterns= -# wrong constant name filter_gem -# wrong constant name format_backtrace1 -# wrong constant name format_backtrace -# wrong constant name full_backtrace= -# wrong constant name full_backtrace? -# wrong constant name inclusion_patterns -# wrong constant name inclusion_patterns= -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name for_failed_spec_run -# wrong constant name close -# wrong constant name receive -# wrong constant name send -# wrong constant name -# uninitialized constant RSpec::Core::Bisect::ExampleSetDescriptor::Elem -# wrong constant name all_example_ids -# wrong constant name all_example_ids= -# wrong constant name failed_example_ids -# wrong constant name failed_example_ids= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name initialize -# wrong constant name publish -# wrong constant name -# wrong constant name -# undefined method `add_formatter1' for class `RSpec::Core::Configuration' -# undefined method `add_setting1' for class `RSpec::Core::Configuration' -# undefined method `after1' for class `RSpec::Core::Configuration' -# undefined method `alias_it_behaves_like_to1' for class `RSpec::Core::Configuration' -# undefined method `alias_it_should_behave_like_to1' for class `RSpec::Core::Configuration' -# undefined method `append_after1' for class `RSpec::Core::Configuration' -# undefined method `append_before1' for class `RSpec::Core::Configuration' -# undefined method `around1' for class `RSpec::Core::Configuration' -# undefined method `before1' for class `RSpec::Core::Configuration' -# undefined method `color_enabled?1' for class `RSpec::Core::Configuration' -# undefined method `formatter=1' for class `RSpec::Core::Configuration' -# undefined method `prepend_after1' for class `RSpec::Core::Configuration' -# undefined method `prepend_before1' for class `RSpec::Core::Configuration' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name add_formatter1 -# wrong constant name add_formatter -# wrong constant name add_setting1 -# wrong constant name add_setting -# wrong constant name after1 -# wrong constant name after -# wrong constant name alias_example_group_to -# wrong constant name alias_example_to -# wrong constant name alias_it_behaves_like_to1 -# wrong constant name alias_it_behaves_like_to -# wrong constant name alias_it_should_behave_like_to1 -# wrong constant name alias_it_should_behave_like_to -# wrong constant name append_after1 -# wrong constant name append_after -# wrong constant name append_before1 -# wrong constant name append_before -# wrong constant name apply_derived_metadata_to -# wrong constant name around1 -# wrong constant name around -# wrong constant name backtrace_exclusion_patterns -# wrong constant name backtrace_exclusion_patterns= -# wrong constant name backtrace_formatter -# wrong constant name backtrace_inclusion_patterns -# wrong constant name backtrace_inclusion_patterns= -# wrong constant name before1 -# wrong constant name before -# wrong constant name bisect_runner -# wrong constant name bisect_runner= -# wrong constant name bisect_runner_class -# wrong constant name color -# wrong constant name color= -# wrong constant name color_enabled?1 -# wrong constant name color_enabled? -# wrong constant name color_mode -# wrong constant name color_mode= -# wrong constant name configure_example -# wrong constant name configure_expectation_framework -# wrong constant name configure_group -# wrong constant name configure_mock_framework -# wrong constant name default_color= -# wrong constant name default_color? -# wrong constant name default_formatter -# wrong constant name default_formatter= -# wrong constant name default_path= -# wrong constant name default_path? -# wrong constant name define_derived_metadata -# wrong constant name deprecation_stream= -# wrong constant name detail_color= -# wrong constant name detail_color? -# wrong constant name disable_monkey_patching -# wrong constant name disable_monkey_patching! -# wrong constant name disable_monkey_patching= -# wrong constant name drb= -# wrong constant name drb? -# wrong constant name drb_port= -# wrong constant name drb_port? -# wrong constant name dry_run= -# wrong constant name dry_run? -# wrong constant name error_stream= -# wrong constant name error_stream? -# wrong constant name example_status_persistence_file_path= -# wrong constant name exclude_pattern= -# wrong constant name exclusion_filter -# wrong constant name exclusion_filter= -# wrong constant name expect_with -# wrong constant name expectation_framework= -# wrong constant name expectation_frameworks -# wrong constant name expose_current_running_example_as -# wrong constant name expose_dsl_globally= -# wrong constant name expose_dsl_globally? -# wrong constant name extend -# wrong constant name fail_fast= -# wrong constant name fail_if_no_examples= -# wrong constant name fail_if_no_examples? -# wrong constant name failure_color= -# wrong constant name failure_color? -# wrong constant name failure_exit_code= -# wrong constant name failure_exit_code? -# wrong constant name files_or_directories_to_run= -# wrong constant name files_to_run -# wrong constant name files_to_run= -# wrong constant name filter -# wrong constant name filter= -# wrong constant name filter_gems_from_backtrace -# wrong constant name filter_manager -# wrong constant name filter_manager= -# wrong constant name filter_run -# wrong constant name filter_run_excluding -# wrong constant name filter_run_including -# wrong constant name filter_run_when_matching -# wrong constant name fixed_color= -# wrong constant name fixed_color? -# wrong constant name force -# wrong constant name format_docstrings -# wrong constant name format_docstrings_block -# wrong constant name formatter=1 -# wrong constant name formatter= -# wrong constant name formatter_loader -# wrong constant name formatters -# wrong constant name full_backtrace= -# wrong constant name full_backtrace? -# wrong constant name full_description -# wrong constant name full_description= -# wrong constant name in_project_source_dir_regex -# wrong constant name include -# wrong constant name include_context -# wrong constant name inclusion_filter -# wrong constant name inclusion_filter= -# wrong constant name last_run_statuses -# wrong constant name libs= -# wrong constant name load_spec_files -# wrong constant name loaded_spec_files -# wrong constant name max_displayed_failure_line_count= -# wrong constant name max_displayed_failure_line_count? -# wrong constant name mock_framework -# wrong constant name mock_framework= -# wrong constant name mock_with -# wrong constant name on_example_group_definition -# wrong constant name on_example_group_definition_callbacks -# wrong constant name only_failures? -# wrong constant name only_failures_but_not_configured? -# wrong constant name order= -# wrong constant name ordering_manager -# wrong constant name ordering_registry -# wrong constant name output_stream= -# wrong constant name pattern= -# wrong constant name pending_color= -# wrong constant name pending_color? -# wrong constant name prepend -# wrong constant name prepend_after1 -# wrong constant name prepend_after -# wrong constant name prepend_before1 -# wrong constant name prepend_before -# wrong constant name profile_examples= -# wrong constant name profile_examples? -# wrong constant name project_source_dirs= -# wrong constant name project_source_dirs? -# wrong constant name raise_errors_for_deprecations! -# wrong constant name raise_on_warning= -# wrong constant name register_ordering -# wrong constant name reporter -# wrong constant name requires= -# wrong constant name reset -# wrong constant name reset_filters -# wrong constant name reset_reporter -# wrong constant name run_all_when_everything_filtered= -# wrong constant name run_all_when_everything_filtered? -# wrong constant name seed -# wrong constant name seed= -# wrong constant name seed_used? -# wrong constant name shared_context_metadata_behavior= -# wrong constant name silence_filter_announcements= -# wrong constant name silence_filter_announcements? -# wrong constant name spec_files_with_failures -# wrong constant name start_time= -# wrong constant name start_time? -# wrong constant name static_config_filter_manager -# wrong constant name static_config_filter_manager= -# wrong constant name success_color= -# wrong constant name success_color? -# wrong constant name threadsafe= -# wrong constant name threadsafe? -# wrong constant name treat_symbols_as_metadata_keys_with_true_values= -# wrong constant name tty= -# wrong constant name tty? -# wrong constant name warnings= -# wrong constant name warnings? -# wrong constant name when_first_matching_example_defined -# wrong constant name with_suite_hooks -# wrong constant name world -# wrong constant name world= -# wrong constant name deprecation -# wrong constant name play_onto -# wrong constant name -# wrong constant name -# wrong constant name # wrong constant name clear_lets_on_failure -# wrong constant name default_color -# wrong constant name default_path # wrong constant name default_retry_count # wrong constant name default_sleep_interval -# wrong constant name deprecation_stream -# wrong constant name detail_color # wrong constant name display_try_failure_messages -# wrong constant name drb -# wrong constant name drb_port -# wrong constant name dry_run -# wrong constant name error_stream -# wrong constant name example_status_persistence_file_path # wrong constant name exceptions_to_hard_fail # wrong constant name exceptions_to_retry -# wrong constant name exclude_pattern # wrong constant name exponential_backoff -# wrong constant name fail_fast -# wrong constant name fail_if_no_examples -# wrong constant name failure_color -# wrong constant name failure_exit_code -# wrong constant name fixed_color -# wrong constant name libs -# wrong constant name max_displayed_failure_line_count -# wrong constant name only_failures -# wrong constant name output_stream -# wrong constant name pattern -# wrong constant name pending_color -# wrong constant name profile_examples -# wrong constant name project_source_dirs -# wrong constant name requires # wrong constant name retry_callback # wrong constant name retry_count_condition -# wrong constant name run_all_when_everything_filtered -# wrong constant name shared_context_metadata_behavior -# wrong constant name silence_filter_announcements -# wrong constant name start_time -# wrong constant name success_color -# wrong constant name threadsafe -# wrong constant name tty # wrong constant name verbose_retry # wrong constant name wait_delay # wrong constant name wait_timeout -# wrong constant name -# undefined singleton method `add_read_only_setting1' for `RSpec::Core::Configuration' -# undefined singleton method `add_setting1' for `RSpec::Core::Configuration' -# wrong constant name -# wrong constant name add_read_only_setting1 -# wrong constant name add_read_only_setting -# wrong constant name add_setting1 -# wrong constant name add_setting -# wrong constant name define_aliases -# wrong constant name define_predicate_for -# wrong constant name define_reader -# wrong constant name delegate_to_ordering_manager -# wrong constant name args -# wrong constant name configure -# wrong constant name configure_filter_manager -# wrong constant name initialize -# wrong constant name options -# wrong constant name -# wrong constant name -# wrong constant name change_global_dsl -# wrong constant name example_group_aliases -# wrong constant name expose_example_group_alias -# wrong constant name expose_example_group_alias_globally -# wrong constant name expose_globally! -# wrong constant name exposed_globally? -# wrong constant name remove_globally! -# wrong constant name top_level -# wrong constant name top_level= -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name relative_file_name -# wrong constant name -# undefined method `duplicate_with1' for class `RSpec::Core::Example' -# undefined method `initialize1' for class `RSpec::Core::Example' -# wrong constant name -# wrong constant name # wrong constant name attempts # wrong constant name attempts= # wrong constant name clear_exception -# wrong constant name clock -# wrong constant name clock= -# wrong constant name description -# wrong constant name display_exception -# wrong constant name display_exception= -# wrong constant name duplicate_with1 -# wrong constant name duplicate_with -# wrong constant name example_group -# wrong constant name example_group_instance -# wrong constant name exception -# wrong constant name execution_result -# wrong constant name fail_with_exception -# wrong constant name file_path -# wrong constant name full_description -# wrong constant name id -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name inspect_output -# wrong constant name instance_exec -# wrong constant name location -# wrong constant name location_rerun_argument -# wrong constant name metadata -# wrong constant name pending -# wrong constant name pending? -# wrong constant name reporter -# wrong constant name rerun_argument -# wrong constant name run -# wrong constant name set_aggregate_failures_exception -# wrong constant name set_exception -# wrong constant name skip -# wrong constant name skip_with_exception -# wrong constant name skipped? -# wrong constant name update_inherited_metadata -# wrong constant name ensure_timing_set -# wrong constant name example_skipped? -# wrong constant name exception -# wrong constant name exception= -# wrong constant name finished_at -# wrong constant name finished_at= -# wrong constant name pending_exception -# wrong constant name pending_exception= -# wrong constant name pending_fixed -# wrong constant name pending_fixed= -# wrong constant name pending_fixed? -# wrong constant name pending_message -# wrong constant name pending_message= -# wrong constant name record_finished -# wrong constant name run_time -# wrong constant name run_time= -# wrong constant name started_at -# wrong constant name started_at= -# wrong constant name status -# wrong constant name status= -# wrong constant name # undefined method `run_with_retry1' for class `RSpec::Core::Example::Procsy' -# wrong constant name << -# wrong constant name === -# wrong constant name >> -# wrong constant name [] -# wrong constant name arity # wrong constant name attempts -# wrong constant name binding -# wrong constant name call -# wrong constant name clock -# wrong constant name clock= -# wrong constant name clone -# wrong constant name curry -# wrong constant name description -# wrong constant name dup -# wrong constant name duplicate_with -# wrong constant name example -# wrong constant name example_group -# wrong constant name example_group_instance -# wrong constant name exception -# wrong constant name executed? -# wrong constant name execution_result -# wrong constant name file_path -# wrong constant name full_description -# wrong constant name hash -# wrong constant name id -# wrong constant name initialize -# wrong constant name inspect_output -# wrong constant name lambda? -# wrong constant name location -# wrong constant name location_rerun_argument -# wrong constant name metadata -# wrong constant name parameters -# wrong constant name pending -# wrong constant name pending? -# wrong constant name reporter -# wrong constant name rerun_argument -# wrong constant name run # wrong constant name run_with_retry1 # wrong constant name run_with_retry -# wrong constant name skip -# wrong constant name skipped? -# wrong constant name source_location -# wrong constant name to_proc -# wrong constant name update_inherited_metadata -# wrong constant name wrap -# wrong constant name yield -# wrong constant name -# wrong constant name -# wrong constant name delegate_to_metadata -# wrong constant name parse_id -# undefined method `initialize1' for class `RSpec::Core::ExampleGroup' # uninitialized constant RSpec::Core::ExampleGroup::BE_PREDICATE_REGEX # uninitialized constant RSpec::Core::ExampleGroup::DYNAMIC_MATCHER_REGEX # uninitialized constant RSpec::Core::ExampleGroup::HAS_REGEX # uninitialized constant RSpec::Core::ExampleGroup::NOT_YET_IMPLEMENTED # uninitialized constant RSpec::Core::ExampleGroup::NO_REASON_GIVEN -# wrong constant name # wrong constant name clear_lets # wrong constant name clear_memoized -# wrong constant name described_class -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# undefined singleton method `define_example_group_method1' for `RSpec::Core::ExampleGroup' -# undefined singleton method `define_example_method1' for `RSpec::Core::ExampleGroup' -# undefined singleton method `define_nested_shared_group_method1' for `RSpec::Core::ExampleGroup' -# undefined singleton method `run1' for `RSpec::Core::ExampleGroup' -# wrong constant name -# wrong constant name add_example -# wrong constant name before_context_ivars -# wrong constant name children -# wrong constant name context -# wrong constant name currently_executing_a_context_hook? -# wrong constant name declaration_locations -# wrong constant name define_example_group_method1 -# wrong constant name define_example_group_method -# wrong constant name define_example_method1 -# wrong constant name define_example_method -# wrong constant name define_nested_shared_group_method1 -# wrong constant name define_nested_shared_group_method -# wrong constant name delegate_to_metadata -# wrong constant name descendant_filtered_examples -# wrong constant name descendants -# wrong constant name describe -# wrong constant name described_class -# wrong constant name description -# wrong constant name each_instance_variable_for_example -# wrong constant name ensure_example_groups_are_configured -# wrong constant name example -# wrong constant name example_group -# wrong constant name examples -# wrong constant name fcontext -# wrong constant name fdescribe -# wrong constant name fexample -# wrong constant name file_path -# wrong constant name filtered_examples -# wrong constant name find_and_eval_shared -# wrong constant name fit -# wrong constant name focus -# wrong constant name for_filtered_examples -# wrong constant name fspecify -# wrong constant name id -# wrong constant name idempotently_define_singleton_method -# wrong constant name include_context -# wrong constant name include_examples -# wrong constant name it -# wrong constant name it_behaves_like -# wrong constant name it_should_behave_like -# wrong constant name location -# wrong constant name metadata -# wrong constant name next_runnable_index_for -# wrong constant name ordering_strategy -# wrong constant name parent_groups -# wrong constant name pending -# wrong constant name remove_example -# wrong constant name reset_memoized -# wrong constant name run1 -# wrong constant name run -# wrong constant name run_after_context_hooks -# wrong constant name run_before_context_hooks -# wrong constant name run_examples -# wrong constant name set_it_up -# wrong constant name set_ivars -# wrong constant name skip -# wrong constant name specify -# wrong constant name store_before_context_ivars -# wrong constant name subclass -# wrong constant name superclass_before_context_ivars -# wrong constant name superclass_metadata -# wrong constant name top_level? -# wrong constant name top_level_description -# wrong constant name traverse_tree_until -# wrong constant name update_inherited_metadata -# wrong constant name with_replaced_metadata -# wrong constant name xcontext -# wrong constant name xdescribe -# wrong constant name xexample -# wrong constant name xit -# wrong constant name xspecify -# wrong constant name dump -# wrong constant name initialize -# wrong constant name -# wrong constant name dump -# wrong constant name initialize -# wrong constant name merge -# wrong constant name -# wrong constant name merge -# wrong constant name initialize -# wrong constant name parse -# wrong constant name -# wrong constant name parse -# wrong constant name initialize -# wrong constant name persist -# wrong constant name -# wrong constant name load_from -# wrong constant name persist -# wrong constant name add_ids -# wrong constant name add_location -# wrong constant name empty? -# wrong constant name exclude -# wrong constant name exclude_only -# wrong constant name exclude_with_low_priority -# wrong constant name exclusions -# wrong constant name include -# wrong constant name include_only -# wrong constant name include_with_low_priority -# wrong constant name inclusions -# wrong constant name prune -# wrong constant name -# undefined method `initialize1' for class `RSpec::Core::FilterRules' -# wrong constant name [] -# wrong constant name add -# wrong constant name add_with_low_priority -# wrong constant name clear -# wrong constant name delete -# wrong constant name description -# wrong constant name each_pair -# wrong constant name empty? -# wrong constant name fetch -# wrong constant name include_example? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name opposite -# wrong constant name opposite= -# wrong constant name rules -# wrong constant name use_only -# wrong constant name -# wrong constant name build -# wrong constant name -# wrong constant name -# wrong constant name items_for -# wrong constant name -# wrong constant name append -# wrong constant name delete -# wrong constant name initialize -# wrong constant name items_and_filters -# wrong constant name items_for -# wrong constant name prepend -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name flat_map -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name example_failed -# wrong constant name example_finished -# wrong constant name initialize -# wrong constant name start_dump -# wrong constant name -# wrong constant name inherited -# wrong constant name close -# wrong constant name example_group -# wrong constant name example_group= -# wrong constant name example_group_started -# wrong constant name initialize -# wrong constant name output -# wrong constant name start -# wrong constant name -# wrong constant name dump_failures -# wrong constant name dump_pending -# wrong constant name dump_summary -# wrong constant name message -# wrong constant name seed -# wrong constant name -# wrong constant name initialize -# wrong constant name notify_results -# wrong constant name -# wrong constant name -# wrong constant name config_colors_to_methods -# wrong constant name console_code_for -# wrong constant name wrap -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name count -# wrong constant name deprecation -# wrong constant name deprecation_message_for -# wrong constant name deprecation_stream -# wrong constant name deprecation_summary -# wrong constant name initialize -# wrong constant name output -# wrong constant name printer -# wrong constant name summary_stream -# wrong constant name deprecation_formatter -# wrong constant name deprecation_stream -# wrong constant name deprecation_summary -# wrong constant name initialize -# wrong constant name print_deferred_deprecation_warnings -# wrong constant name print_deprecation_message -# wrong constant name stash_deprecation_message -# wrong constant name summary_stream -# wrong constant name -# wrong constant name initialize -# wrong constant name puts -# wrong constant name summarize -# wrong constant name -# uninitialized constant RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage::Elem -# wrong constant name initialize -# wrong constant name too_many_warnings_message -# wrong constant name type -# wrong constant name type= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name deprecation_formatter -# wrong constant name deprecation_stream -# wrong constant name deprecation_summary -# wrong constant name initialize -# wrong constant name print_deprecation_message -# wrong constant name summary_stream -# wrong constant name -# wrong constant name puts -# wrong constant name summarize -# wrong constant name -# uninitialized constant RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage::Elem -# wrong constant name initialize -# wrong constant name too_many_warnings_message -# wrong constant name type -# wrong constant name type= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name example_failed -# wrong constant name example_group_finished -# wrong constant name example_passed -# wrong constant name example_pending -# wrong constant name example_started -# wrong constant name -# undefined method `colorized_formatted_backtrace1' for class `RSpec::Core::Formatters::ExceptionPresenter' -# undefined method `colorized_message_lines1' for class `RSpec::Core::Formatters::ExceptionPresenter' -# undefined method `formatted_backtrace1' for class `RSpec::Core::Formatters::ExceptionPresenter' -# undefined method `fully_formatted1' for class `RSpec::Core::Formatters::ExceptionPresenter' -# undefined method `initialize1' for class `RSpec::Core::Formatters::ExceptionPresenter' -# wrong constant name -# wrong constant name colorized_formatted_backtrace1 -# wrong constant name colorized_formatted_backtrace -# wrong constant name colorized_message_lines1 -# wrong constant name colorized_message_lines -# wrong constant name description -# wrong constant name example -# wrong constant name exception -# wrong constant name formatted_backtrace1 -# wrong constant name formatted_backtrace -# wrong constant name formatted_cause -# wrong constant name fully_formatted1 -# wrong constant name fully_formatted -# wrong constant name fully_formatted_lines -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name message_lines -# wrong constant name -# wrong constant name -# wrong constant name build -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name with_truncated_backtrace -# wrong constant name -# wrong constant name -# wrong constant name format_backtrace -# wrong constant name -# wrong constant name -# wrong constant name dump_profile -# wrong constant name example_failed -# wrong constant name message -# wrong constant name -# wrong constant name initialize -# wrong constant name message -# wrong constant name output -# wrong constant name -# undefined singleton method `format_seconds1' for `RSpec::Core::Formatters::Helpers' -# wrong constant name -# wrong constant name format_duration -# wrong constant name format_seconds1 -# wrong constant name format_seconds -# wrong constant name organize_ids -# wrong constant name pluralize -# wrong constant name dump_summary -# wrong constant name example_failed -# wrong constant name example_passed -# wrong constant name example_pending -# wrong constant name example_started -# wrong constant name start_dump -# wrong constant name -# uninitialized constant RSpec::Core::Formatters::HtmlPrinter::HTML_ESCAPE -# uninitialized constant RSpec::Core::Formatters::HtmlPrinter::HTML_ESCAPE_ONCE_REGEXP -# uninitialized constant RSpec::Core::Formatters::HtmlPrinter::JSON_ESCAPE -# uninitialized constant RSpec::Core::Formatters::HtmlPrinter::JSON_ESCAPE_REGEXP -# wrong constant name flush -# wrong constant name initialize -# wrong constant name make_example_group_header_red -# wrong constant name make_example_group_header_yellow -# wrong constant name make_header_red -# wrong constant name make_header_yellow -# wrong constant name move_progress -# wrong constant name print_example_failed -# wrong constant name print_example_group_end -# wrong constant name print_example_group_start -# wrong constant name print_example_passed -# wrong constant name print_example_pending -# wrong constant name print_html_start -# wrong constant name print_summary -# wrong constant name -# wrong constant name dump_profile -# wrong constant name dump_profile_slowest_example_groups -# wrong constant name dump_profile_slowest_examples -# wrong constant name dump_summary -# wrong constant name message -# wrong constant name output_hash -# wrong constant name seed -# wrong constant name stop -# wrong constant name -# wrong constant name add -# wrong constant name default_formatter -# wrong constant name default_formatter= -# wrong constant name formatters -# wrong constant name initialize -# wrong constant name prepare_default -# wrong constant name reporter -# wrong constant name setup_default -# wrong constant name -# wrong constant name formatters -# wrong constant name dump_profile -# wrong constant name initialize -# wrong constant name output -# wrong constant name -# wrong constant name example_failed -# wrong constant name example_passed -# wrong constant name example_pending -# wrong constant name start_dump -# wrong constant name -# undefined method `initialize1' for class `RSpec::Core::Formatters::SnippetExtractor' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name beginning_line_number -# wrong constant name expression_lines -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name max_line_count -# wrong constant name source -# wrong constant name -# wrong constant name -# wrong constant name -# undefined singleton method `extract_expression_lines_at1' for `RSpec::Core::Formatters::SnippetExtractor' -# wrong constant name -# wrong constant name extract_expression_lines_at1 -# wrong constant name extract_expression_lines_at -# wrong constant name extract_line_at -# wrong constant name least_indentation_from -# wrong constant name source_from_file -# wrong constant name -# wrong constant name -# wrong constant name highlight -# wrong constant name initialize -# wrong constant name -# wrong constant name highlight_syntax -# wrong constant name -# wrong constant name highlight_syntax -# wrong constant name -# wrong constant name attempt_to_add_rspec_terms_to_coderay_keywords -# wrong constant name -# wrong constant name register -# wrong constant name < -# wrong constant name <= -# wrong constant name > -# wrong constant name >= -# wrong constant name -# wrong constant name [] -# wrong constant name []= -# wrong constant name all? -# wrong constant name any? # wrong constant name assert_valid_keys -# wrong constant name assoc -# wrong constant name chain -# wrong constant name chunk -# wrong constant name chunk_while -# wrong constant name clear -# wrong constant name collect -# wrong constant name collect_concat -# wrong constant name compact -# wrong constant name compact! -# wrong constant name compare_by_identity -# wrong constant name compare_by_identity? -# wrong constant name count -# wrong constant name cycle # wrong constant name deep_merge # wrong constant name deep_merge! # wrong constant name deep_stringify_keys @@ -17810,275 +10859,19 @@ # wrong constant name deep_symbolize_keys! # wrong constant name deep_transform_keys # wrong constant name deep_transform_keys! -# wrong constant name default -# wrong constant name default= -# wrong constant name default_proc -# wrong constant name default_proc= -# wrong constant name delete -# wrong constant name delete_if -# wrong constant name detect -# wrong constant name dig -# wrong constant name drop -# wrong constant name drop_while -# wrong constant name each -# wrong constant name each_cons -# wrong constant name each_entry -# wrong constant name each_key -# wrong constant name each_pair -# wrong constant name each_slice -# wrong constant name each_value -# wrong constant name each_with_index -# wrong constant name each_with_object -# wrong constant name empty? -# wrong constant name entries # wrong constant name except # wrong constant name except! # wrong constant name extract! # wrong constant name extractable_options? -# wrong constant name fetch -# wrong constant name fetch_values -# wrong constant name filter -# wrong constant name filter! -# wrong constant name find -# wrong constant name find_all -# wrong constant name find_index -# wrong constant name first -# wrong constant name flat_map -# wrong constant name flatten -# wrong constant name grep -# wrong constant name grep_v -# wrong constant name group_by -# wrong constant name has_key? -# wrong constant name has_value? -# wrong constant name include? -# wrong constant name index -# wrong constant name inject -# wrong constant name invert -# wrong constant name keep_if -# wrong constant name key -# wrong constant name key? -# wrong constant name keys -# wrong constant name lazy -# wrong constant name length -# wrong constant name map -# wrong constant name max -# wrong constant name max_by -# wrong constant name member? -# wrong constant name merge -# wrong constant name merge! -# wrong constant name min -# wrong constant name min_by -# wrong constant name minmax -# wrong constant name minmax_by -# wrong constant name none? -# wrong constant name one? -# wrong constant name partition -# wrong constant name rassoc -# wrong constant name reduce -# wrong constant name rehash -# wrong constant name reject -# wrong constant name reject! -# wrong constant name replace -# wrong constant name reverse_each # wrong constant name save_plist -# wrong constant name select -# wrong constant name select! -# wrong constant name shift -# wrong constant name size -# wrong constant name slice # wrong constant name slice! -# wrong constant name slice_after -# wrong constant name slice_before -# wrong constant name slice_when -# wrong constant name sort -# wrong constant name sort_by -# wrong constant name store # wrong constant name stringify_keys # wrong constant name stringify_keys! -# wrong constant name sum # wrong constant name symbolize_keys # wrong constant name symbolize_keys! -# wrong constant name take -# wrong constant name take_while -# wrong constant name to_a -# wrong constant name to_h -# wrong constant name to_hash # wrong constant name to_options # wrong constant name to_options! # wrong constant name to_plist -# wrong constant name to_proc -# wrong constant name to_set -# wrong constant name transform_keys -# wrong constant name transform_keys! -# wrong constant name transform_values -# wrong constant name transform_values! -# wrong constant name uniq -# wrong constant name update -# wrong constant name value? -# wrong constant name values -# wrong constant name values_at -# wrong constant name zip -# wrong constant name attr_accessor -# wrong constant name hash_attribute_names -# wrong constant name -# wrong constant name -# wrong constant name included -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name after -# wrong constant name append_after -# wrong constant name append_before -# wrong constant name around -# wrong constant name before -# wrong constant name hooks -# wrong constant name prepend_after -# wrong constant name prepend_before -# uninitialized constant RSpec::Core::Hooks::AfterContextHook::Elem -# wrong constant name run -# wrong constant name -# uninitialized constant RSpec::Core::Hooks::AfterHook::Elem -# wrong constant name run -# wrong constant name -# uninitialized constant RSpec::Core::Hooks::AroundHook::Elem -# wrong constant name execute_with -# wrong constant name hook_description -# wrong constant name -# uninitialized constant RSpec::Core::Hooks::BeforeHook::Elem -# wrong constant name run -# wrong constant name -# uninitialized constant RSpec::Core::Hooks::Hook::Elem -# wrong constant name block -# wrong constant name block= -# wrong constant name options -# wrong constant name options= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name all_hooks_for -# wrong constant name initialize -# wrong constant name matching_hooks_for -# wrong constant name processable_hooks_for -# wrong constant name register -# wrong constant name register_global_singleton_context_hooks -# wrong constant name register_globals -# wrong constant name run -# wrong constant name run_owned_hooks_for -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Core::InclusionRules::PROC_HEX_NUMBER -# uninitialized constant RSpec::Core::InclusionRules::PROJECT_DIR -# wrong constant name add -# wrong constant name add_with_low_priority -# wrong constant name split_file_scoped_rules -# wrong constant name standalone? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name call -# wrong constant name -# wrong constant name call -# wrong constant name -# wrong constant name call -# wrong constant name -# uninitialized constant RSpec::Core::Invocations::PrintHelp::Elem -# wrong constant name call -# wrong constant name hidden_options -# wrong constant name hidden_options= -# wrong constant name parser -# wrong constant name parser= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name call -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name -# undefined method `should1' for module `RSpec::Core::MemoizedHelpers' -# undefined method `should2' for module `RSpec::Core::MemoizedHelpers' -# undefined method `should_not1' for module `RSpec::Core::MemoizedHelpers' -# undefined method `should_not2' for module `RSpec::Core::MemoizedHelpers' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name is_expected -# wrong constant name should1 -# wrong constant name should2 -# wrong constant name should -# wrong constant name should_not1 -# wrong constant name should_not2 -# wrong constant name should_not -# wrong constant name subject -# undefined method `subject1' for module `RSpec::Core::MemoizedHelpers::ClassMethods' -# undefined method `subject!1' for module `RSpec::Core::MemoizedHelpers::ClassMethods' -# wrong constant name let -# wrong constant name let! -# wrong constant name subject1 -# wrong constant name subject -# wrong constant name subject!1 -# wrong constant name subject! -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name article -# wrong constant name hook_expression -# wrong constant name hook_intention -# wrong constant name -# wrong constant name article -# wrong constant name hook_expression -# wrong constant name hook_intention -# wrong constant name -# wrong constant name fetch_or_store -# wrong constant name isolate_for_context_hook -# wrong constant name fetch_or_store -# wrong constant name -# wrong constant name fetch_or_store -# wrong constant name -# wrong constant name -# wrong constant name define_helpers_on -# wrong constant name get_constant_or_yield -# wrong constant name module_for -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name backwards_compatibility_default_proc -# wrong constant name create -# wrong constant name hash_with_backwards_compatibility_default_proc -# wrong constant name -# wrong constant name create -# wrong constant name block -# wrong constant name description_args -# wrong constant name initialize -# wrong constant name metadata -# wrong constant name populate -# wrong constant name user_metadata -# wrong constant name -# undefined singleton method `build_hash_from1' for `RSpec::Core::Metadata' -# wrong constant name -# wrong constant name ascend -# wrong constant name ascending -# wrong constant name build_hash_from1 -# wrong constant name build_hash_from -# wrong constant name deep_hash_dup -# wrong constant name id_from -# wrong constant name location_tuple_from -# wrong constant name relative_path -# wrong constant name relative_path_regex -# wrong constant name -# wrong constant name apply? -# wrong constant name filter_applies? -# wrong constant name silence_metadata_example_group_deprecations # wrong constant name # wrong constant name setup_mocks_for_rspec # wrong constant name teardown_mocks_for_rspec @@ -18087,2250 +10880,18 @@ # wrong constant name configuration # wrong constant name framework_name # wrong constant name -# wrong constant name -# wrong constant name aggregation_block_label -# wrong constant name aggregation_metadata -# wrong constant name all_exceptions -# wrong constant name exception_count_description -# wrong constant name failures -# wrong constant name initialize -# wrong constant name other_errors -# wrong constant name summary -# wrong constant name add -# wrong constant name -# wrong constant name for -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::CustomNotification::Elem -# undefined singleton method `for1' for `RSpec::Core::Notifications::CustomNotification' -# wrong constant name -# wrong constant name for1 -# wrong constant name for -# uninitialized constant RSpec::Core::Notifications::DeprecationNotification::Elem -# wrong constant name call_site -# wrong constant name call_site= -# wrong constant name deprecated -# wrong constant name deprecated= -# wrong constant name message -# wrong constant name message= -# wrong constant name replacement -# wrong constant name replacement= -# wrong constant name -# wrong constant name [] -# wrong constant name from_hash -# wrong constant name members -# uninitialized constant RSpec::Core::Notifications::ExampleNotification::Elem -# wrong constant name example -# wrong constant name example= -# wrong constant name -# wrong constant name [] -# wrong constant name for -# wrong constant name members -# undefined method `fully_formatted_failed_examples1' for class `RSpec::Core::Notifications::ExamplesNotification' -# undefined method `fully_formatted_pending_examples1' for class `RSpec::Core::Notifications::ExamplesNotification' -# wrong constant name examples -# wrong constant name failed_examples -# wrong constant name failure_notifications -# wrong constant name fully_formatted_failed_examples1 -# wrong constant name fully_formatted_failed_examples -# wrong constant name fully_formatted_pending_examples1 -# wrong constant name fully_formatted_pending_examples -# wrong constant name initialize -# wrong constant name notifications -# wrong constant name pending_examples -# wrong constant name pending_notifications -# wrong constant name -# undefined method `colorized_formatted_backtrace1' for class `RSpec::Core::Notifications::FailedExampleNotification' -# undefined method `colorized_message_lines1' for class `RSpec::Core::Notifications::FailedExampleNotification' -# undefined method `fully_formatted1' for class `RSpec::Core::Notifications::FailedExampleNotification' -# undefined method `fully_formatted_lines1' for class `RSpec::Core::Notifications::FailedExampleNotification' -# undefined method `initialize1' for class `RSpec::Core::Notifications::FailedExampleNotification' -# uninitialized constant RSpec::Core::Notifications::FailedExampleNotification::Elem -# wrong constant name colorized_formatted_backtrace1 -# wrong constant name colorized_formatted_backtrace -# wrong constant name colorized_message_lines1 -# wrong constant name colorized_message_lines -# wrong constant name description -# wrong constant name exception -# wrong constant name formatted_backtrace -# wrong constant name fully_formatted1 -# wrong constant name fully_formatted -# wrong constant name fully_formatted_lines1 -# wrong constant name fully_formatted_lines -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name message_lines -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::GroupNotification::Elem -# wrong constant name group -# wrong constant name group= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# uninitialized constant RSpec::Core::Notifications::MessageNotification::Elem -# wrong constant name message -# wrong constant name message= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name wrap -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification::Elem -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::PendingExampleFixedNotification::Elem -# wrong constant name -# wrong constant name duration -# wrong constant name examples -# wrong constant name initialize -# wrong constant name number_of_examples -# wrong constant name percentage -# wrong constant name slow_duration -# wrong constant name slowest_examples -# wrong constant name slowest_groups -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::SeedNotification::Elem -# wrong constant name fully_formatted -# wrong constant name seed -# wrong constant name seed= -# wrong constant name seed_used? -# wrong constant name used= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# undefined method `fully_formatted1' for class `RSpec::Core::Notifications::SkippedExampleNotification' -# uninitialized constant RSpec::Core::Notifications::SkippedExampleNotification::Elem -# wrong constant name fully_formatted1 -# wrong constant name fully_formatted -# wrong constant name -# uninitialized constant RSpec::Core::Notifications::StartNotification::Elem -# wrong constant name count -# wrong constant name count= -# wrong constant name load_time -# wrong constant name load_time= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# undefined method `colorized_rerun_commands1' for class `RSpec::Core::Notifications::SummaryNotification' -# undefined method `colorized_totals_line1' for class `RSpec::Core::Notifications::SummaryNotification' -# undefined method `fully_formatted1' for class `RSpec::Core::Notifications::SummaryNotification' -# uninitialized constant RSpec::Core::Notifications::SummaryNotification::Elem -# uninitialized constant RSpec::Core::Notifications::SummaryNotification::SHELLS_ALLOWING_UNQUOTED_IDS -# wrong constant name colorized_rerun_commands1 -# wrong constant name colorized_rerun_commands -# wrong constant name colorized_totals_line1 -# wrong constant name colorized_totals_line -# wrong constant name duration -# wrong constant name duration= -# wrong constant name errors_outside_of_examples_count -# wrong constant name errors_outside_of_examples_count= -# wrong constant name example_count -# wrong constant name examples -# wrong constant name examples= -# wrong constant name failed_examples -# wrong constant name failed_examples= -# wrong constant name failure_count -# wrong constant name formatted_duration -# wrong constant name formatted_load_time -# wrong constant name fully_formatted1 -# wrong constant name fully_formatted -# wrong constant name load_time -# wrong constant name load_time= -# wrong constant name pending_count -# wrong constant name pending_examples -# wrong constant name pending_examples= -# wrong constant name totals_line -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `register_ordering1' for class `RSpec::Core::Ordering::ConfigurationManager' -# wrong constant name force -# wrong constant name order= -# wrong constant name ordering_registry -# wrong constant name register_ordering1 -# wrong constant name register_ordering -# wrong constant name seed -# wrong constant name seed= -# wrong constant name seed_used? -# wrong constant name -# wrong constant name initialize -# wrong constant name order -# wrong constant name -# wrong constant name order -# wrong constant name -# wrong constant name initialize -# wrong constant name order -# wrong constant name used? -# wrong constant name -# wrong constant name fetch -# wrong constant name initialize -# wrong constant name register -# wrong constant name used_random_seed? -# wrong constant name -# wrong constant name -# undefined method `respond_to?1' for class `RSpec::Core::OutputWrapper' -# wrong constant name << -# wrong constant name advise # wrong constant name as_json -# wrong constant name autoclose= -# wrong constant name autoclose? -# wrong constant name binmode -# wrong constant name binmode? -# wrong constant name bytes -# wrong constant name chars -# wrong constant name close -# wrong constant name close_on_exec= -# wrong constant name close_on_exec? -# wrong constant name close_read -# wrong constant name close_write -# wrong constant name closed? -# wrong constant name codepoints -# wrong constant name each -# wrong constant name each_byte -# wrong constant name each_char -# wrong constant name each_codepoint -# wrong constant name each_line -# wrong constant name eof -# wrong constant name eof? -# wrong constant name external_encoding -# wrong constant name fcntl -# wrong constant name fdatasync -# wrong constant name fileno -# wrong constant name flush -# wrong constant name fsync -# wrong constant name getbyte -# wrong constant name getc -# wrong constant name gets -# wrong constant name initialize -# wrong constant name inspect -# wrong constant name internal_encoding -# wrong constant name ioctl -# wrong constant name isatty -# wrong constant name lineno -# wrong constant name lineno= -# wrong constant name lines -# wrong constant name method_missing # wrong constant name nonblock # wrong constant name nonblock= # wrong constant name nonblock? # wrong constant name nread -# wrong constant name output -# wrong constant name output= -# wrong constant name pathconf -# wrong constant name pid -# wrong constant name pos -# wrong constant name pos= -# wrong constant name pread -# wrong constant name print -# wrong constant name printf -# wrong constant name putc -# wrong constant name puts -# wrong constant name pwrite -# wrong constant name read -# wrong constant name read_nonblock -# wrong constant name readbyte -# wrong constant name readchar -# wrong constant name readline -# wrong constant name readlines -# wrong constant name readpartial # wrong constant name ready? -# wrong constant name reopen -# wrong constant name respond_to?1 -# wrong constant name respond_to? -# wrong constant name rewind -# wrong constant name seek -# wrong constant name set_encoding -# wrong constant name stat -# wrong constant name sync -# wrong constant name sync= -# wrong constant name sysread -# wrong constant name sysseek -# wrong constant name syswrite -# wrong constant name tell -# wrong constant name to_i -# wrong constant name to_io -# wrong constant name tty? -# wrong constant name ungetbyte -# wrong constant name ungetc # wrong constant name wait # wrong constant name wait_readable # wrong constant name wait_writable -# wrong constant name write -# wrong constant name write_nonblock -# wrong constant name -# undefined method `parse1' for class `RSpec::Core::Parser' -# wrong constant name initialize -# wrong constant name original_args -# wrong constant name parse1 -# wrong constant name parse -# undefined singleton method `parse1' for `RSpec::Core::Parser' -# wrong constant name -# wrong constant name parse1 -# wrong constant name parse -# undefined method `pending1' for module `RSpec::Core::Pending' -# undefined method `skip1' for module `RSpec::Core::Pending' -# wrong constant name -# wrong constant name -# wrong constant name pending1 -# wrong constant name pending -# wrong constant name skip1 -# wrong constant name skip -# wrong constant name -# wrong constant name argument -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name mark_fixed! -# wrong constant name mark_pending! -# wrong constant name mark_skipped! -# wrong constant name example_group_finished -# wrong constant name example_group_started -# wrong constant name example_groups -# wrong constant name example_started -# wrong constant name -# undefined method `publish1' for class `RSpec::Core::Reporter' -# undefined method `start1' for class `RSpec::Core::Reporter' -# wrong constant name abort_with -# wrong constant name close_after -# wrong constant name deprecation -# wrong constant name example_failed -# wrong constant name example_finished -# wrong constant name example_group_finished -# wrong constant name example_group_started -# wrong constant name example_passed -# wrong constant name example_pending -# wrong constant name example_started -# wrong constant name examples -# wrong constant name exit_early -# wrong constant name fail_fast_limit_met? -# wrong constant name failed_examples -# wrong constant name finish -# wrong constant name initialize -# wrong constant name message -# wrong constant name notify -# wrong constant name notify_non_example_exception -# wrong constant name pending_examples -# wrong constant name prepare_default -# wrong constant name publish1 -# wrong constant name publish -# wrong constant name register_listener -# wrong constant name registered_listeners -# wrong constant name report -# wrong constant name start1 -# wrong constant name start -# wrong constant name stop -# wrong constant name -# wrong constant name -# wrong constant name add_dir_to_load_path -# wrong constant name add_to_load_path -# wrong constant name ascend_until -# wrong constant name determine_root -# wrong constant name find_first_parent_containing -# wrong constant name root -# undefined method `initialize1' for class `RSpec::Core::Runner' -# undefined method `initialize2' for class `RSpec::Core::Runner' -# wrong constant name configuration -# wrong constant name configure -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name options -# wrong constant name run -# wrong constant name run_specs -# wrong constant name setup -# wrong constant name world -# undefined singleton method `run1' for `RSpec::Core::Runner' -# undefined singleton method `run2' for `RSpec::Core::Runner' -# wrong constant name -# wrong constant name autorun -# wrong constant name autorun_disabled? -# wrong constant name disable_autorun! -# wrong constant name handle_interrupt -# wrong constant name installed_at_exit? -# wrong constant name invoke -# wrong constant name perform_at_exit -# wrong constant name run1 -# wrong constant name run2 -# wrong constant name run -# wrong constant name running_in_drb? -# wrong constant name trap_interrupt -# undefined method `initialize1' for class `RSpec::Core::Set' -# wrong constant name << -# uninitialized constant RSpec::Core::Set::Elem -# wrong constant name clear -# wrong constant name delete -# wrong constant name each -# wrong constant name empty? -# wrong constant name include? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name merge -# wrong constant name -# wrong constant name # uninitialized constant RSpec::Core::SharedContext::VERSION -# wrong constant name __shared_context_recordings -# wrong constant name after -# wrong constant name append_after -# wrong constant name append_before -# wrong constant name around -# wrong constant name before -# wrong constant name context -# wrong constant name describe -# wrong constant name hooks -# wrong constant name included -# wrong constant name let -# wrong constant name let! -# wrong constant name prepend_after -# wrong constant name prepend_before -# wrong constant name subject -# wrong constant name subject! -# uninitialized constant RSpec::Core::SharedContext::Recording::Elem -# wrong constant name args -# wrong constant name args= -# wrong constant name block -# wrong constant name block= -# wrong constant name method_name -# wrong constant name method_name= -# wrong constant name playback_onto -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name record -# wrong constant name -# wrong constant name -# wrong constant name shared_context -# wrong constant name shared_examples -# wrong constant name shared_examples_for -# wrong constant name add -# wrong constant name find -# wrong constant name -# wrong constant name -# wrong constant name definitions -# wrong constant name expose_globally! -# wrong constant name exposed_globally? -# wrong constant name remove_globally! -# wrong constant name -# wrong constant name description -# wrong constant name formatted_inclusion_location -# wrong constant name inclusion_location -# wrong constant name initialize -# wrong constant name shared_group_name -# wrong constant name -# wrong constant name current_backtrace -# wrong constant name shared_example_group_inclusions -# wrong constant name with_frame -# uninitialized constant RSpec::Core::SharedExampleGroupModule::DELEGATION_RESERVED_KEYWORDS -# uninitialized constant RSpec::Core::SharedExampleGroupModule::DELEGATION_RESERVED_METHOD_NAMES -# uninitialized constant RSpec::Core::SharedExampleGroupModule::RUBY_RESERVED_KEYWORDS -# wrong constant name definition -# wrong constant name include_in -# wrong constant name included -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name conditionally_quote -# wrong constant name escape -# wrong constant name quote -# wrong constant name shell_allows_unquoted_ids? -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name now -# wrong constant name -# undefined method `deprecate1' for module `RSpec::Core::Warnings' -# undefined method `warn_deprecation1' for module `RSpec::Core::Warnings' -# undefined method `warn_with1' for module `RSpec::Core::Warnings' -# wrong constant name deprecate1 -# wrong constant name deprecate -# wrong constant name warn_deprecation1 -# wrong constant name warn_deprecation -# wrong constant name warn_with1 -# wrong constant name warn_with -# wrong constant name -# undefined method `example_count1' for class `RSpec::Core::World' -# undefined method `initialize1' for class `RSpec::Core::World' -# wrong constant name -# wrong constant name all_example_groups -# wrong constant name all_examples -# wrong constant name announce_exclusion_filter -# wrong constant name announce_filters -# wrong constant name announce_inclusion_filter -# wrong constant name everything_filtered_message -# wrong constant name example_count1 -# wrong constant name example_count -# wrong constant name example_group_counts_by_spec_file -# wrong constant name example_groups -# wrong constant name exclusion_filter -# wrong constant name filter_manager -# wrong constant name filtered_examples -# wrong constant name inclusion_filter -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name non_example_failure -# wrong constant name non_example_failure= -# wrong constant name num_example_groups_defined_in -# wrong constant name ordered_example_groups -# wrong constant name preceding_declaration_line -# wrong constant name prepare_example_filtering -# wrong constant name record -# wrong constant name registered_example_group_files -# wrong constant name report_filter_message -# wrong constant name reporter -# wrong constant name reset -# wrong constant name shared_example_group_registry -# wrong constant name source_from_file -# wrong constant name syntax_highlighter -# wrong constant name traverse_example_group_trees_until -# wrong constant name wants_to_quit -# wrong constant name wants_to_quit= -# wrong constant name -# wrong constant name all_example_groups -# wrong constant name example_groups -# wrong constant name non_example_failure -# wrong constant name non_example_failure= -# wrong constant name registered_example_group_files -# wrong constant name traverse_example_group_trees_until -# wrong constant name -# wrong constant name -# wrong constant name path_to_executable -# wrong constant name -# wrong constant name assign_const -# wrong constant name base_name_for -# wrong constant name constant_scope_for -# wrong constant name disambiguate -# wrong constant name remove_all_constants -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `not_to1' for class `RSpec::Expectations::BlockExpectationTarget' -# undefined method `to1' for class `RSpec::Expectations::BlockExpectationTarget' -# undefined method `to_not1' for class `RSpec::Expectations::BlockExpectationTarget' -# wrong constant name not_to1 -# wrong constant name not_to -# wrong constant name to1 -# wrong constant name to -# wrong constant name to_not1 -# wrong constant name to_not -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name body_content_lines -# wrong constant name initialize -# wrong constant name method_name -# wrong constant name -# uninitialized constant RSpec::Expectations::BlockSnippetExtractor::BlockLocator::Elem -# wrong constant name beginning_line_number -# wrong constant name beginning_line_number= -# wrong constant name body_content_locations -# wrong constant name method_call_location -# wrong constant name method_name -# wrong constant name method_name= -# wrong constant name source -# wrong constant name source= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# uninitialized constant RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor::Elem -# wrong constant name beginning_line_number -# wrong constant name beginning_line_number= -# wrong constant name body_tokens -# wrong constant name method_name -# wrong constant name method_name= -# wrong constant name source -# wrong constant name source= -# wrong constant name state -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name try_extracting_single_line_body_of -# wrong constant name -# wrong constant name add_should_and_should_not_to -# wrong constant name backtrace_formatter -# wrong constant name backtrace_formatter= -# wrong constant name color? -# wrong constant name false_positives_handler -# wrong constant name include_chain_clauses_in_custom_matcher_descriptions= -# wrong constant name include_chain_clauses_in_custom_matcher_descriptions? -# wrong constant name max_formatted_output_length= -# wrong constant name on_potential_false_positives -# wrong constant name on_potential_false_positives= -# wrong constant name reset_syntaxes_to_default -# wrong constant name syntax -# wrong constant name syntax= -# wrong constant name warn_about_potential_false_positives= -# wrong constant name warn_about_potential_false_positives? -# wrong constant name -# wrong constant name format_backtrace -# wrong constant name -# wrong constant name -# wrong constant name check_message -# wrong constant name handle_failure -# wrong constant name modern_matcher_from -# wrong constant name with_matcher -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name target -# undefined method `not_to1' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# undefined method `not_to2' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# undefined method `to1' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# undefined method `to2' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# undefined method `to_not1' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# undefined method `to_not2' for module `RSpec::Expectations::ExpectationTarget::InstanceMethods' -# wrong constant name not_to1 -# wrong constant name not_to2 -# wrong constant name not_to -# wrong constant name to1 -# wrong constant name to2 -# wrong constant name to -# wrong constant name to_not1 -# wrong constant name to_not2 -# wrong constant name to_not -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name for -# wrong constant name aggregate -# wrong constant name block_label -# wrong constant name call -# wrong constant name failures -# wrong constant name initialize -# wrong constant name metadata -# wrong constant name other_errors -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name -# wrong constant name interface_matches? -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name -# wrong constant name interface_matches? -# wrong constant name -# wrong constant name wrap -# wrong constant name aggregation_block_label -# wrong constant name aggregation_metadata -# wrong constant name all_exceptions -# wrong constant name exception_count_description -# wrong constant name failures -# wrong constant name initialize -# wrong constant name other_errors -# wrong constant name summary -# wrong constant name -# undefined singleton method `handle_matcher1' for `RSpec::Expectations::NegativeExpectationHandler' -# wrong constant name -# wrong constant name does_not_match? -# wrong constant name handle_matcher1 -# wrong constant name handle_matcher -# wrong constant name opposite_should_method -# wrong constant name should_method -# wrong constant name verb -# undefined singleton method `handle_matcher1' for `RSpec::Expectations::PositiveExpectationHandler' -# wrong constant name -# wrong constant name handle_matcher1 -# wrong constant name handle_matcher -# wrong constant name opposite_should_method -# wrong constant name should_method -# wrong constant name verb -# undefined singleton method `disable_expect1' for `RSpec::Expectations::Syntax' -# undefined singleton method `disable_should1' for `RSpec::Expectations::Syntax' -# undefined singleton method `enable_expect1' for `RSpec::Expectations::Syntax' -# undefined singleton method `enable_should1' for `RSpec::Expectations::Syntax' -# undefined singleton method `expect_enabled?1' for `RSpec::Expectations::Syntax' -# undefined singleton method `should_enabled?1' for `RSpec::Expectations::Syntax' -# wrong constant name -# wrong constant name default_should_host -# wrong constant name disable_expect1 -# wrong constant name disable_expect -# wrong constant name disable_should1 -# wrong constant name disable_should -# wrong constant name enable_expect1 -# wrong constant name enable_expect -# wrong constant name enable_should1 -# wrong constant name enable_should -# wrong constant name expect_enabled?1 -# wrong constant name expect_enabled? -# wrong constant name should_enabled?1 -# wrong constant name should_enabled? -# wrong constant name warn_about_should! -# wrong constant name warn_about_should_unless_configured -# wrong constant name -# undefined singleton method `fail_with1' for `RSpec::Expectations' -# undefined singleton method `fail_with2' for `RSpec::Expectations' -# wrong constant name -# wrong constant name configuration -# wrong constant name differ -# wrong constant name fail_with1 -# wrong constant name fail_with2 -# wrong constant name fail_with # wrong constant name its # wrong constant name -# undefined method `aggregate_failures1' for module `RSpec::Matchers' -# undefined method `aggregate_failures2' for module `RSpec::Matchers' -# undefined method `change1' for module `RSpec::Matchers' -# undefined method `change2' for module `RSpec::Matchers' -# undefined method `expect1' for module `RSpec::Matchers' -# undefined method `output1' for module `RSpec::Matchers' -# undefined method `raise_error1' for module `RSpec::Matchers' -# undefined method `raise_error2' for module `RSpec::Matchers' -# undefined method `raise_exception1' for module `RSpec::Matchers' -# undefined method `raise_exception2' for module `RSpec::Matchers' -# undefined method `satisfy1' for module `RSpec::Matchers' -# undefined method `throw_symbol1' for module `RSpec::Matchers' -# undefined method `throw_symbol2' for module `RSpec::Matchers' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name a_block_changing -# wrong constant name a_block_outputting -# wrong constant name a_block_raising -# wrong constant name a_block_throwing -# wrong constant name a_block_yielding_control -# wrong constant name a_block_yielding_successive_args -# wrong constant name a_block_yielding_with_args -# wrong constant name a_block_yielding_with_no_args -# wrong constant name a_collection_containing_exactly -# wrong constant name a_collection_ending_with -# wrong constant name a_collection_including -# wrong constant name a_collection_starting_with -# wrong constant name a_falsey_value -# wrong constant name a_falsy_value -# wrong constant name a_hash_including -# wrong constant name a_kind_of -# wrong constant name a_nil_value -# wrong constant name a_range_covering -# wrong constant name a_string_ending_with -# wrong constant name a_string_including -# wrong constant name a_string_matching -# wrong constant name a_string_starting_with -# wrong constant name a_truthy_value -# wrong constant name a_value -# wrong constant name a_value_between -# wrong constant name a_value_within -# wrong constant name aggregate_failures1 -# wrong constant name aggregate_failures2 -# wrong constant name aggregate_failures -# wrong constant name all -# wrong constant name an_instance_of -# wrong constant name an_object_eq_to -# wrong constant name an_object_eql_to -# wrong constant name an_object_equal_to -# wrong constant name an_object_existing -# wrong constant name an_object_having_attributes -# wrong constant name an_object_matching -# wrong constant name an_object_responding_to -# wrong constant name an_object_satisfying -# wrong constant name be -# wrong constant name be_a -# wrong constant name be_a_kind_of -# wrong constant name be_an -# wrong constant name be_an_instance_of -# wrong constant name be_between -# wrong constant name be_falsey -# wrong constant name be_falsy -# wrong constant name be_instance_of -# wrong constant name be_kind_of -# wrong constant name be_nil -# wrong constant name be_truthy -# wrong constant name be_within -# wrong constant name change1 -# wrong constant name change2 -# wrong constant name change -# wrong constant name changing -# wrong constant name contain_exactly -# wrong constant name containing_exactly -# wrong constant name cover -# wrong constant name covering -# wrong constant name end_with -# wrong constant name ending_with -# wrong constant name eq -# wrong constant name eq_to -# wrong constant name eql -# wrong constant name eql_to -# wrong constant name equal -# wrong constant name equal_to -# wrong constant name exist -# wrong constant name existing -# wrong constant name expect1 -# wrong constant name expect -# wrong constant name have_attributes -# wrong constant name having_attributes -# wrong constant name include -# wrong constant name including -# wrong constant name match -# wrong constant name match_array -# wrong constant name match_regex -# wrong constant name matching -# wrong constant name output1 -# wrong constant name output -# wrong constant name raise_error1 -# wrong constant name raise_error2 -# wrong constant name raise_error -# wrong constant name raise_exception1 -# wrong constant name raise_exception2 -# wrong constant name raise_exception -# wrong constant name raising -# wrong constant name respond_to -# wrong constant name responding_to -# wrong constant name satisfy1 -# wrong constant name satisfy -# wrong constant name satisfying -# wrong constant name start_with -# wrong constant name starting_with -# wrong constant name throw_symbol1 -# wrong constant name throw_symbol2 -# wrong constant name throw_symbol -# wrong constant name throwing -# wrong constant name within -# wrong constant name yield_control -# wrong constant name yield_successive_args -# wrong constant name yield_with_args -# wrong constant name yield_with_no_args -# wrong constant name yielding_control -# wrong constant name yielding_successive_args -# wrong constant name yielding_with_args -# wrong constant name yielding_with_no_args -# wrong constant name description -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name -# wrong constant name -# wrong constant name does_not_match? -# wrong constant name matches? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::All::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name failed_objects -# wrong constant name initialize -# wrong constant name matcher -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::BaseMatcher' -# wrong constant name -# wrong constant name -# wrong constant name actual -# wrong constant name actual_formatted -# wrong constant name description -# wrong constant name diffable? -# wrong constant name expected -# wrong constant name expected_formatted -# wrong constant name expects_call_stack_jump? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name match_unless_raises -# wrong constant name matcher_name -# wrong constant name matcher_name= -# wrong constant name matches? -# wrong constant name present_ivars -# wrong constant name rescued_exception -# wrong constant name supports_block_expectations? -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name -# wrong constant name has_default_failure_messages? -# wrong constant name -# wrong constant name improve_hash_formatting -# wrong constant name -# wrong constant name matcher_name -# wrong constant name < -# wrong constant name <= -# wrong constant name == -# wrong constant name === -# wrong constant name =~ -# wrong constant name > -# wrong constant name >= -# uninitialized constant RSpec::Matchers::BuiltIn::Be::UNDEFINED -# wrong constant name initialize -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeAKindOf::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeAnInstanceOf::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeBetween::UNDEFINED -# wrong constant name exclusive -# wrong constant name inclusive -# wrong constant name initialize -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeComparedTo::UNDEFINED -# wrong constant name initialize -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeFalsey::UNDEFINED -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeNil::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BePredicate::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeTruthy::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::BeWithin::UNDEFINED -# wrong constant name initialize -# wrong constant name of -# wrong constant name percent_of -# wrong constant name -# wrong constant name -# wrong constant name capture -# wrong constant name -# wrong constant name capture -# wrong constant name capture -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::Change' -# undefined method `initialize2' for class `RSpec::Matchers::BuiltIn::Change' -# uninitialized constant RSpec::Matchers::BuiltIn::Change::UNDEFINED -# wrong constant name by -# wrong constant name by_at_least -# wrong constant name by_at_most -# wrong constant name does_not_match? -# wrong constant name from -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name to -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::ChangeDetails' -# undefined method `initialize2' for class `RSpec::Matchers::BuiltIn::ChangeDetails' -# wrong constant name actual_after -# wrong constant name actual_delta -# wrong constant name changed? -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name perform_change -# wrong constant name value_representation -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::ChangeFromValue::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name to -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::ChangeRelatively::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::ChangeToValue::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name from -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Compound::UNDEFINED -# wrong constant name diffable_matcher_list -# wrong constant name does_not_match? -# wrong constant name evaluator -# wrong constant name initialize -# wrong constant name matcher_1 -# wrong constant name matcher_2 -# uninitialized constant RSpec::Matchers::BuiltIn::Compound::And::UNDEFINED -# wrong constant name -# wrong constant name initialize -# wrong constant name matcher_matches? -# wrong constant name -# wrong constant name matcher_expects_call_stack_jump? -# uninitialized constant RSpec::Matchers::BuiltIn::Compound::Or::UNDEFINED -# wrong constant name -# wrong constant name initialize -# wrong constant name matcher_matches? -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::ContainExactly::UNDEFINED -# wrong constant name -# wrong constant name -# wrong constant name actual_to_expected_matched_indexes -# wrong constant name expected_to_actual_matched_indexes -# wrong constant name find_best_solution -# wrong constant name initialize -# wrong constant name solution -# wrong constant name -# wrong constant name worse_than? -# wrong constant name + -# uninitialized constant RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution::Elem -# wrong constant name candidate? -# wrong constant name ideal? -# wrong constant name indeterminate_actual_indexes -# wrong constant name indeterminate_actual_indexes= -# wrong constant name indeterminate_expected_indexes -# wrong constant name indeterminate_expected_indexes= -# wrong constant name unmatched_actual_indexes -# wrong constant name unmatched_actual_indexes= -# wrong constant name unmatched_expected_indexes -# wrong constant name unmatched_expected_indexes= -# wrong constant name unmatched_item_count -# wrong constant name worse_than? -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Cover::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::EndWith::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Eq::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Eql::UNDEFINED -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Equal::UNDEFINED -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Exist::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name actual_exists? -# wrong constant name valid_test? -# wrong constant name validity_message -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Has::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::HaveAttributes::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name respond_to_failed -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Include::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name expecteds -# wrong constant name initialize -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::Match::UNDEFINED -# wrong constant name initialize -# wrong constant name with_captures -# wrong constant name -# wrong constant name __delegate_operator -# wrong constant name -# wrong constant name -# wrong constant name capture -# wrong constant name != -# wrong constant name !~ -# wrong constant name < -# wrong constant name <= -# wrong constant name == -# wrong constant name === -# wrong constant name =~ -# wrong constant name > -# wrong constant name >= -# wrong constant name description -# wrong constant name fail_with_message -# wrong constant name initialize -# wrong constant name -# wrong constant name get -# wrong constant name register -# wrong constant name registry -# wrong constant name unregister -# wrong constant name use_custom_matcher_or_delegate -# uninitialized constant RSpec::Matchers::BuiltIn::Output::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name to_stderr -# wrong constant name to_stderr_from_any_process -# wrong constant name to_stdout -# wrong constant name to_stdout_from_any_process -# wrong constant name -# wrong constant name __delegate_operator -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::RaiseError' -# undefined method `initialize2' for class `RSpec::Matchers::BuiltIn::RaiseError' -# undefined method `matches?1' for class `RSpec::Matchers::BuiltIn::RaiseError' -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name expects_call_stack_jump? -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name matches?1 -# wrong constant name matches? -# wrong constant name supports_block_expectations? -# wrong constant name with_message -# wrong constant name -# wrong constant name captures -# wrong constant name initialize -# wrong constant name match_data -# wrong constant name names -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::RespondTo::UNDEFINED -# wrong constant name and_any_keywords -# wrong constant name and_keywords -# wrong constant name and_unlimited_arguments -# wrong constant name argument -# wrong constant name arguments -# wrong constant name does_not_match? -# wrong constant name ignoring_method_signature_failure! -# wrong constant name initialize -# wrong constant name with -# wrong constant name with_any_keywords -# wrong constant name with_keywords -# wrong constant name with_unlimited_arguments -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::Satisfy' -# uninitialized constant RSpec::Matchers::BuiltIn::Satisfy::UNDEFINED -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::SpecificValuesChange::UNDEFINED -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::StartOrEndWith::UNDEFINED -# wrong constant name initialize -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::StartWith::UNDEFINED -# wrong constant name -# undefined method `initialize1' for class `RSpec::Matchers::BuiltIn::ThrowSymbol' -# undefined method `initialize2' for class `RSpec::Matchers::BuiltIn::ThrowSymbol' -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name expects_call_stack_jump? -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name supports_block_expectations? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::YieldControl::UNDEFINED -# wrong constant name at_least -# wrong constant name at_most -# wrong constant name does_not_match? -# wrong constant name exactly -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name once -# wrong constant name thrice -# wrong constant name times -# wrong constant name twice -# wrong constant name -# wrong constant name assert_used! -# wrong constant name assert_valid_expect_block! -# wrong constant name has_block? -# wrong constant name initialize -# wrong constant name num_yields -# wrong constant name num_yields= -# wrong constant name probe -# wrong constant name single_yield_args -# wrong constant name to_proc -# wrong constant name yielded_args -# wrong constant name yielded_args= -# wrong constant name yielded_once? -# wrong constant name -# wrong constant name probe -# uninitialized constant RSpec::Matchers::BuiltIn::YieldSuccessiveArgs::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::YieldWithArgs::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name -# uninitialized constant RSpec::Matchers::BuiltIn::YieldWithNoArgs::UNDEFINED -# wrong constant name does_not_match? -# wrong constant name matches? -# wrong constant name -# wrong constant name -# wrong constant name & -# wrong constant name === -# wrong constant name and -# wrong constant name or -# wrong constant name | -# wrong constant name -# wrong constant name should_enumerate? -# wrong constant name surface_descriptions_in -# wrong constant name unreadable_io? -# undefined method `alias_matcher1' for module `RSpec::Matchers::DSL' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name alias_matcher1 -# wrong constant name alias_matcher -# wrong constant name define -# wrong constant name define_negated_matcher -# wrong constant name matcher -# wrong constant name description -# wrong constant name diffable? -# wrong constant name expects_call_stack_jump? -# wrong constant name supports_block_expectations? -# wrong constant name -# undefined method `match1' for module `RSpec::Matchers::DSL::Macros' -# undefined method `match_unless_raises1' for module `RSpec::Matchers::DSL::Macros' -# undefined method `match_when_negated1' for module `RSpec::Matchers::DSL::Macros' -# wrong constant name -# wrong constant name chain -# wrong constant name description -# wrong constant name diffable -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name match1 -# wrong constant name match -# wrong constant name match_unless_raises1 -# wrong constant name match_unless_raises -# wrong constant name match_when_negated1 -# wrong constant name match_when_negated -# wrong constant name supports_block_expectations -# wrong constant name failure_message_for_should -# wrong constant name failure_message_for_should_not -# wrong constant name match_for_should -# wrong constant name match_for_should_not -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Matchers::DSL::Matcher::BE_PREDICATE_REGEX -# uninitialized constant RSpec::Matchers::DSL::Matcher::DYNAMIC_MATCHER_REGEX -# uninitialized constant RSpec::Matchers::DSL::Matcher::HAS_REGEX -# wrong constant name actual -# wrong constant name block_arg -# wrong constant name expected -# wrong constant name expected_as_array -# wrong constant name initialize -# wrong constant name name -# wrong constant name rescued_exception -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name list -# wrong constant name split_words -# wrong constant name initialize -# wrong constant name message_with_diff -# wrong constant name -# wrong constant name for_many_matchers -# wrong constant name from -# wrong constant name base_matcher -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name -# wrong constant name -# wrong constant name alias_matcher -# wrong constant name clear_generated_description -# wrong constant name configuration -# wrong constant name generated_description -# wrong constant name is_a_describable_matcher? -# wrong constant name is_a_matcher? -# wrong constant name last_description -# wrong constant name last_expectation_handler -# wrong constant name last_expectation_handler= -# wrong constant name last_matcher -# wrong constant name last_matcher= -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name expression -# wrong constant name not_to -# wrong constant name to -# wrong constant name to_not -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name call -# wrong constant name initial_action= -# wrong constant name initialize -# wrong constant name inner_action -# wrong constant name inner_action= -# wrong constant name terminal_action= -# wrong constant name -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name constrained_to_any_of? -# wrong constant name expectation_fulfilled! -# wrong constant name initialize -# wrong constant name matches_args? -# wrong constant name never -# wrong constant name playback! -# wrong constant name and_call_original -# wrong constant name and_raise -# wrong constant name and_return -# wrong constant name and_throw -# wrong constant name and_wrap_original -# wrong constant name and_yield -# wrong constant name at_least -# wrong constant name at_most -# wrong constant name exactly -# wrong constant name never -# wrong constant name once -# wrong constant name thrice -# wrong constant name time -# wrong constant name times -# wrong constant name twice -# wrong constant name with -# wrong constant name -# wrong constant name record -# wrong constant name -# wrong constant name raise_does_not_implement_error -# wrong constant name raise_message_already_received_by_other_instance_error -# wrong constant name raise_not_supported_with_prepend_error -# wrong constant name raise_second_instance_received_message_error -# wrong constant name -# uninitialized constant RSpec::Mocks::AnyInstance::ExpectChainChain::EmptyInvocationOrder -# uninitialized constant RSpec::Mocks::AnyInstance::ExpectChainChain::InvocationOrder -# wrong constant name initialize -# wrong constant name -# wrong constant name expectation_fulfilled? -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name -# wrong constant name [] -# wrong constant name add -# wrong constant name all_expectations_fulfilled? -# wrong constant name each_unfulfilled_expectation_matching -# wrong constant name has_expectation? -# wrong constant name playback! -# wrong constant name received_expected_message! -# wrong constant name remove_stub_chains_for! -# wrong constant name unfulfilled_expectations -# wrong constant name -# wrong constant name -# wrong constant name expect_chain -# wrong constant name initialize -# wrong constant name klass -# wrong constant name should_not_receive -# wrong constant name should_receive -# wrong constant name stub -# wrong constant name stub_chain -# wrong constant name unstub -# wrong constant name -# wrong constant name already_observing? -# wrong constant name build_alias_method_name -# wrong constant name expect_chain -# wrong constant name initialize -# wrong constant name instance_that_received -# wrong constant name klass -# wrong constant name message_chains -# wrong constant name notify_received_message -# wrong constant name playback! -# wrong constant name should_not_receive -# wrong constant name should_receive -# wrong constant name stop_all_observation! -# wrong constant name stop_observing! -# wrong constant name stub -# wrong constant name stub_chain -# wrong constant name stubs -# wrong constant name unstub -# wrong constant name verify -# wrong constant name -# wrong constant name expectation_fulfilled? -# wrong constant name -# uninitialized constant RSpec::Mocks::AnyInstance::StubChainChain::EmptyInvocationOrder -# uninitialized constant RSpec::Mocks::AnyInstance::StubChainChain::InvocationOrder -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name error_generator -# wrong constant name expression -# wrong constant name not_to -# wrong constant name to -# wrong constant name to_not -# wrong constant name -# wrong constant name expression -# wrong constant name not_to -# wrong constant name to -# wrong constant name to_not -# wrong constant name -# wrong constant name args_match? -# wrong constant name expected_args -# wrong constant name initialize -# wrong constant name resolve_expected_args_based_on -# wrong constant name -# wrong constant name a_kind_of -# wrong constant name an_instance_of -# wrong constant name any_args -# wrong constant name anything -# wrong constant name array_including -# wrong constant name boolean -# wrong constant name duck_type -# wrong constant name hash_excluding -# wrong constant name hash_including -# wrong constant name hash_not_including -# wrong constant name instance_of -# wrong constant name kind_of -# wrong constant name no_args -# wrong constant name -# wrong constant name anythingize_lonely_keys -# wrong constant name call -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name applies_to? -# uninitialized constant RSpec::Mocks::ClassVerifyingDouble::DELEGATION_RESERVED_KEYWORDS -# uninitialized constant RSpec::Mocks::ClassVerifyingDouble::DELEGATION_RESERVED_METHOD_NAMES -# uninitialized constant RSpec::Mocks::ClassVerifyingDouble::RUBY_RESERVED_KEYWORDS -# wrong constant name -# wrong constant name add_stub_and_should_receive_to -# wrong constant name allow_message_expectations_on_nil -# wrong constant name allow_message_expectations_on_nil= -# wrong constant name before_verifying_doubles -# wrong constant name color? -# wrong constant name patch_marshal_to_support_partial_doubles= -# wrong constant name reset_syntaxes_to_default -# wrong constant name syntax -# wrong constant name syntax= -# wrong constant name temporarily_suppress_partial_double_verification -# wrong constant name temporarily_suppress_partial_double_verification= -# wrong constant name transfer_nested_constants= -# wrong constant name transfer_nested_constants? -# wrong constant name verify_doubled_constant_names= -# wrong constant name verify_doubled_constant_names? -# wrong constant name verify_partial_doubles= -# wrong constant name verify_partial_doubles? -# wrong constant name verifying_double_callbacks -# wrong constant name when_declaring_verifying_double -# wrong constant name yield_receiver_to_any_instance_implementation_blocks= -# wrong constant name yield_receiver_to_any_instance_implementation_blocks? -# wrong constant name -# wrong constant name hidden= -# wrong constant name hidden? -# wrong constant name initialize -# wrong constant name mutated? -# wrong constant name name -# wrong constant name original_value -# wrong constant name original_value= -# wrong constant name previously_defined= -# wrong constant name previously_defined? -# wrong constant name stubbed= -# wrong constant name stubbed? -# wrong constant name valid_name= -# wrong constant name valid_name? -# wrong constant name -# wrong constant name original -# wrong constant name unmutated -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name full_constant_name -# wrong constant name idempotently_reset -# wrong constant name initialize -# wrong constant name original_value -# wrong constant name to_constant -# wrong constant name -# wrong constant name mutate -# wrong constant name reset -# wrong constant name -# wrong constant name initialize -# wrong constant name mutate -# wrong constant name reset -# wrong constant name should_transfer_nested_constants? -# wrong constant name transfer_nested_constants -# wrong constant name verify_constants_to_transfer! -# wrong constant name -# wrong constant name mutate -# wrong constant name reset -# wrong constant name -# undefined singleton method `stub1' for `RSpec::Mocks::ConstantMutator' -# wrong constant name -# wrong constant name hide -# wrong constant name mutate -# wrong constant name raise_on_invalid_const -# wrong constant name stub1 -# wrong constant name stub -# wrong constant name const_to_replace -# wrong constant name defined? -# wrong constant name description -# wrong constant name initialize -# wrong constant name target -# wrong constant name when_loaded -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `intro1' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `method_call_args_description1' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `method_call_args_description2' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `raise_expectation_error1' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `raise_expectation_error2' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `raise_similar_message_args_error1' for class `RSpec::Mocks::ErrorGenerator' -# undefined method `raise_unexpected_message_args_error1' for class `RSpec::Mocks::ErrorGenerator' -# wrong constant name default_error_message -# wrong constant name describe_expectation -# wrong constant name expectation_on_nil_message -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name intro1 -# wrong constant name intro -# wrong constant name method_call_args_description1 -# wrong constant name method_call_args_description2 -# wrong constant name method_call_args_description -# wrong constant name opts -# wrong constant name opts= -# wrong constant name raise_already_invoked_error -# wrong constant name raise_cant_constrain_count_for_negated_have_received_error -# wrong constant name raise_double_negation_error -# wrong constant name raise_expectation_error1 -# wrong constant name raise_expectation_error2 -# wrong constant name raise_expectation_error -# wrong constant name raise_expectation_on_mocked_method -# wrong constant name raise_expectation_on_nil_error -# wrong constant name raise_expectation_on_unstubbed_method -# wrong constant name raise_expired_test_double_error -# wrong constant name raise_have_received_disallowed -# wrong constant name raise_invalid_arguments_error -# wrong constant name raise_method_not_stubbed_error -# wrong constant name raise_missing_block_error -# wrong constant name raise_missing_default_stub_error -# wrong constant name raise_non_public_error -# wrong constant name raise_only_valid_on_a_partial_double -# wrong constant name raise_out_of_order_error -# wrong constant name raise_similar_message_args_error1 -# wrong constant name raise_similar_message_args_error -# wrong constant name raise_unexpected_message_args_error1 -# wrong constant name raise_unexpected_message_args_error -# wrong constant name raise_unexpected_message_error -# wrong constant name raise_unimplemented_error -# wrong constant name raise_verifying_double_not_defined_error -# wrong constant name raise_wrong_arity_error -# wrong constant name -# undefined method `stub_const1' for module `RSpec::Mocks::ExampleMethods' -# wrong constant name -# wrong constant name allow -# wrong constant name allow_any_instance_of -# wrong constant name allow_message_expectations_on_nil -# wrong constant name class_double -# wrong constant name class_spy -# wrong constant name double -# wrong constant name expect_any_instance_of -# wrong constant name have_received -# wrong constant name hide_const -# wrong constant name instance_double -# wrong constant name instance_spy -# wrong constant name object_double -# wrong constant name object_spy -# wrong constant name receive -# wrong constant name receive_message_chain -# wrong constant name receive_messages -# wrong constant name spy -# wrong constant name stub_const1 -# wrong constant name stub_const -# wrong constant name without_partial_double_verification -# wrong constant name expect -# wrong constant name -# wrong constant name -# wrong constant name declare_double -# wrong constant name declare_verifying_double -# wrong constant name extended -# wrong constant name included -# wrong constant name -# wrong constant name expect_chain_on -# wrong constant name -# wrong constant name expression -# wrong constant name not_to -# wrong constant name to -# wrong constant name to_not -# wrong constant name -# wrong constant name -# wrong constant name call -# wrong constant name initial_action -# wrong constant name initial_action= -# wrong constant name inner_action -# wrong constant name inner_action= -# wrong constant name terminal_action -# wrong constant name terminal_action= -# wrong constant name -# wrong constant name -# wrong constant name handle_restoration_failures -# wrong constant name initialize -# wrong constant name method_is_stashed? -# wrong constant name original_method -# wrong constant name restore -# wrong constant name stash -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name patch! -# wrong constant name unpatch! -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name block -# wrong constant name block= -# wrong constant name initialize -# wrong constant name playback_onto -# wrong constant name -# wrong constant name at_least -# wrong constant name at_most -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name exactly -# wrong constant name failure_message -# wrong constant name failure_message_when_negated -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name name -# wrong constant name once -# wrong constant name ordered -# wrong constant name setup_allowance -# wrong constant name setup_any_instance_allowance -# wrong constant name setup_any_instance_expectation -# wrong constant name setup_any_instance_negative_expectation -# wrong constant name setup_expectation -# wrong constant name setup_negative_expectation -# wrong constant name thrice -# wrong constant name time -# wrong constant name times -# wrong constant name twice -# wrong constant name with -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name and_call_original -# wrong constant name and_raise -# wrong constant name and_return -# wrong constant name and_throw -# wrong constant name and_wrap_original -# wrong constant name and_yield -# wrong constant name at_least -# wrong constant name at_most -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name exactly -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name name -# wrong constant name never -# wrong constant name once -# wrong constant name ordered -# wrong constant name setup_allowance -# wrong constant name setup_any_instance_allowance -# wrong constant name setup_any_instance_expectation -# wrong constant name setup_any_instance_negative_expectation -# wrong constant name setup_expectation -# wrong constant name setup_negative_expectation -# wrong constant name thrice -# wrong constant name time -# wrong constant name times -# wrong constant name twice -# wrong constant name with -# wrong constant name description_for -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name and_call_original -# wrong constant name and_raise -# wrong constant name and_return -# wrong constant name and_throw -# wrong constant name and_yield -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name name -# wrong constant name setup_allowance -# wrong constant name setup_any_instance_allowance -# wrong constant name setup_any_instance_expectation -# wrong constant name setup_expectation -# wrong constant name setup_negative_expectation -# wrong constant name with -# wrong constant name -# wrong constant name description -# wrong constant name does_not_match? -# wrong constant name initialize -# wrong constant name matches? -# wrong constant name name -# wrong constant name setup_allowance -# wrong constant name setup_any_instance_allowance -# wrong constant name setup_any_instance_expectation -# wrong constant name setup_expectation -# wrong constant name setup_negative_expectation -# wrong constant name warn_about_block -# wrong constant name -# wrong constant name -# wrong constant name block -# wrong constant name chain -# wrong constant name initialize -# wrong constant name object -# wrong constant name setup_chain -# wrong constant name -# wrong constant name -# wrong constant name and_call_original -# wrong constant name and_raise -# wrong constant name and_return -# wrong constant name and_throw -# wrong constant name and_wrap_original -# wrong constant name and_yield -# wrong constant name at_least -# wrong constant name at_most -# wrong constant name exactly -# wrong constant name never -# wrong constant name once -# wrong constant name ordered -# wrong constant name thrice -# wrong constant name time -# wrong constant name times -# wrong constant name twice -# wrong constant name with -# undefined method `initialize1' for module `RSpec::Mocks::MessageExpectation::ImplementationDetails' -# undefined method `initialize2' for module `RSpec::Mocks::MessageExpectation::ImplementationDetails' -# wrong constant name actual_received_count_matters? -# wrong constant name additional_expected_calls -# wrong constant name advise -# wrong constant name and_yield_receiver_to_implementation -# wrong constant name argument_list_matcher= -# wrong constant name called_max_times? -# wrong constant name description_for -# wrong constant name ensure_expected_ordering_received! -# wrong constant name error_generator -# wrong constant name error_generator= -# wrong constant name expectation_count_type -# wrong constant name expected_args -# wrong constant name expected_from= -# wrong constant name expected_messages_received? -# wrong constant name expected_received_count= -# wrong constant name generate_error -# wrong constant name ignoring_args? -# wrong constant name implementation -# wrong constant name implementation= -# wrong constant name increase_actual_received_count! -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name invoke -# wrong constant name invoke_without_incrementing_received_count -# wrong constant name matches? -# wrong constant name matches_at_least_count? -# wrong constant name matches_at_most_count? -# wrong constant name matches_exact_count? -# wrong constant name matches_name_but_not_args -# wrong constant name message -# wrong constant name negative? -# wrong constant name negative_expectation_for? -# wrong constant name ordered? -# wrong constant name orig_object -# wrong constant name raise_out_of_order_error -# wrong constant name raise_unexpected_message_args_error -# wrong constant name safe_invoke -# wrong constant name similar_messages -# wrong constant name type -# wrong constant name unadvise -# wrong constant name verify_messages_received -# wrong constant name yield_receiver_to_implementation_block? -# wrong constant name -# wrong constant name -# undefined method `add_stub1' for class `RSpec::Mocks::MethodDouble' -# undefined method `setup_simple_method_double1' for class `RSpec::Mocks::MethodDouble' -# undefined method `setup_simple_method_double2' for class `RSpec::Mocks::MethodDouble' -# wrong constant name -# wrong constant name add_default_stub -# wrong constant name add_expectation -# wrong constant name add_simple_expectation -# wrong constant name add_simple_stub -# wrong constant name add_stub1 -# wrong constant name add_stub -# wrong constant name build_expectation -# wrong constant name clear -# wrong constant name configure_method -# wrong constant name define_proxy_method -# wrong constant name expectations -# wrong constant name message_expectation_class -# wrong constant name method_name -# wrong constant name method_stasher -# wrong constant name object -# wrong constant name object_singleton_class -# wrong constant name original_implementation_callable -# wrong constant name original_method -# wrong constant name proxy_method_invoked -# wrong constant name raise_method_not_stubbed_error -# wrong constant name remove_stub -# wrong constant name remove_stub_if_present -# wrong constant name reset -# wrong constant name restore_original_method -# wrong constant name restore_original_visibility -# wrong constant name save_original_implementation_callable! -# wrong constant name setup_simple_method_double1 -# wrong constant name setup_simple_method_double2 -# wrong constant name setup_simple_method_double -# wrong constant name show_frozen_warning -# wrong constant name stubs -# wrong constant name verify -# wrong constant name visibility -# uninitialized constant RSpec::Mocks::MethodDouble::RSpecPrependedModule::DELEGATION_RESERVED_KEYWORDS -# uninitialized constant RSpec::Mocks::MethodDouble::RSpecPrependedModule::DELEGATION_RESERVED_METHOD_NAMES -# uninitialized constant RSpec::Mocks::MethodDouble::RSpecPrependedModule::RUBY_RESERVED_KEYWORDS -# wrong constant name -# wrong constant name -# wrong constant name defined? -# wrong constant name implemented? -# wrong constant name initialize -# wrong constant name unimplemented? -# wrong constant name visibility -# wrong constant name with_signature -# wrong constant name -# wrong constant name for -# wrong constant name instance_method_visibility_for -# wrong constant name method_defined_at_any_visibility? -# wrong constant name method_visibility_for -# wrong constant name -# wrong constant name -# wrong constant name const_to_replace -# wrong constant name defined? -# wrong constant name description -# wrong constant name initialize -# wrong constant name target -# wrong constant name when_loaded -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name call -# wrong constant name -# wrong constant name -# undefined singleton method `for1' for `RSpec::Mocks::ObjectReference' -# wrong constant name -# wrong constant name for1 -# wrong constant name for -# wrong constant name -# undefined method `as_stubbed_const1' for module `RSpec::Mocks::ObjectVerifyingDoubleMethods' -# wrong constant name as_stubbed_const1 -# wrong constant name as_stubbed_const -# wrong constant name -# wrong constant name clear -# wrong constant name consume -# wrong constant name empty? -# wrong constant name handle_order_constraint -# wrong constant name invoked -# wrong constant name ready_for? -# wrong constant name register -# wrong constant name verify_invocation_order -# wrong constant name -# wrong constant name -# uninitialized constant RSpec::Mocks::PartialClassDoubleProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name -# wrong constant name initialize -# wrong constant name method_double_from_ancestor_for -# wrong constant name original_method_handle_for -# wrong constant name original_unbound_method_handle_from_ancestor_for -# wrong constant name superclass_proxy -# wrong constant name -# uninitialized constant RSpec::Mocks::PartialDoubleProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name original_method_handle_for -# wrong constant name visibility_for -# wrong constant name -# undefined method `add_message_expectation1' for class `RSpec::Mocks::Proxy' -# undefined method `add_stub1' for class `RSpec::Mocks::Proxy' -# undefined method `initialize1' for class `RSpec::Mocks::Proxy' -# wrong constant name -# wrong constant name add_message_expectation1 -# wrong constant name add_message_expectation -# wrong constant name add_simple_expectation -# wrong constant name add_simple_stub -# wrong constant name add_stub1 -# wrong constant name add_stub -# wrong constant name build_expectation -# wrong constant name check_for_unexpected_arguments -# wrong constant name ensure_implemented -# wrong constant name has_negative_expectation? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name message_received -# wrong constant name messages_arg_list -# wrong constant name method_double_if_exists_for_message -# wrong constant name object -# wrong constant name original_method_handle_for -# wrong constant name prepended_modules_of_singleton_class -# wrong constant name raise_missing_default_stub_error -# wrong constant name raise_unexpected_message_error -# wrong constant name received_message? -# wrong constant name record_message_received -# wrong constant name remove_stub -# wrong constant name remove_stub_if_present -# wrong constant name replay_received_message_on -# wrong constant name reset -# wrong constant name verify -# wrong constant name visibility_for -# wrong constant name == -# uninitialized constant RSpec::Mocks::Proxy::SpecificMessage::Elem -# wrong constant name args -# wrong constant name args= -# wrong constant name message -# wrong constant name message= -# wrong constant name object -# wrong constant name object= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name prepended_modules_of -# uninitialized constant RSpec::Mocks::ProxyForNil::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name disallow_expectations -# wrong constant name disallow_expectations= -# wrong constant name initialize -# wrong constant name warn_about_expectations -# wrong constant name warn_about_expectations= -# wrong constant name -# wrong constant name any_instance_proxy_for -# wrong constant name any_instance_recorder_for -# wrong constant name any_instance_recorders_from_ancestry_of -# wrong constant name new_scope -# wrong constant name proxy_for -# wrong constant name register_constant_mutator -# wrong constant name registered? -# wrong constant name reset_all -# wrong constant name superclass_proxy_for -# wrong constant name verify_all -# wrong constant name -# undefined method `initialize1' for class `RSpec::Mocks::SimpleMessageExpectation' -# wrong constant name called_max_times? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name invoke -# wrong constant name matches? -# wrong constant name unadvise -# wrong constant name verify_messages_received -# wrong constant name -# undefined method `any_instance_recorder_for1' for class `RSpec::Mocks::Space' -# wrong constant name any_instance_mutex -# wrong constant name any_instance_proxy_for -# wrong constant name any_instance_recorder_for1 -# wrong constant name any_instance_recorder_for -# wrong constant name any_instance_recorders -# wrong constant name any_instance_recorders_from_ancestry_of -# wrong constant name constant_mutator_for -# wrong constant name ensure_registered -# wrong constant name new_scope -# wrong constant name proxies -# wrong constant name proxies_of -# wrong constant name proxy_for -# wrong constant name proxy_mutex -# wrong constant name register_constant_mutator -# wrong constant name registered? -# wrong constant name reset_all -# wrong constant name superclass_proxy_for -# wrong constant name verify_all -# wrong constant name -# wrong constant name -# wrong constant name stub_chain_on -# undefined singleton method `disable_expect1' for `RSpec::Mocks::Syntax' -# undefined singleton method `disable_should1' for `RSpec::Mocks::Syntax' -# undefined singleton method `enable_expect1' for `RSpec::Mocks::Syntax' -# undefined singleton method `enable_should1' for `RSpec::Mocks::Syntax' -# undefined singleton method `expect_enabled?1' for `RSpec::Mocks::Syntax' -# undefined singleton method `should_enabled?1' for `RSpec::Mocks::Syntax' -# undefined singleton method `warn_unless_should_configured1' for `RSpec::Mocks::Syntax' -# wrong constant name -# wrong constant name default_should_syntax_host -# wrong constant name disable_expect1 -# wrong constant name disable_expect -# wrong constant name disable_should1 -# wrong constant name disable_should -# wrong constant name enable_expect1 -# wrong constant name enable_expect -# wrong constant name enable_should1 -# wrong constant name enable_should -# wrong constant name expect_enabled?1 -# wrong constant name expect_enabled? -# wrong constant name should_enabled?1 -# wrong constant name should_enabled? -# wrong constant name warn_about_should! -# wrong constant name warn_unless_should_configured1 -# wrong constant name warn_unless_should_configured -# wrong constant name initialize -# wrong constant name -# undefined method `delegate_not_to1' for module `RSpec::Mocks::TargetDelegationClassMethods' -# wrong constant name delegate_not_to1 -# wrong constant name delegate_not_to -# wrong constant name delegate_to -# wrong constant name disallow_negation -# wrong constant name -# wrong constant name target -# wrong constant name -# undefined method `initialize1' for module `RSpec::Mocks::TestDouble' -# undefined method `initialize2' for module `RSpec::Mocks::TestDouble' -# undefined method `respond_to?1' for module `RSpec::Mocks::TestDouble' -# wrong constant name == -# wrong constant name __build_mock_proxy_unless_expired -# wrong constant name __disallow_further_usage! -# wrong constant name as_null_object -# wrong constant name freeze -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name inspect -# wrong constant name null_object? -# wrong constant name respond_to?1 -# wrong constant name respond_to? -# wrong constant name to_s -# wrong constant name -# undefined singleton method `format1' for `RSpec::Mocks::TestDoubleFormatter' -# wrong constant name -# wrong constant name format1 -# wrong constant name format -# uninitialized constant RSpec::Mocks::TestDoubleProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name -# wrong constant name -# undefined method `respond_to?1' for module `RSpec::Mocks::VerifyingDouble' -# wrong constant name -# wrong constant name __send__ -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name respond_to?1 -# wrong constant name respond_to? -# wrong constant name send -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name unimplemented? -# wrong constant name with_signature -# wrong constant name -# wrong constant name for -# wrong constant name initialize -# wrong constant name method_reference -# wrong constant name method_reference= -# wrong constant name -# wrong constant name add_expectation -# wrong constant name add_stub -# wrong constant name initialize -# wrong constant name proxy_method_invoked -# wrong constant name validate_arguments! -# wrong constant name -# uninitialized constant RSpec::Mocks::VerifyingPartialClassDoubleProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name -# undefined method `initialize1' for class `RSpec::Mocks::VerifyingPartialDoubleProxy' -# uninitialized constant RSpec::Mocks::VerifyingPartialDoubleProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name ensure_implemented -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name method_reference -# wrong constant name -# uninitialized constant RSpec::Mocks::VerifyingProxy::DEFAULT_MESSAGE_EXPECTATION_OPTS -# wrong constant name initialize -# wrong constant name method_reference -# wrong constant name validate_arguments! -# wrong constant name visibility_for -# wrong constant name -# undefined method `add_message_expectation1' for module `RSpec::Mocks::VerifyingProxyMethods' -# undefined method `add_stub1' for module `RSpec::Mocks::VerifyingProxyMethods' -# wrong constant name add_message_expectation1 -# wrong constant name add_message_expectation -# wrong constant name add_simple_stub -# wrong constant name add_stub1 -# wrong constant name add_stub -# wrong constant name ensure_implemented -# wrong constant name ensure_publicly_implemented -# wrong constant name -# wrong constant name -# undefined singleton method `allow_message1' for `RSpec::Mocks' -# undefined singleton method `expect_message1' for `RSpec::Mocks' -# wrong constant name -# wrong constant name allow_message1 -# wrong constant name allow_message -# wrong constant name configuration -# wrong constant name error_generator -# wrong constant name expect_message1 -# wrong constant name expect_message -# wrong constant name setup -# wrong constant name space -# wrong constant name teardown -# wrong constant name verify -# wrong constant name with_temporary_scope # undefined method `initialize1' for class `RSpec::Retry' # wrong constant name attempts # wrong constant name attempts= @@ -20349,255 +10910,6 @@ # wrong constant name verbose_retry? # wrong constant name # wrong constant name setup -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name === -# uninitialized constant RSpec::Support::BlockSignature::INFINITY -# wrong constant name -# wrong constant name <=> -# wrong constant name initialize -# wrong constant name segments -# wrong constant name string -# wrong constant name -# undefined method `initialize1' for class `RSpec::Support::Differ' -# wrong constant name color? -# wrong constant name diff -# wrong constant name diff_as_object -# wrong constant name diff_as_string -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name mkdir_p -# undefined method `initialize1' for class `RSpec::Support::EncodedString' -# wrong constant name << -# wrong constant name == -# wrong constant name empty? -# wrong constant name encoding -# wrong constant name eql? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name lines -# wrong constant name source_encoding -# wrong constant name split -# wrong constant name to_str -# wrong constant name -# wrong constant name pick_encoding -# wrong constant name -# wrong constant name values_match? -# wrong constant name -# wrong constant name has_kw_args_in? -# wrong constant name initialize -# wrong constant name invalid_kw_args_from -# wrong constant name missing_kw_args_from -# wrong constant name non_kw_args_arity_description -# wrong constant name valid_non_kw_args? -# wrong constant name -# wrong constant name -# undefined method `classify_arity1' for class `RSpec::Support::MethodSignature' -# undefined method `valid_non_kw_args?1' for class `RSpec::Support::MethodSignature' -# wrong constant name arbitrary_kw_args? -# wrong constant name classify_arity1 -# wrong constant name classify_arity -# wrong constant name classify_parameters -# wrong constant name could_contain_kw_args? -# wrong constant name description -# wrong constant name has_kw_args_in? -# wrong constant name initialize -# wrong constant name invalid_kw_args_from -# wrong constant name max_non_kw_args -# wrong constant name min_non_kw_args -# wrong constant name missing_kw_args_from -# wrong constant name non_kw_args_arity_description -# wrong constant name optional_kw_args -# wrong constant name required_kw_args -# wrong constant name unlimited_args? -# wrong constant name valid_non_kw_args?1 -# wrong constant name valid_non_kw_args? -# wrong constant name -# wrong constant name empty? -# wrong constant name expect_arbitrary_keywords -# wrong constant name expect_arbitrary_keywords= -# wrong constant name expect_unlimited_arguments -# wrong constant name expect_unlimited_arguments= -# wrong constant name keywords -# wrong constant name keywords= -# wrong constant name max_count -# wrong constant name max_count= -# wrong constant name min_count -# wrong constant name min_count= -# wrong constant name -# undefined method `initialize1' for class `RSpec::Support::MethodSignatureVerifier' -# wrong constant name error_message -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name kw_args -# wrong constant name max_non_kw_args -# wrong constant name min_non_kw_args -# wrong constant name non_kw_args -# wrong constant name valid? -# wrong constant name with_expectation -# wrong constant name -# wrong constant name -# wrong constant name new -# wrong constant name -# wrong constant name windows? -# wrong constant name windows_file_path? -# undefined method `initialize1' for class `RSpec::Support::ObjectFormatter' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name format -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name max_formatted_output_length -# wrong constant name max_formatted_output_length= -# wrong constant name prepare_array -# wrong constant name prepare_element -# wrong constant name prepare_for_inspection -# wrong constant name prepare_hash -# wrong constant name recursive_structure? -# wrong constant name sort_hash_keys -# wrong constant name with_entering_structure -# uninitialized constant RSpec::Support::ObjectFormatter::BaseInspector::Elem -# wrong constant name formatter -# wrong constant name formatter= -# wrong constant name object -# wrong constant name object= -# wrong constant name pretty_print -# wrong constant name -# wrong constant name [] -# wrong constant name can_inspect? -# wrong constant name members -# uninitialized constant RSpec::Support::ObjectFormatter::BigDecimalInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::DateTimeInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::DelegatorInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::DescribableMatcherInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::InspectableItem::Elem -# wrong constant name pretty_print -# wrong constant name text -# wrong constant name text= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# uninitialized constant RSpec::Support::ObjectFormatter::InspectableObjectInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::TimeInspector::Elem -# wrong constant name -# wrong constant name can_inspect? -# uninitialized constant RSpec::Support::ObjectFormatter::UninspectableObjectInspector::Elem -# wrong constant name klass -# wrong constant name native_object_id -# wrong constant name -# wrong constant name can_inspect? -# wrong constant name -# wrong constant name default_instance -# wrong constant name format -# wrong constant name prepare_for_inspection -# wrong constant name const_defined_on? -# wrong constant name constants_defined_on -# wrong constant name get_const_defined_on -# wrong constant name normalize_const_name -# wrong constant name recursive_const_defined? -# wrong constant name recursive_const_get -# wrong constant name -# wrong constant name synchronize -# wrong constant name -# wrong constant name -# wrong constant name jruby? -# wrong constant name jruby_9000? -# wrong constant name jruby_version -# wrong constant name mri? -# wrong constant name non_mri? -# wrong constant name rbx? -# wrong constant name truffleruby? -# wrong constant name -# wrong constant name caller_locations_supported? -# wrong constant name fork_supported? -# wrong constant name kw_args_supported? -# wrong constant name module_prepends_supported? -# wrong constant name module_refinement_supported? -# wrong constant name optional_and_splat_args_supported? -# wrong constant name required_kw_args_supported? -# wrong constant name ripper_supported? -# wrong constant name supports_exception_cause? -# wrong constant name supports_rebinding_module_methods? -# wrong constant name supports_taint? -# wrong constant name -# undefined method `deprecate1' for module `RSpec::Support::Warnings' -# undefined method `warn_deprecation1' for module `RSpec::Support::Warnings' -# undefined method `warn_with1' for module `RSpec::Support::Warnings' -# undefined method `warning1' for module `RSpec::Support::Warnings' -# wrong constant name deprecate1 -# wrong constant name deprecate -# wrong constant name warn_deprecation1 -# wrong constant name warn_deprecation -# wrong constant name warn_with1 -# wrong constant name warn_with -# wrong constant name warning1 -# wrong constant name warning -# wrong constant name -# wrong constant name -# wrong constant name class_exec -# undefined singleton method `notify_failure1' for `RSpec::Support' -# wrong constant name -# wrong constant name class_of -# wrong constant name define_optimized_require_for_rspec -# wrong constant name deregister_matcher_definition -# wrong constant name failure_notifier -# wrong constant name failure_notifier= -# wrong constant name is_a_matcher? -# wrong constant name matcher_definitions -# wrong constant name method_handle_for -# wrong constant name notify_failure1 -# wrong constant name notify_failure -# wrong constant name register_matcher_definition -# wrong constant name require_rspec_core -# wrong constant name require_rspec_expectations -# wrong constant name require_rspec_matchers -# wrong constant name require_rspec_mocks -# wrong constant name require_rspec_support -# wrong constant name rspec_description_for_object -# wrong constant name thread_local_data -# wrong constant name warning_notifier -# wrong constant name warning_notifier= -# wrong constant name with_failure_notifier -# wrong constant name # wrong constant name # wrong constant name # wrong constant name @@ -20633,130 +10945,8 @@ # wrong constant name wait_for1 # wrong constant name wait_for # wrong constant name with_wait -# wrong constant name -# wrong constant name clear_examples -# wrong constant name configuration -# wrong constant name configuration= -# wrong constant name configure -# wrong constant name const_missing -# wrong constant name context -# wrong constant name current_example -# wrong constant name current_example= -# wrong constant name describe -# wrong constant name example_group -# wrong constant name fcontext -# wrong constant name fdescribe -# wrong constant name reset -# wrong constant name world -# wrong constant name world= -# wrong constant name xcontext -# wrong constant name xdescribe # wrong constant name # wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name ground -# wrong constant name codes -# wrong constant name initialize -# wrong constant name num -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name color_names -# wrong constant name valid_names -# wrong constant name b -# wrong constant name g -# wrong constant name initialize -# wrong constant name r -# wrong constant name -# wrong constant name to_ansi_domain -# uninitialized constant Rainbow::Color::X11Named::NAMES -# wrong constant name initialize -# wrong constant name -# wrong constant name color_names -# wrong constant name valid_names -# wrong constant name -# wrong constant name build -# wrong constant name parse_hex_color -# uninitialized constant Rainbow::NullPresenter::BLANK_RE -# uninitialized constant Rainbow::NullPresenter::ENCODED_BLANKS -# wrong constant name background -# wrong constant name bg -# wrong constant name black -# wrong constant name blink -# wrong constant name blue -# wrong constant name bold -# wrong constant name bright -# wrong constant name color -# wrong constant name cyan -# wrong constant name dark -# wrong constant name faint -# wrong constant name fg -# wrong constant name foreground -# wrong constant name green -# wrong constant name hide -# wrong constant name inverse -# wrong constant name italic -# wrong constant name magenta -# wrong constant name method_missing -# wrong constant name red -# wrong constant name reset -# wrong constant name underline -# wrong constant name white -# wrong constant name yellow -# wrong constant name -# uninitialized constant Rainbow::Presenter::BLANK_RE -# uninitialized constant Rainbow::Presenter::ENCODED_BLANKS -# wrong constant name background -# wrong constant name bg -# wrong constant name black -# wrong constant name blink -# wrong constant name blue -# wrong constant name bold -# wrong constant name bright -# wrong constant name color -# wrong constant name cyan -# wrong constant name dark -# wrong constant name faint -# wrong constant name fg -# wrong constant name foreground -# wrong constant name green -# wrong constant name hide -# wrong constant name inverse -# wrong constant name italic -# wrong constant name magenta -# wrong constant name method_missing -# wrong constant name red -# wrong constant name reset -# wrong constant name underline -# wrong constant name white -# wrong constant name yellow -# wrong constant name -# wrong constant name -# wrong constant name uncolor -# wrong constant name wrap_with_sgr -# undefined method `initialize1' for class `Rainbow::Wrapper' -# wrong constant name enabled -# wrong constant name enabled= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name wrap -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name enabled -# wrong constant name enabled= -# wrong constant name global -# wrong constant name new -# wrong constant name uncolor # wrong constant name bytes # wrong constant name % # wrong constant name entries @@ -20771,891 +10961,6 @@ # wrong constant name fire_update! # wrong constant name ruby # wrong constant name completion_quote_character -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Expression::Alternation::Elem -# wrong constant name alternatives -# wrong constant name -# uninitialized constant Regexp::Expression::Alternative::Elem -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Expression::Assertion::Base::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Assertion::Lookahead::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Assertion::Lookbehind::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Assertion::NegativeLookahead::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Assertion::NegativeLookbehind::Elem -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name referenced_expression -# wrong constant name referenced_expression= -# wrong constant name -# wrong constant name name -# wrong constant name reference -# wrong constant name -# wrong constant name -# wrong constant name recursion_level -# wrong constant name -# wrong constant name number -# wrong constant name reference -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name recursion_level -# wrong constant name -# wrong constant name effective_number -# wrong constant name effective_number= -# wrong constant name -# wrong constant name -# undefined method `=~1' for class `Regexp::Expression::Base' -# undefined method `initialize1' for class `Regexp::Expression::Base' -# undefined method `is?1' for class `Regexp::Expression::Base' -# undefined method `match1' for class `Regexp::Expression::Base' -# undefined method `one_of?1' for class `Regexp::Expression::Base' -# undefined method `quantify1' for class `Regexp::Expression::Base' -# undefined method `quantify2' for class `Regexp::Expression::Base' -# undefined method `quantify3' for class `Regexp::Expression::Base' -# undefined method `strfre1' for class `Regexp::Expression::Base' -# undefined method `strfre2' for class `Regexp::Expression::Base' -# undefined method `strfre3' for class `Regexp::Expression::Base' -# undefined method `strfregexp1' for class `Regexp::Expression::Base' -# undefined method `strfregexp2' for class `Regexp::Expression::Base' -# undefined method `strfregexp3' for class `Regexp::Expression::Base' -# undefined method `to_re1' for class `Regexp::Expression::Base' -# undefined method `to_s1' for class `Regexp::Expression::Base' -# wrong constant name =~1 -# wrong constant name =~ -# wrong constant name a? -# wrong constant name ascii_classes? -# wrong constant name attributes -# wrong constant name case_insensitive? -# wrong constant name coded_offset -# wrong constant name conditional_level -# wrong constant name conditional_level= -# wrong constant name d? -# wrong constant name default_classes? -# wrong constant name extended? -# wrong constant name free_spacing? -# wrong constant name full_length -# wrong constant name greedy? -# wrong constant name i? -# wrong constant name ignore_case? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name is?1 -# wrong constant name is? -# wrong constant name lazy? -# wrong constant name level -# wrong constant name level= -# wrong constant name m? -# wrong constant name match1 -# wrong constant name match -# wrong constant name match? -# wrong constant name matches? -# wrong constant name multiline? -# wrong constant name nesting_level -# wrong constant name nesting_level= -# wrong constant name offset -# wrong constant name one_of?1 -# wrong constant name one_of? -# wrong constant name options -# wrong constant name options= -# wrong constant name possessive? -# wrong constant name quantified? -# wrong constant name quantifier -# wrong constant name quantifier= -# wrong constant name quantifier_affix -# wrong constant name quantify1 -# wrong constant name quantify2 -# wrong constant name quantify3 -# wrong constant name quantify -# wrong constant name quantity -# wrong constant name reluctant? -# wrong constant name repetitions -# wrong constant name set_level -# wrong constant name set_level= -# wrong constant name starts_at -# wrong constant name strfre1 -# wrong constant name strfre2 -# wrong constant name strfre3 -# wrong constant name strfre -# wrong constant name strfregexp1 -# wrong constant name strfregexp2 -# wrong constant name strfregexp3 -# wrong constant name strfregexp -# wrong constant name terminal? -# wrong constant name text -# wrong constant name text= -# wrong constant name to_h -# wrong constant name to_re1 -# wrong constant name to_re -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name token -# wrong constant name token= -# wrong constant name ts -# wrong constant name ts= -# wrong constant name type -# wrong constant name type= -# wrong constant name type? -# wrong constant name u? -# wrong constant name unicode_classes? -# wrong constant name unquantified_clone -# wrong constant name x? -# wrong constant name -# uninitialized constant Regexp::Expression::CharacterSet::Elem -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name close -# wrong constant name closed -# wrong constant name closed= -# wrong constant name closed? -# wrong constant name negate -# wrong constant name negated? -# wrong constant name negative -# wrong constant name negative= -# wrong constant name negative? -# uninitialized constant Regexp::Expression::CharacterSet::IntersectedSequence::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::CharacterSet::Intersection::Elem -# wrong constant name -# undefined method `to_s1' for class `Regexp::Expression::CharacterSet::Range' -# uninitialized constant Regexp::Expression::CharacterSet::Range::Elem -# wrong constant name complete? -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Expression::Conditional::Branch::Elem -# wrong constant name -# wrong constant name match_length -# wrong constant name reference -# wrong constant name referenced_expression -# wrong constant name referenced_expression= -# wrong constant name -# undefined method `add_sequence1' for class `Regexp::Expression::Conditional::Expression' -# undefined method `branch1' for class `Regexp::Expression::Conditional::Expression' -# uninitialized constant Regexp::Expression::Conditional::Expression::Elem -# wrong constant name add_sequence1 -# wrong constant name add_sequence -# wrong constant name branch1 -# wrong constant name branch -# wrong constant name branches -# wrong constant name condition -# wrong constant name condition= -# wrong constant name reference -# wrong constant name referenced_expression -# wrong constant name referenced_expression= -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name char -# wrong constant name codepoint -# wrong constant name match_length -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name chars -# wrong constant name codepoints -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Absence::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Atomic::Elem -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Base::Elem -# wrong constant name capturing? -# wrong constant name comment? -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Capture::Elem -# wrong constant name identifier -# wrong constant name number -# wrong constant name number= -# wrong constant name number_at_level -# wrong constant name number_at_level= -# wrong constant name -# undefined method `to_s1' for class `Regexp::Expression::Group::Comment' -# uninitialized constant Regexp::Expression::Group::Comment::Elem -# wrong constant name to_s1 -# wrong constant name to_s -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Named::Elem -# wrong constant name name -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Options::Elem -# wrong constant name option_changes -# wrong constant name option_changes= -# wrong constant name -# uninitialized constant Regexp::Expression::Group::Passive::Elem -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name -# wrong constant name match_length -# wrong constant name name -# wrong constant name negative? -# wrong constant name -# wrong constant name greedy? -# wrong constant name initialize -# wrong constant name lazy? -# wrong constant name max -# wrong constant name min -# wrong constant name mode -# wrong constant name possessive? -# wrong constant name reluctant? -# wrong constant name text -# wrong constant name to_h -# wrong constant name to_str -# wrong constant name token -# wrong constant name -# uninitialized constant Regexp::Expression::Root::Elem -# wrong constant name initialize -# undefined singleton method `build1' for `Regexp::Expression::Root' -# wrong constant name -# wrong constant name build1 -# wrong constant name build -# wrong constant name build_token -# uninitialized constant Regexp::Expression::Sequence::Elem -# wrong constant name initialize -# undefined singleton method `add_to1' for `Regexp::Expression::Sequence' -# undefined singleton method `add_to2' for `Regexp::Expression::Sequence' -# wrong constant name -# wrong constant name add_to1 -# wrong constant name add_to2 -# wrong constant name add_to -# wrong constant name at_levels -# undefined method `add_sequence1' for class `Regexp::Expression::SequenceOperation' -# uninitialized constant Regexp::Expression::SequenceOperation::Elem -# wrong constant name add_sequence1 -# wrong constant name add_sequence -# wrong constant name operands -# wrong constant name operator -# wrong constant name sequences -# wrong constant name -# undefined method `each_expression1' for class `Regexp::Expression::Subexpression' -# undefined method `flat_map1' for class `Regexp::Expression::Subexpression' -# undefined method `strfre_tree1' for class `Regexp::Expression::Subexpression' -# undefined method `strfre_tree2' for class `Regexp::Expression::Subexpression' -# undefined method `strfre_tree3' for class `Regexp::Expression::Subexpression' -# undefined method `strfregexp_tree1' for class `Regexp::Expression::Subexpression' -# undefined method `strfregexp_tree2' for class `Regexp::Expression::Subexpression' -# undefined method `strfregexp_tree3' for class `Regexp::Expression::Subexpression' -# undefined method `traverse1' for class `Regexp::Expression::Subexpression' -# undefined method `walk1' for class `Regexp::Expression::Subexpression' -# wrong constant name << -# uninitialized constant Regexp::Expression::Subexpression::Elem -# wrong constant name [] -# wrong constant name at -# wrong constant name dig -# wrong constant name each -# wrong constant name each_expression1 -# wrong constant name each_expression -# wrong constant name empty? -# wrong constant name expressions -# wrong constant name expressions= -# wrong constant name fetch -# wrong constant name flat_map1 -# wrong constant name flat_map -# wrong constant name index -# wrong constant name inner_match_length -# wrong constant name join -# wrong constant name last -# wrong constant name length -# wrong constant name match_length -# wrong constant name strfre_tree1 -# wrong constant name strfre_tree2 -# wrong constant name strfre_tree3 -# wrong constant name strfre_tree -# wrong constant name strfregexp_tree1 -# wrong constant name strfregexp_tree2 -# wrong constant name strfregexp_tree3 -# wrong constant name strfregexp_tree -# wrong constant name te -# wrong constant name to_h -# wrong constant name traverse1 -# wrong constant name traverse -# wrong constant name values_at -# wrong constant name walk1 -# wrong constant name walk -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name match_length -# wrong constant name name -# wrong constant name negative? -# wrong constant name shortcut -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name merge -# wrong constant name -# wrong constant name -# wrong constant name parsed -# undefined method `lex1' for class `Regexp::Lexer' -# wrong constant name lex1 -# wrong constant name lex -# undefined singleton method `lex1' for `Regexp::Lexer' -# undefined singleton method `scan1' for `Regexp::Lexer' -# wrong constant name -# wrong constant name lex1 -# wrong constant name lex -# wrong constant name scan1 -# wrong constant name scan -# undefined method `each1' for class `Regexp::MatchLength' -# undefined method `initialize1' for class `Regexp::MatchLength' -# uninitialized constant Regexp::MatchLength::Elem -# wrong constant name each1 -# wrong constant name each -# wrong constant name endless_each -# wrong constant name fixed? -# wrong constant name include? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name max -# wrong constant name min -# wrong constant name to_re -# wrong constant name -# wrong constant name of -# undefined method `parse1' for class `Regexp::Parser' -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Parser::VERSION_CONST_REGEXP -# uninitialized constant Regexp::Parser::VERSION_FORMAT -# uninitialized constant Regexp::Parser::VERSION_REGEXP -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# undefined singleton method `parse1' for `Regexp::Parser' -# wrong constant name -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name emit -# wrong constant name scan -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# undefined method `initialize1' for class `Regexp::Scanner::InvalidSequenceError' -# undefined method `initialize2' for class `Regexp::Scanner::InvalidSequenceError' -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name -# undefined method `initialize1' for class `Regexp::Scanner::PrematureEndError' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name long_prop_map -# wrong constant name scan -# wrong constant name short_prop_map -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Regexp::Syntax::Any::All -# uninitialized constant Regexp::Syntax::Any::Map -# uninitialized constant Regexp::Syntax::Any::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::Base::All -# uninitialized constant Regexp::Syntax::Base::Map -# uninitialized constant Regexp::Syntax::Base::Types -# wrong constant name check! -# wrong constant name check? -# wrong constant name excludes -# wrong constant name features -# wrong constant name implementations -# wrong constant name implements -# wrong constant name implements! -# wrong constant name implements? -# wrong constant name normalize -# wrong constant name normalize_backref -# wrong constant name normalize_group -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name -# uninitialized constant Regexp::Syntax::V1_8_6::All -# uninitialized constant Regexp::Syntax::V1_8_6::Map -# uninitialized constant Regexp::Syntax::V1_8_6::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V1_9::All -# uninitialized constant Regexp::Syntax::V1_9::Map -# uninitialized constant Regexp::Syntax::V1_9::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V1_9_1::All -# uninitialized constant Regexp::Syntax::V1_9_1::Map -# uninitialized constant Regexp::Syntax::V1_9_1::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V1_9_3::All -# uninitialized constant Regexp::Syntax::V1_9_3::Map -# uninitialized constant Regexp::Syntax::V1_9_3::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_0_0::All -# uninitialized constant Regexp::Syntax::V2_0_0::Map -# uninitialized constant Regexp::Syntax::V2_0_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_1::All -# uninitialized constant Regexp::Syntax::V2_1::Map -# uninitialized constant Regexp::Syntax::V2_1::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_2::All -# uninitialized constant Regexp::Syntax::V2_2::Map -# uninitialized constant Regexp::Syntax::V2_2::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_2_0::All -# uninitialized constant Regexp::Syntax::V2_2_0::Map -# uninitialized constant Regexp::Syntax::V2_2_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_3::All -# uninitialized constant Regexp::Syntax::V2_3::Map -# uninitialized constant Regexp::Syntax::V2_3::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_3_0::All -# uninitialized constant Regexp::Syntax::V2_3_0::Map -# uninitialized constant Regexp::Syntax::V2_3_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_4::All -# uninitialized constant Regexp::Syntax::V2_4::Map -# uninitialized constant Regexp::Syntax::V2_4::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_4_0::All -# uninitialized constant Regexp::Syntax::V2_4_0::Map -# uninitialized constant Regexp::Syntax::V2_4_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_4_1::All -# uninitialized constant Regexp::Syntax::V2_4_1::Map -# uninitialized constant Regexp::Syntax::V2_4_1::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_5::All -# uninitialized constant Regexp::Syntax::V2_5::Map -# uninitialized constant Regexp::Syntax::V2_5::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_5_0::All -# uninitialized constant Regexp::Syntax::V2_5_0::Map -# uninitialized constant Regexp::Syntax::V2_5_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_6_0::All -# uninitialized constant Regexp::Syntax::V2_6_0::Map -# uninitialized constant Regexp::Syntax::V2_6_0::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_6_2::All -# uninitialized constant Regexp::Syntax::V2_6_2::Map -# uninitialized constant Regexp::Syntax::V2_6_2::Types -# wrong constant name -# uninitialized constant Regexp::Syntax::V2_6_3::All -# uninitialized constant Regexp::Syntax::V2_6_3::Map -# uninitialized constant Regexp::Syntax::V2_6_3::Types -# wrong constant name -# wrong constant name -# wrong constant name comparable_version -# wrong constant name fallback_version_class -# wrong constant name inherit_from_version -# wrong constant name new -# wrong constant name specified_versions -# wrong constant name supported? -# wrong constant name version_class -# wrong constant name version_const_name -# wrong constant name warn_if_future_version -# uninitialized constant Regexp::Token::Elem -# wrong constant name conditional_level -# wrong constant name conditional_level= -# wrong constant name level -# wrong constant name level= -# wrong constant name next -# wrong constant name next= -# wrong constant name offset -# wrong constant name previous -# wrong constant name previous= -# wrong constant name set_level -# wrong constant name set_level= -# wrong constant name te -# wrong constant name te= -# wrong constant name text -# wrong constant name text= -# wrong constant name token -# wrong constant name token= -# wrong constant name ts -# wrong constant name ts= -# wrong constant name type -# wrong constant name type= -# wrong constant name -# wrong constant name [] -# wrong constant name members # undefined singleton method `cask1' for `Requirement' # undefined singleton method `download1' for `Requirement' # undefined singleton method `fatal1' for `Requirement' @@ -21862,1658 +11167,34 @@ # wrong constant name release? # wrong constant name revision # wrong constant name version -# uninitialized constant RuboCop::AST::AliasNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::AliasNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::AliasNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::AliasNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::CONDITIONALS -# uninitialized constant RuboCop::AST::AliasNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::AliasNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::KEYWORDS -# uninitialized constant RuboCop::AST::AliasNode::LITERALS -# uninitialized constant RuboCop::AST::AliasNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::AliasNode::REFERENCES -# uninitialized constant RuboCop::AST::AliasNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::AliasNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::AliasNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::AliasNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::AliasNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::AliasNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::AliasNode::VARIABLES -# wrong constant name new_identifier -# wrong constant name old_identifier -# wrong constant name -# uninitialized constant RuboCop::AST::AndNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::AndNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::AndNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::AndNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::AndNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::AndNode::CONDITIONALS -# uninitialized constant RuboCop::AST::AndNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::AndNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::AndNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::AndNode::KEYWORDS -# uninitialized constant RuboCop::AST::AndNode::LITERALS -# uninitialized constant RuboCop::AST::AndNode::LOGICAL_AND -# uninitialized constant RuboCop::AST::AndNode::LOGICAL_OR -# uninitialized constant RuboCop::AST::AndNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::AndNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::AndNode::REFERENCES -# uninitialized constant RuboCop::AST::AndNode::SEMANTIC_AND -# uninitialized constant RuboCop::AST::AndNode::SEMANTIC_OR -# uninitialized constant RuboCop::AST::AndNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::AndNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::AndNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::AndNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::AndNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::AndNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::AndNode::VARIABLES -# wrong constant name alternate_operator -# wrong constant name inverse_operator -# wrong constant name -# uninitialized constant RuboCop::AST::ArgsNode::ARRAY_METHODS -# uninitialized constant RuboCop::AST::ArgsNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArgsNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ArgsNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ArgsNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ArgsNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArgsNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::KEYWORDS -# uninitialized constant RuboCop::AST::ArgsNode::LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ArgsNode::REFERENCES -# uninitialized constant RuboCop::AST::ArgsNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArgsNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ArgsNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ArgsNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ArgsNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ArgsNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ArgsNode::VARIABLES -# wrong constant name empty_and_without_delimiters? -# wrong constant name -# undefined method `percent_literal?1' for class `RuboCop::AST::ArrayNode' -# uninitialized constant RuboCop::AST::ArrayNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArrayNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ArrayNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ArrayNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ArrayNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArrayNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::KEYWORDS -# uninitialized constant RuboCop::AST::ArrayNode::LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ArrayNode::REFERENCES -# uninitialized constant RuboCop::AST::ArrayNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ArrayNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ArrayNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ArrayNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ArrayNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ArrayNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ArrayNode::VARIABLES -# wrong constant name bracketed? -# wrong constant name each_value -# wrong constant name percent_literal?1 -# wrong constant name percent_literal? -# wrong constant name square_brackets? -# wrong constant name values -# wrong constant name -# wrong constant name value -# wrong constant name -# wrong constant name conditions -# wrong constant name lhs -# wrong constant name rhs -# wrong constant name -# uninitialized constant RuboCop::AST::BlockNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::BlockNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::BlockNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::BlockNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::CONDITIONALS -# uninitialized constant RuboCop::AST::BlockNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::BlockNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::BlockNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::KEYWORDS -# uninitialized constant RuboCop::AST::BlockNode::LITERALS -# uninitialized constant RuboCop::AST::BlockNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::BlockNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::BlockNode::REFERENCES -# uninitialized constant RuboCop::AST::BlockNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::BlockNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::BlockNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::BlockNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::BlockNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::BlockNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::BlockNode::VARIABLES -# wrong constant name arguments -# wrong constant name arguments? -# wrong constant name body -# wrong constant name braces? -# wrong constant name closing_delimiter -# wrong constant name delimiters -# wrong constant name keywords? -# wrong constant name lambda? -# wrong constant name method_name -# wrong constant name opening_delimiter -# wrong constant name send_node -# wrong constant name void_context? -# wrong constant name -# uninitialized constant RuboCop::AST::BreakNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::BreakNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::BreakNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::BreakNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::BreakNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::CONDITIONALS -# uninitialized constant RuboCop::AST::BreakNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::BreakNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::BreakNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::KEYWORDS -# uninitialized constant RuboCop::AST::BreakNode::LITERALS -# uninitialized constant RuboCop::AST::BreakNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::BreakNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::BreakNode::REFERENCES -# uninitialized constant RuboCop::AST::BreakNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::BreakNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::BreakNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::BreakNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::BreakNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::BreakNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::BreakNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::BreakNode::VARIABLES -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::AST::CaseMatchNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseMatchNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::CaseMatchNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::CaseMatchNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::CONDITIONALS -# uninitialized constant RuboCop::AST::CaseMatchNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseMatchNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::KEYWORDS -# uninitialized constant RuboCop::AST::CaseMatchNode::LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::CaseMatchNode::REFERENCES -# uninitialized constant RuboCop::AST::CaseMatchNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseMatchNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::CaseMatchNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::CaseMatchNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::CaseMatchNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::CaseMatchNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::CaseMatchNode::VARIABLES -# wrong constant name each_in_pattern -# wrong constant name else? -# wrong constant name else_branch -# wrong constant name in_pattern_branches -# wrong constant name keyword -# wrong constant name -# uninitialized constant RuboCop::AST::CaseNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::CaseNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::CaseNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::CONDITIONALS -# uninitialized constant RuboCop::AST::CaseNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::KEYWORDS -# uninitialized constant RuboCop::AST::CaseNode::LITERALS -# uninitialized constant RuboCop::AST::CaseNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::CaseNode::REFERENCES -# uninitialized constant RuboCop::AST::CaseNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::CaseNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::CaseNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::CaseNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::CaseNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::CaseNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::CaseNode::VARIABLES -# wrong constant name each_when -# wrong constant name else? -# wrong constant name else_branch -# wrong constant name keyword -# wrong constant name when_branches -# wrong constant name -# uninitialized constant RuboCop::AST::ClassNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ClassNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ClassNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ClassNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ClassNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ClassNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::KEYWORDS -# uninitialized constant RuboCop::AST::ClassNode::LITERALS -# uninitialized constant RuboCop::AST::ClassNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ClassNode::REFERENCES -# uninitialized constant RuboCop::AST::ClassNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ClassNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ClassNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ClassNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ClassNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ClassNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ClassNode::VARIABLES -# wrong constant name body -# wrong constant name identifier -# wrong constant name parent_class -# wrong constant name -# wrong constant name & -# wrong constant name * -# wrong constant name + -# wrong constant name - -# wrong constant name << -# wrong constant name [] -# wrong constant name []= -# wrong constant name all? -# wrong constant name any? -# wrong constant name append -# wrong constant name assoc -# wrong constant name at -# wrong constant name bsearch -# wrong constant name bsearch_index -# wrong constant name chain -# wrong constant name chunk -# wrong constant name chunk_while -# wrong constant name clear -# wrong constant name collect -# wrong constant name collect! -# wrong constant name collect_concat -# wrong constant name combination -# wrong constant name compact -# wrong constant name compact! -# wrong constant name concat -# wrong constant name count -# wrong constant name cycle -# wrong constant name delete -# wrong constant name delete_at -# wrong constant name delete_if -# wrong constant name detect -# wrong constant name difference -# wrong constant name dig -# wrong constant name drop -# wrong constant name drop_while -# wrong constant name each -# wrong constant name each_cons -# wrong constant name each_entry -# wrong constant name each_index -# wrong constant name each_slice -# wrong constant name each_with_index -# wrong constant name each_with_object -# wrong constant name empty? -# wrong constant name entries # wrong constant name extract_options! -# wrong constant name fetch -# wrong constant name fill -# wrong constant name filter -# wrong constant name filter! -# wrong constant name find -# wrong constant name find_all -# wrong constant name find_index -# wrong constant name first -# wrong constant name flat_map -# wrong constant name flatten -# wrong constant name flatten! -# wrong constant name grep -# wrong constant name grep_v -# wrong constant name group_by -# wrong constant name include? -# wrong constant name index -# wrong constant name inject -# wrong constant name insert -# wrong constant name join -# wrong constant name keep_if -# wrong constant name last -# wrong constant name lazy -# wrong constant name length -# wrong constant name map -# wrong constant name map! -# wrong constant name max -# wrong constant name max_by -# wrong constant name member? -# wrong constant name min -# wrong constant name min_by -# wrong constant name minmax -# wrong constant name minmax_by -# wrong constant name none? -# wrong constant name one? -# wrong constant name pack -# wrong constant name partition -# wrong constant name permutation -# wrong constant name pop -# wrong constant name prepend -# wrong constant name product -# wrong constant name push -# wrong constant name rassoc -# wrong constant name reduce -# wrong constant name reject -# wrong constant name reject! -# wrong constant name repeated_combination -# wrong constant name repeated_permutation -# wrong constant name replace -# wrong constant name reverse -# wrong constant name reverse! -# wrong constant name reverse_each -# wrong constant name rindex -# wrong constant name rotate -# wrong constant name rotate! -# wrong constant name sample # wrong constant name save_plist -# wrong constant name select -# wrong constant name select! -# wrong constant name shelljoin -# wrong constant name shift -# wrong constant name shuffle -# wrong constant name shuffle! -# wrong constant name size -# wrong constant name slice -# wrong constant name slice! -# wrong constant name slice_after -# wrong constant name slice_before -# wrong constant name slice_when -# wrong constant name sort -# wrong constant name sort! -# wrong constant name sort_by -# wrong constant name sort_by! -# wrong constant name sum -# wrong constant name take -# wrong constant name take_while -# wrong constant name to_ary # wrong constant name to_default_s # wrong constant name to_formatted_s -# wrong constant name to_h # wrong constant name to_plist # wrong constant name to_sentence -# wrong constant name to_set # wrong constant name to_xml -# wrong constant name transpose -# wrong constant name union -# wrong constant name uniq -# wrong constant name uniq! -# wrong constant name unshift -# wrong constant name values_at -# wrong constant name zip -# wrong constant name | -# wrong constant name -# wrong constant name body -# wrong constant name condition -# wrong constant name multiline_condition? -# wrong constant name single_line_condition? -# wrong constant name -# uninitialized constant RuboCop::AST::DefNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::DefNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::DefNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::DefNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::DefNode::CONDITIONALS -# uninitialized constant RuboCop::AST::DefNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::DefNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::DefNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::DefNode::KEYWORDS -# uninitialized constant RuboCop::AST::DefNode::LITERALS -# uninitialized constant RuboCop::AST::DefNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::DefNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::DefNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::DefNode::REFERENCES -# uninitialized constant RuboCop::AST::DefNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::DefNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::DefNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::DefNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::DefNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::DefNode::VARIABLES -# wrong constant name argument_forwarding? -# wrong constant name arguments -# wrong constant name body -# wrong constant name method_name -# wrong constant name receiver -# wrong constant name void_context? -# wrong constant name -# uninitialized constant RuboCop::AST::DefinedNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::DefinedNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefinedNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::DefinedNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::DefinedNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::CONDITIONALS -# uninitialized constant RuboCop::AST::DefinedNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::DefinedNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefinedNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::KEYWORDS -# uninitialized constant RuboCop::AST::DefinedNode::LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::DefinedNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::DefinedNode::REFERENCES -# uninitialized constant RuboCop::AST::DefinedNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::DefinedNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::DefinedNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::DefinedNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::DefinedNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::DefinedNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::DefinedNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::DefinedNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::EnsureNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::EnsureNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::EnsureNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::EnsureNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::CONDITIONALS -# uninitialized constant RuboCop::AST::EnsureNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::EnsureNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::KEYWORDS -# uninitialized constant RuboCop::AST::EnsureNode::LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::EnsureNode::REFERENCES -# uninitialized constant RuboCop::AST::EnsureNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::EnsureNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::EnsureNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::EnsureNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::EnsureNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::EnsureNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::EnsureNode::VARIABLES -# wrong constant name body -# wrong constant name -# uninitialized constant RuboCop::AST::FloatNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::FloatNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::FloatNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::FloatNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::CONDITIONALS -# uninitialized constant RuboCop::AST::FloatNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::FloatNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::KEYWORDS -# uninitialized constant RuboCop::AST::FloatNode::LITERALS -# uninitialized constant RuboCop::AST::FloatNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::FloatNode::REFERENCES -# uninitialized constant RuboCop::AST::FloatNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::FloatNode::SIGN_REGEX -# uninitialized constant RuboCop::AST::FloatNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::FloatNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::FloatNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::FloatNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::FloatNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::FloatNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::ForNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ForNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ForNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ForNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ForNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ForNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ForNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ForNode::KEYWORDS -# uninitialized constant RuboCop::AST::ForNode::LITERALS -# uninitialized constant RuboCop::AST::ForNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ForNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ForNode::REFERENCES -# uninitialized constant RuboCop::AST::ForNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ForNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ForNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ForNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ForNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ForNode::VARIABLES -# wrong constant name body -# wrong constant name collection -# wrong constant name do? -# wrong constant name keyword -# wrong constant name variable -# wrong constant name void_context? -# wrong constant name -# uninitialized constant RuboCop::AST::ForwardArgsNode::ARRAY_METHODS -# uninitialized constant RuboCop::AST::ForwardArgsNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForwardArgsNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ForwardArgsNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForwardArgsNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::KEYWORDS -# uninitialized constant RuboCop::AST::ForwardArgsNode::LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ForwardArgsNode::REFERENCES -# uninitialized constant RuboCop::AST::ForwardArgsNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ForwardArgsNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ForwardArgsNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ForwardArgsNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ForwardArgsNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ForwardArgsNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ForwardArgsNode::VARIABLES -# wrong constant name -# undefined method `key_delta1' for module `RuboCop::AST::HashElementNode' -# wrong constant name delimiter_delta -# wrong constant name key -# wrong constant name key_delta1 -# wrong constant name key_delta -# wrong constant name same_line? -# wrong constant name value -# wrong constant name value_delta -# wrong constant name -# uninitialized constant RuboCop::AST::HashNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::HashNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::HashNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::HashNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::HashNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::HashNode::CONDITIONALS -# uninitialized constant RuboCop::AST::HashNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::HashNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::HashNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::HashNode::KEYWORDS -# uninitialized constant RuboCop::AST::HashNode::LITERALS -# uninitialized constant RuboCop::AST::HashNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::HashNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::HashNode::REFERENCES -# uninitialized constant RuboCop::AST::HashNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::HashNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::HashNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::HashNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::HashNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::HashNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::HashNode::VARIABLES -# wrong constant name braces? -# wrong constant name each_key -# wrong constant name each_pair -# wrong constant name each_value -# wrong constant name empty? -# wrong constant name keys -# wrong constant name mixed_delimiters? -# wrong constant name pairs -# wrong constant name pairs_on_same_line? -# wrong constant name values -# wrong constant name -# uninitialized constant RuboCop::AST::IfNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::IfNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::IfNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::IfNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::IfNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::IfNode::CONDITIONALS -# uninitialized constant RuboCop::AST::IfNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::IfNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::IfNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::IfNode::KEYWORDS -# uninitialized constant RuboCop::AST::IfNode::LITERALS -# uninitialized constant RuboCop::AST::IfNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::IfNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::IfNode::REFERENCES -# uninitialized constant RuboCop::AST::IfNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::IfNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::IfNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::IfNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::IfNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::IfNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::IfNode::VARIABLES -# wrong constant name branches -# wrong constant name each_branch -# wrong constant name else? -# wrong constant name else_branch -# wrong constant name elsif? -# wrong constant name elsif_conditional? -# wrong constant name if? -# wrong constant name if_branch -# wrong constant name inverse_keyword -# wrong constant name keyword -# wrong constant name nested_conditional? -# wrong constant name ternary? -# wrong constant name unless? -# wrong constant name -# uninitialized constant RuboCop::AST::IntNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::IntNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::IntNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::IntNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::IntNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::IntNode::CONDITIONALS -# uninitialized constant RuboCop::AST::IntNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::IntNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::IntNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::IntNode::KEYWORDS -# uninitialized constant RuboCop::AST::IntNode::LITERALS -# uninitialized constant RuboCop::AST::IntNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::IntNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::IntNode::REFERENCES -# uninitialized constant RuboCop::AST::IntNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::IntNode::SIGN_REGEX -# uninitialized constant RuboCop::AST::IntNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::IntNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::IntNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::IntNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::IntNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::IntNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::KeywordSplatNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::KeywordSplatNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::KeywordSplatNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::CONDITIONALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::KeywordSplatNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::KEYWORDS -# uninitialized constant RuboCop::AST::KeywordSplatNode::LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::KeywordSplatNode::REFERENCES -# uninitialized constant RuboCop::AST::KeywordSplatNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::KeywordSplatNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::KeywordSplatNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::KeywordSplatNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::KeywordSplatNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::KeywordSplatNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::KeywordSplatNode::VARIABLES -# wrong constant name colon? -# wrong constant name hash_rocket? -# wrong constant name operator -# wrong constant name -# undefined method `adjacent_def_modifier?1' for module `RuboCop::AST::MethodDispatchNode' -# undefined method `bare_access_modifier_declaration?1' for module `RuboCop::AST::MethodDispatchNode' -# undefined method `macro_scope?1' for module `RuboCop::AST::MethodDispatchNode' -# undefined method `non_bare_access_modifier_declaration?1' for module `RuboCop::AST::MethodDispatchNode' -# uninitialized constant RuboCop::AST::MethodDispatchNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::MethodDispatchNode::OPERATOR_METHODS -# wrong constant name access_modifier? -# wrong constant name adjacent_def_modifier?1 -# wrong constant name adjacent_def_modifier? -# wrong constant name arguments -# wrong constant name arithmetic_operation? -# wrong constant name assignment? -# wrong constant name bare_access_modifier? -# wrong constant name bare_access_modifier_declaration?1 -# wrong constant name bare_access_modifier_declaration? -# wrong constant name binary_operation? -# wrong constant name block_literal? -# wrong constant name block_node -# wrong constant name command? -# wrong constant name const_receiver? -# wrong constant name def_modifier? -# wrong constant name dot? -# wrong constant name double_colon? -# wrong constant name implicit_call? -# wrong constant name lambda? -# wrong constant name lambda_literal? -# wrong constant name macro? -# wrong constant name macro_scope?1 -# wrong constant name macro_scope? -# wrong constant name method_name -# wrong constant name non_bare_access_modifier? -# wrong constant name non_bare_access_modifier_declaration?1 -# wrong constant name non_bare_access_modifier_declaration? -# wrong constant name receiver -# wrong constant name safe_navigation? -# wrong constant name self_receiver? -# wrong constant name setter_method? -# wrong constant name special_modifier? -# wrong constant name unary_operation? -# wrong constant name -# wrong constant name assignment_method? -# wrong constant name bang_method? -# wrong constant name camel_case_method? -# wrong constant name comparison_method? -# wrong constant name const_receiver? -# wrong constant name enumerator_method? -# wrong constant name method? -# wrong constant name negation_method? -# wrong constant name operator_method? -# wrong constant name predicate_method? -# wrong constant name prefix_bang? -# wrong constant name prefix_not? -# wrong constant name self_receiver? -# wrong constant name -# wrong constant name modifier_form? -# wrong constant name -# uninitialized constant RuboCop::AST::ModuleNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ModuleNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ModuleNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ModuleNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ModuleNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ModuleNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::KEYWORDS -# uninitialized constant RuboCop::AST::ModuleNode::LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ModuleNode::REFERENCES -# uninitialized constant RuboCop::AST::ModuleNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ModuleNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ModuleNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ModuleNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ModuleNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ModuleNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ModuleNode::VARIABLES -# wrong constant name body -# wrong constant name identifier -# wrong constant name -# undefined method `assignment_or_similar?1' for class `RuboCop::AST::Node' # undefined method `block_args1' for class `RuboCop::AST::Node' # undefined method `block_body1' for class `RuboCop::AST::Node' # undefined method `cask_block?1' for class `RuboCop::AST::Node' -# undefined method `class_constructor?1' for class `RuboCop::AST::Node' # undefined method `key_node1' for class `RuboCop::AST::Node' -# undefined method `lambda?1' for class `RuboCop::AST::Node' -# undefined method `lambda_or_proc?1' for class `RuboCop::AST::Node' -# undefined method `match_guard_clause?1' for class `RuboCop::AST::Node' # undefined method `method_node1' for class `RuboCop::AST::Node' -# undefined method `new_class_or_module_block?1' for class `RuboCop::AST::Node' -# undefined method `proc?1' for class `RuboCop::AST::Node' -# undefined method `receiver1' for class `RuboCop::AST::Node' -# undefined method `str_content1' for class `RuboCop::AST::Node' # undefined method `val_node1' for class `RuboCop::AST::Node' # uninitialized constant RuboCop::AST::Node::STANZA_GROUPS # uninitialized constant RuboCop::AST::Node::STANZA_GROUP_HASH # uninitialized constant RuboCop::AST::Node::STANZA_ORDER -# wrong constant name __ENCODING___type? -# wrong constant name __FILE___type? -# wrong constant name __LINE___type? -# wrong constant name alias_type? -# wrong constant name ancestors -# wrong constant name and_asgn_type? -# wrong constant name and_type? -# wrong constant name arg_expr_type? -# wrong constant name arg_type? -# wrong constant name args_type? -# wrong constant name argument? -# wrong constant name array_pattern_type? -# wrong constant name array_pattern_with_tail_type? -# wrong constant name array_type? -# wrong constant name assignment? -# wrong constant name assignment_or_similar?1 -# wrong constant name assignment_or_similar? -# wrong constant name back_ref_type? -# wrong constant name basic_conditional? -# wrong constant name basic_literal? -# wrong constant name begin_type? # wrong constant name block_args1 # wrong constant name block_args # wrong constant name block_body1 # wrong constant name block_body -# wrong constant name block_pass_type? -# wrong constant name block_type? -# wrong constant name blockarg_expr_type? -# wrong constant name blockarg_type? -# wrong constant name boolean_type? -# wrong constant name break_type? -# wrong constant name call_type? -# wrong constant name case_match_type? -# wrong constant name case_type? -# wrong constant name casgn_type? # wrong constant name cask_block?1 # wrong constant name cask_block? -# wrong constant name cbase_type? -# wrong constant name chained? -# wrong constant name child_nodes -# wrong constant name class_constructor?1 -# wrong constant name class_constructor? -# wrong constant name class_type? -# wrong constant name complete! -# wrong constant name complete? -# wrong constant name complex_type? -# wrong constant name conditional? -# wrong constant name const_name -# wrong constant name const_pattern_type? -# wrong constant name const_type? -# wrong constant name csend_type? -# wrong constant name cvar_type? -# wrong constant name cvasgn_type? -# wrong constant name def_e_type? -# wrong constant name def_type? -# wrong constant name defined_module -# wrong constant name defined_module_name -# wrong constant name defined_type? -# wrong constant name defs_e_type? -# wrong constant name defs_type? -# wrong constant name descendants -# wrong constant name dstr_type? -# wrong constant name dsym_type? -# wrong constant name each_ancestor -# wrong constant name each_child_node -# wrong constant name each_descendant -# wrong constant name each_node -# wrong constant name eflipflop_type? -# wrong constant name empty_else_type? -# wrong constant name empty_source? -# wrong constant name ensure_type? -# wrong constant name equals_asgn? -# wrong constant name erange_type? -# wrong constant name false_type? -# wrong constant name falsey_literal? -# wrong constant name first_line -# wrong constant name float_type? -# wrong constant name for_type? -# wrong constant name forward_args_type? -# wrong constant name forwarded_args_type? -# wrong constant name guard_clause? -# wrong constant name gvar_type? -# wrong constant name gvasgn_type? -# wrong constant name hash_pattern_type? -# wrong constant name hash_type? -# wrong constant name ident_type? -# wrong constant name if_guard_type? -# wrong constant name if_type? -# wrong constant name iflipflop_type? -# wrong constant name immutable_literal? -# wrong constant name in_match_type? -# wrong constant name in_pattern_type? -# wrong constant name index_type? -# wrong constant name indexasgn_type? -# wrong constant name int_type? -# wrong constant name irange_type? -# wrong constant name ivar_type? -# wrong constant name ivasgn_type? # wrong constant name key_node1 # wrong constant name key_node -# wrong constant name keyword? -# wrong constant name kwarg_type? -# wrong constant name kwbegin_type? -# wrong constant name kwnilarg_type? -# wrong constant name kwoptarg_type? -# wrong constant name kwrestarg_type? -# wrong constant name kwsplat_type? -# wrong constant name lambda?1 -# wrong constant name lambda? -# wrong constant name lambda_or_proc?1 -# wrong constant name lambda_or_proc? -# wrong constant name lambda_type? -# wrong constant name last_line -# wrong constant name line_count -# wrong constant name literal? -# wrong constant name lvar_type? -# wrong constant name lvasgn_type? -# wrong constant name masgn_type? -# wrong constant name match_alt_type? -# wrong constant name match_as_type? -# wrong constant name match_current_line_type? -# wrong constant name match_guard_clause?1 -# wrong constant name match_guard_clause? -# wrong constant name match_nil_pattern_type? -# wrong constant name match_rest_type? -# wrong constant name match_var_type? -# wrong constant name match_with_lvasgn_type? -# wrong constant name match_with_trailing_comma_type? # wrong constant name method_node1 # wrong constant name method_node -# wrong constant name mlhs_type? -# wrong constant name module_type? -# wrong constant name mrasgn_type? -# wrong constant name multiline? -# wrong constant name mutable_literal? -# wrong constant name new_class_or_module_block?1 -# wrong constant name new_class_or_module_block? -# wrong constant name next_type? -# wrong constant name nil_type? -# wrong constant name node_parts -# wrong constant name nonempty_line_count -# wrong constant name not_type? -# wrong constant name nth_ref_type? -# wrong constant name numargs_type? -# wrong constant name numblock_type? -# wrong constant name numeric_type? -# wrong constant name objc_kwarg_type? -# wrong constant name objc_restarg_type? -# wrong constant name objc_varargs_type? -# wrong constant name op_asgn_type? -# wrong constant name operator_keyword? -# wrong constant name optarg_type? -# wrong constant name or_asgn_type? -# wrong constant name or_type? -# wrong constant name pair_type? -# wrong constant name parent -# wrong constant name parent= -# wrong constant name parent_module_name -# wrong constant name parenthesized_call? -# wrong constant name pin_type? -# wrong constant name postexe_type? -# wrong constant name preexe_type? -# wrong constant name proc?1 -# wrong constant name proc? -# wrong constant name procarg0_type? -# wrong constant name pure? -# wrong constant name range_type? -# wrong constant name rasgn_type? -# wrong constant name rational_type? -# wrong constant name receiver1 -# wrong constant name receiver -# wrong constant name recursive_basic_literal? -# wrong constant name recursive_literal? -# wrong constant name redo_type? -# wrong constant name reference? -# wrong constant name regexp_type? -# wrong constant name regopt_type? -# wrong constant name resbody_type? -# wrong constant name rescue_type? -# wrong constant name restarg_expr_type? -# wrong constant name restarg_type? -# wrong constant name retry_type? -# wrong constant name return_type? -# wrong constant name root_type? -# wrong constant name sclass_type? -# wrong constant name self_type? -# wrong constant name send_type? -# wrong constant name shadowarg_type? -# wrong constant name shorthand_asgn? -# wrong constant name sibling_index -# wrong constant name single_line? -# wrong constant name source -# wrong constant name source_length -# wrong constant name source_range -# wrong constant name special_keyword? -# wrong constant name splat_type? -# wrong constant name str_content1 -# wrong constant name str_content -# wrong constant name str_type? -# wrong constant name super_type? -# wrong constant name sym_type? -# wrong constant name true_type? -# wrong constant name truthy_literal? -# wrong constant name undef_type? -# wrong constant name unless_guard_type? -# wrong constant name until_post_type? -# wrong constant name until_type? # wrong constant name val_node1 # wrong constant name val_node -# wrong constant name value_used? -# wrong constant name variable? -# wrong constant name visit_descendants -# wrong constant name when_type? -# wrong constant name while_post_type? -# wrong constant name while_type? -# wrong constant name xstr_type? -# wrong constant name yield_type? -# wrong constant name zsuper_type? -# wrong constant name == -# wrong constant name -# wrong constant name -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name marshal_dump -# wrong constant name marshal_load -# wrong constant name match -# wrong constant name pattern -# wrong constant name -# wrong constant name def_node_matcher -# wrong constant name def_node_search -# wrong constant name node_search -# wrong constant name node_search_all -# wrong constant name node_search_body -# wrong constant name node_search_first -# wrong constant name -# wrong constant name -# wrong constant name descend -# wrong constant name sign? -# wrong constant name -# uninitialized constant RuboCop::AST::OrNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::OrNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::OrNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::OrNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::OrNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::OrNode::CONDITIONALS -# uninitialized constant RuboCop::AST::OrNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::OrNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::OrNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::OrNode::KEYWORDS -# uninitialized constant RuboCop::AST::OrNode::LITERALS -# uninitialized constant RuboCop::AST::OrNode::LOGICAL_AND -# uninitialized constant RuboCop::AST::OrNode::LOGICAL_OR -# uninitialized constant RuboCop::AST::OrNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::OrNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::OrNode::REFERENCES -# uninitialized constant RuboCop::AST::OrNode::SEMANTIC_AND -# uninitialized constant RuboCop::AST::OrNode::SEMANTIC_OR -# uninitialized constant RuboCop::AST::OrNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::OrNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::OrNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::OrNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::OrNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::OrNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::OrNode::VARIABLES -# wrong constant name alternate_operator -# wrong constant name inverse_operator -# wrong constant name -# undefined method `delimiter1' for class `RuboCop::AST::PairNode' -# undefined method `inverse_delimiter1' for class `RuboCop::AST::PairNode' -# uninitialized constant RuboCop::AST::PairNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::PairNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::PairNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::PairNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::PairNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::PairNode::CONDITIONALS -# uninitialized constant RuboCop::AST::PairNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::PairNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::PairNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::PairNode::KEYWORDS -# uninitialized constant RuboCop::AST::PairNode::LITERALS -# uninitialized constant RuboCop::AST::PairNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::PairNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::PairNode::REFERENCES -# uninitialized constant RuboCop::AST::PairNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::PairNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::PairNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::PairNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::PairNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::PairNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::PairNode::VARIABLES -# wrong constant name colon? -# wrong constant name delimiter1 -# wrong constant name delimiter -# wrong constant name hash_rocket? -# wrong constant name inverse_delimiter1 -# wrong constant name inverse_delimiter -# wrong constant name value_on_new_line? -# wrong constant name -# wrong constant name arguments? -# wrong constant name block_argument? -# wrong constant name first_argument -# wrong constant name last_argument -# wrong constant name parenthesized? -# wrong constant name rest_argument? -# wrong constant name splat_argument? -# wrong constant name -# wrong constant name logical_operator? -# wrong constant name operator -# wrong constant name semantic_operator? -# wrong constant name -# undefined method `initialize1' for class `RuboCop::AST::ProcessedSource' -# wrong constant name [] -# wrong constant name ast -# wrong constant name ast_with_comments -# wrong constant name buffer -# wrong constant name checksum -# wrong constant name commented? -# wrong constant name comments -# wrong constant name comments_before_line -# wrong constant name current_line -# wrong constant name diagnostics -# wrong constant name each_comment -# wrong constant name each_token -# wrong constant name file_path -# wrong constant name find_comment -# wrong constant name find_token -# wrong constant name following_line -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name line_indentation -# wrong constant name lines -# wrong constant name parser_error -# wrong constant name path -# wrong constant name preceding_line -# wrong constant name raw_source -# wrong constant name ruby_version -# wrong constant name start_with? -# wrong constant name tokens -# wrong constant name valid_syntax? -# wrong constant name -# wrong constant name from_file -# uninitialized constant RuboCop::AST::RangeNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::RangeNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::RangeNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::RangeNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::CONDITIONALS -# uninitialized constant RuboCop::AST::RangeNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RangeNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::KEYWORDS -# uninitialized constant RuboCop::AST::RangeNode::LITERALS -# uninitialized constant RuboCop::AST::RangeNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::RangeNode::REFERENCES -# uninitialized constant RuboCop::AST::RangeNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RangeNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::RangeNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::RangeNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::RangeNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::RangeNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::RangeNode::VARIABLES -# wrong constant name begin -# wrong constant name end -# wrong constant name -# uninitialized constant RuboCop::AST::RegexpNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::RegexpNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::RegexpNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::CONDITIONALS -# uninitialized constant RuboCop::AST::RegexpNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::REFERENCES -# uninitialized constant RuboCop::AST::RegexpNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::RegexpNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::RegexpNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::RegexpNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::VARIABLES -# wrong constant name content -# wrong constant name regopt -# wrong constant name to_regexp -# wrong constant name -# uninitialized constant RuboCop::AST::ResbodyNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ResbodyNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ResbodyNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ResbodyNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ResbodyNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ResbodyNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::KEYWORDS -# uninitialized constant RuboCop::AST::ResbodyNode::LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ResbodyNode::REFERENCES -# uninitialized constant RuboCop::AST::ResbodyNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ResbodyNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ResbodyNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ResbodyNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ResbodyNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ResbodyNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ResbodyNode::VARIABLES -# wrong constant name body -# wrong constant name exception_variable -# wrong constant name -# uninitialized constant RuboCop::AST::RetryNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::RetryNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::RetryNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::RetryNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::RetryNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::CONDITIONALS -# uninitialized constant RuboCop::AST::RetryNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::RetryNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RetryNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::KEYWORDS -# uninitialized constant RuboCop::AST::RetryNode::LITERALS -# uninitialized constant RuboCop::AST::RetryNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::RetryNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::RetryNode::REFERENCES -# uninitialized constant RuboCop::AST::RetryNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RetryNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::RetryNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::RetryNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::RetryNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::RetryNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::RetryNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::RetryNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::ReturnNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::ReturnNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::ReturnNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::ReturnNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::ReturnNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::CONDITIONALS -# uninitialized constant RuboCop::AST::ReturnNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::ReturnNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ReturnNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::KEYWORDS -# uninitialized constant RuboCop::AST::ReturnNode::LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::ReturnNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::ReturnNode::REFERENCES -# uninitialized constant RuboCop::AST::ReturnNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::ReturnNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::ReturnNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::ReturnNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::ReturnNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::ReturnNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::ReturnNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::ReturnNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::SelfClassNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::SelfClassNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::SelfClassNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::SelfClassNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::CONDITIONALS -# uninitialized constant RuboCop::AST::SelfClassNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SelfClassNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::KEYWORDS -# uninitialized constant RuboCop::AST::SelfClassNode::LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::SelfClassNode::REFERENCES -# uninitialized constant RuboCop::AST::SelfClassNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SelfClassNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::SelfClassNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::SelfClassNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::SelfClassNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::SelfClassNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::SelfClassNode::VARIABLES -# wrong constant name body -# wrong constant name identifier -# wrong constant name -# undefined method `attribute_accessor?1' for class `RuboCop::AST::SendNode' -# uninitialized constant RuboCop::AST::SendNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::SendNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::SendNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::SendNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::SendNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::SendNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::SendNode::CONDITIONALS -# uninitialized constant RuboCop::AST::SendNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::SendNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SendNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::SendNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SendNode::KEYWORDS -# uninitialized constant RuboCop::AST::SendNode::LITERALS -# uninitialized constant RuboCop::AST::SendNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SendNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::SendNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::SendNode::REFERENCES -# uninitialized constant RuboCop::AST::SendNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SendNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::SendNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::SendNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::SendNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::SendNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::SendNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::SendNode::VARIABLES -# wrong constant name attribute_accessor?1 -# wrong constant name attribute_accessor? -# wrong constant name -# wrong constant name s -# wrong constant name -# uninitialized constant RuboCop::AST::StrNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::StrNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::StrNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::StrNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::StrNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::StrNode::CONDITIONALS -# uninitialized constant RuboCop::AST::StrNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::StrNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::StrNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::StrNode::KEYWORDS -# uninitialized constant RuboCop::AST::StrNode::LITERALS -# uninitialized constant RuboCop::AST::StrNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::StrNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::StrNode::REFERENCES -# uninitialized constant RuboCop::AST::StrNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::StrNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::StrNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::StrNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::StrNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::StrNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::StrNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::SuperNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::SuperNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::SuperNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::SuperNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::SuperNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::CONDITIONALS -# uninitialized constant RuboCop::AST::SuperNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::SuperNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SuperNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::KEYWORDS -# uninitialized constant RuboCop::AST::SuperNode::LITERALS -# uninitialized constant RuboCop::AST::SuperNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::SuperNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::SuperNode::REFERENCES -# uninitialized constant RuboCop::AST::SuperNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SuperNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::SuperNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::SuperNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::SuperNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::SuperNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::SuperNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::SuperNode::VARIABLES -# wrong constant name -# uninitialized constant RuboCop::AST::SymbolNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::SymbolNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::SymbolNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::SymbolNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::CONDITIONALS -# uninitialized constant RuboCop::AST::SymbolNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SymbolNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::KEYWORDS -# uninitialized constant RuboCop::AST::SymbolNode::LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::SymbolNode::REFERENCES -# uninitialized constant RuboCop::AST::SymbolNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::SymbolNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::SymbolNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::SymbolNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::SymbolNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::SymbolNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::SymbolNode::VARIABLES -# wrong constant name -# wrong constant name begin_pos -# wrong constant name column -# wrong constant name comma? -# wrong constant name comment? -# wrong constant name end? -# wrong constant name end_pos -# wrong constant name equal_sign? -# wrong constant name initialize -# wrong constant name left_array_bracket? -# wrong constant name left_brace? -# wrong constant name left_bracket? -# wrong constant name left_curly_brace? -# wrong constant name left_parens? -# wrong constant name left_ref_bracket? -# wrong constant name line -# wrong constant name pos -# wrong constant name rescue_modifier? -# wrong constant name right_bracket? -# wrong constant name right_curly_brace? -# wrong constant name right_parens? -# wrong constant name semicolon? -# wrong constant name space_after? -# wrong constant name space_before? -# wrong constant name text -# wrong constant name type -# wrong constant name -# wrong constant name from_parser_token -# wrong constant name on_alias -# wrong constant name on_and -# wrong constant name on_and_asgn -# wrong constant name on_arg -# wrong constant name on_arg_expr -# wrong constant name on_args -# wrong constant name on_array -# wrong constant name on_array_pattern -# wrong constant name on_array_pattern_with_tail -# wrong constant name on_back_ref -# wrong constant name on_begin -# wrong constant name on_block -# wrong constant name on_block_pass -# wrong constant name on_blockarg -# wrong constant name on_break -# wrong constant name on_case -# wrong constant name on_case_match -# wrong constant name on_casgn -# wrong constant name on_cbase -# wrong constant name on_class -# wrong constant name on_complex -# wrong constant name on_const -# wrong constant name on_const_pattern -# wrong constant name on_csend -# wrong constant name on_cvar -# wrong constant name on_cvasgn -# wrong constant name on_def -# wrong constant name on_defined? -# wrong constant name on_defs -# wrong constant name on_dstr -# wrong constant name on_dsym -# wrong constant name on_eflipflop -# wrong constant name on_empty_else -# wrong constant name on_ensure -# wrong constant name on_erange -# wrong constant name on_false -# wrong constant name on_float -# wrong constant name on_for -# wrong constant name on_forward_args -# wrong constant name on_forwarded_args -# wrong constant name on_gvar -# wrong constant name on_gvasgn -# wrong constant name on_hash -# wrong constant name on_hash_pattern -# wrong constant name on_if -# wrong constant name on_if_guard -# wrong constant name on_iflipflop -# wrong constant name on_in_match -# wrong constant name on_in_pattern -# wrong constant name on_int -# wrong constant name on_irange -# wrong constant name on_ivar -# wrong constant name on_ivasgn -# wrong constant name on_kwarg -# wrong constant name on_kwbegin -# wrong constant name on_kwoptarg -# wrong constant name on_kwrestarg -# wrong constant name on_kwsplat -# wrong constant name on_lambda -# wrong constant name on_lvar -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_match_alt -# wrong constant name on_match_as -# wrong constant name on_match_current_line -# wrong constant name on_match_nil_pattern -# wrong constant name on_match_rest -# wrong constant name on_match_var -# wrong constant name on_match_with_lvasgn -# wrong constant name on_match_with_trailing_comma -# wrong constant name on_mlhs -# wrong constant name on_module -# wrong constant name on_next -# wrong constant name on_nil -# wrong constant name on_not -# wrong constant name on_nth_ref -# wrong constant name on_numblock -# wrong constant name on_op_asgn -# wrong constant name on_optarg -# wrong constant name on_or -# wrong constant name on_or_asgn -# wrong constant name on_pair -# wrong constant name on_pin -# wrong constant name on_postexe -# wrong constant name on_preexe -# wrong constant name on_rational -# wrong constant name on_redo -# wrong constant name on_regexp -# wrong constant name on_regopt -# wrong constant name on_resbody -# wrong constant name on_rescue -# wrong constant name on_restarg -# wrong constant name on_retry -# wrong constant name on_return -# wrong constant name on_sclass -# wrong constant name on_self -# wrong constant name on_send -# wrong constant name on_shadowarg -# wrong constant name on_splat -# wrong constant name on_str -# wrong constant name on_super -# wrong constant name on_sym -# wrong constant name on_true -# wrong constant name on_undef -# wrong constant name on_unless_guard -# wrong constant name on_until -# wrong constant name on_until_post -# wrong constant name on_when -# wrong constant name on_while -# wrong constant name on_while_post -# wrong constant name on_xstr -# wrong constant name on_yield -# wrong constant name on_zsuper -# wrong constant name walk -# wrong constant name -# uninitialized constant RuboCop::AST::UntilNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::UntilNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::UntilNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::UntilNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::CONDITIONALS -# uninitialized constant RuboCop::AST::UntilNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::UntilNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::KEYWORDS -# uninitialized constant RuboCop::AST::UntilNode::LITERALS -# uninitialized constant RuboCop::AST::UntilNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::UntilNode::REFERENCES -# uninitialized constant RuboCop::AST::UntilNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::UntilNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::UntilNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::UntilNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::UntilNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::UntilNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::UntilNode::VARIABLES -# wrong constant name do? -# wrong constant name inverse_keyword -# wrong constant name keyword -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::AST::WhenNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhenNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::WhenNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::WhenNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::CONDITIONALS -# uninitialized constant RuboCop::AST::WhenNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhenNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::KEYWORDS -# uninitialized constant RuboCop::AST::WhenNode::LITERALS -# uninitialized constant RuboCop::AST::WhenNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::WhenNode::REFERENCES -# uninitialized constant RuboCop::AST::WhenNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhenNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::WhenNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::WhenNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::WhenNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::WhenNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::WhenNode::VARIABLES -# wrong constant name body -# wrong constant name branch_index -# wrong constant name conditions -# wrong constant name each_condition -# wrong constant name then? -# wrong constant name -# uninitialized constant RuboCop::AST::WhileNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhileNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::WhileNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::WhileNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::CONDITIONALS -# uninitialized constant RuboCop::AST::WhileNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhileNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::KEYWORDS -# uninitialized constant RuboCop::AST::WhileNode::LITERALS -# uninitialized constant RuboCop::AST::WhileNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::WhileNode::REFERENCES -# uninitialized constant RuboCop::AST::WhileNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::WhileNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::WhileNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::WhileNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::WhileNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::WhileNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::WhileNode::VARIABLES -# wrong constant name do? -# wrong constant name inverse_keyword -# wrong constant name keyword -# wrong constant name -# uninitialized constant RuboCop::AST::YieldNode::ARITHMETIC_OPERATORS -# uninitialized constant RuboCop::AST::YieldNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::YieldNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::YieldNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::YieldNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::CONDITIONALS -# uninitialized constant RuboCop::AST::YieldNode::ENUMERATOR_METHODS -# uninitialized constant RuboCop::AST::YieldNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::YieldNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::KEYWORDS -# uninitialized constant RuboCop::AST::YieldNode::LITERALS -# uninitialized constant RuboCop::AST::YieldNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::YieldNode::OPERATOR_METHODS -# uninitialized constant RuboCop::AST::YieldNode::REFERENCES -# uninitialized constant RuboCop::AST::YieldNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::YieldNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::YieldNode::SPECIAL_MODIFIERS -# uninitialized constant RuboCop::AST::YieldNode::STANZA_GROUPS -# uninitialized constant RuboCop::AST::YieldNode::STANZA_GROUP_HASH -# uninitialized constant RuboCop::AST::YieldNode::STANZA_ORDER -# uninitialized constant RuboCop::AST::YieldNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::YieldNode::VARIABLES -# wrong constant name -# undefined method `run1' for class `RuboCop::CLI' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name config_store -# wrong constant name options -# wrong constant name run1 -# wrong constant name run -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name run -# wrong constant name -# wrong constant name env -# wrong constant name initialize -# wrong constant name -# wrong constant name by_command_name -# wrong constant name command_name -# wrong constant name command_name= -# wrong constant name inherited -# wrong constant name run -# wrong constant name -# wrong constant name run -# wrong constant name -# wrong constant name run -# wrong constant name -# wrong constant name run -# wrong constant name -# wrong constant name -# wrong constant name run -# wrong constant name config_store -# wrong constant name initialize -# wrong constant name options -# wrong constant name paths -# wrong constant name run -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name from_json -# wrong constant name initialize -# wrong constant name to_json -# wrong constant name # wrong constant name cask_body # wrong constant name app? # wrong constant name appcast? @@ -23556,192 +11237,6 @@ # wrong constant name version? # wrong constant name vst_plugin? # wrong constant name zap? -# wrong constant name -# wrong constant name cop_disabled_line_ranges -# wrong constant name cop_enabled_at_line? -# wrong constant name extra_enabled_comments -# wrong constant name initialize -# wrong constant name processed_source -# uninitialized constant RuboCop::CommentConfig::CopAnalysis::Elem -# wrong constant name line_ranges -# wrong constant name line_ranges= -# wrong constant name start_line_number -# wrong constant name start_line_number= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Config' -# undefined method `initialize2' for class `RuboCop::Config' -# wrong constant name -# wrong constant name [] -# wrong constant name []= -# wrong constant name add_excludes_from_higher_level -# wrong constant name allowed_camel_case_file? -# wrong constant name base_dir_for_path_parameters -# wrong constant name bundler_lock_file_path -# wrong constant name check -# wrong constant name delete -# wrong constant name deprecation_check -# wrong constant name disabled_new_cops? -# wrong constant name each -# wrong constant name each_key -# wrong constant name enabled_new_cops? -# wrong constant name file_to_exclude? -# wrong constant name file_to_include? -# wrong constant name for_all_cops -# wrong constant name for_cop -# wrong constant name for_department -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name internal? -# wrong constant name key? -# wrong constant name keys -# wrong constant name loaded_path -# wrong constant name make_excludes_absolute -# wrong constant name map -# wrong constant name merge -# wrong constant name path_relative_to_config -# wrong constant name patterns_to_exclude -# wrong constant name patterns_to_include -# wrong constant name pending_cops -# wrong constant name possibly_include_hidden? -# wrong constant name signature -# wrong constant name smart_loaded_path -# wrong constant name target_rails_version -# wrong constant name target_ruby_version -# wrong constant name to_h -# wrong constant name to_hash -# wrong constant name transform_values -# wrong constant name validate -# uninitialized constant RuboCop::Config::CopConfig::Elem -# wrong constant name metadata -# wrong constant name metadata= -# wrong constant name name -# wrong constant name name= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name create -# undefined singleton method `merge_with_default1' for `RuboCop::ConfigLoader' -# wrong constant name -# wrong constant name add_excludes_from_files -# wrong constant name add_inheritance_from_auto_generated_file -# wrong constant name add_missing_namespaces -# wrong constant name auto_gen_config -# wrong constant name auto_gen_config= -# wrong constant name auto_gen_config? -# wrong constant name clear_options -# wrong constant name configuration_file_for -# wrong constant name configuration_from_file -# wrong constant name debug -# wrong constant name debug= -# wrong constant name debug? -# wrong constant name default_configuration -# wrong constant name default_configuration= -# wrong constant name disable_pending_cops -# wrong constant name disable_pending_cops= -# wrong constant name enable_pending_cops -# wrong constant name enable_pending_cops= -# wrong constant name ignore_parent_exclusion -# wrong constant name ignore_parent_exclusion= -# wrong constant name ignore_parent_exclusion? -# wrong constant name load_file -# wrong constant name merge -# wrong constant name merge_with_default1 -# wrong constant name merge_with_default -# wrong constant name options_config -# wrong constant name options_config= -# wrong constant name possible_new_cops? -# wrong constant name warn_on_pending_cops -# wrong constant name merge -# wrong constant name merge_with_default -# wrong constant name override_department_setting_for_cops -# wrong constant name resolve_inheritance -# wrong constant name resolve_inheritance_from_gems -# wrong constant name resolve_requires -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name reject_obsolete_cops_and_parameters -# wrong constant name -# wrong constant name for -# wrong constant name for_dir -# wrong constant name for_file -# wrong constant name force_default_config! -# wrong constant name options_config= -# wrong constant name -# wrong constant name for_all_cops -# wrong constant name initialize -# wrong constant name smart_loaded_path -# wrong constant name target_ruby_version -# wrong constant name validate -# wrong constant name validate_section_presence -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name align_end -# wrong constant name correct -# wrong constant name processed_source -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name autocorrect? -# wrong constant name autocorrect_enabled? -# wrong constant name autocorrect_requested? -# wrong constant name correctable? -# wrong constant name disable_offense -# wrong constant name disable_uncorrectable? -# wrong constant name safe_autocorrect? -# wrong constant name support_autocorrect? -# wrong constant name -# wrong constant name == -# wrong constant name -# wrong constant name cop_name -# wrong constant name department -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name match? -# wrong constant name qualified? -# wrong constant name with_department -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name for -# wrong constant name parse -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Bundler::DuplicatedGem::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Bundler::DuplicatedGem::LITERAL_REGEX -# wrong constant name gem_declarations -# wrong constant name investigate -# wrong constant name -# undefined method `gem_declaration?1' for class `RuboCop::Cop::Bundler::GemComment' -# uninitialized constant RuboCop::Cop::Bundler::GemComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::GemComment::NON_PUBLIC_MODIFIERS -# wrong constant name gem_declaration?1 -# wrong constant name gem_declaration? -# wrong constant name on_send -# wrong constant name -# undefined method `insecure_protocol_source?1' for class `RuboCop::Cop::Bundler::InsecureProtocolSource' -# uninitialized constant RuboCop::Cop::Bundler::InsecureProtocolSource::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Bundler::InsecureProtocolSource::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name insecure_protocol_source?1 -# wrong constant name insecure_protocol_source? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Bundler::OrderedGems::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name gem_declarations -# wrong constant name investigate -# wrong constant name -# wrong constant name # uninitialized constant RuboCop::Cop::Cask::HomepageMatchesUrl::LITERAL_REGEX # wrong constant name cask_node # wrong constant name sorted_toplevel_stanzas @@ -23759,179 +11254,9 @@ # wrong constant name cask_node # wrong constant name sorted_toplevel_stanzas # wrong constant name toplevel_stanzas -# wrong constant name on_and_asgn -# wrong constant name on_casgn -# wrong constant name on_cvasgn -# wrong constant name on_gvasgn -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_op_asgn -# wrong constant name on_or_asgn -# wrong constant name on_send -# wrong constant name -# wrong constant name extract_rhs -# wrong constant name extract_breakable_node -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Cop::Commissioner' -# undefined method `initialize2' for class `RuboCop::Cop::Commissioner' -# uninitialized constant RuboCop::Cop::Commissioner::MANY_CHILD_NODES -# uninitialized constant RuboCop::Cop::Commissioner::NO_CHILD_NODES -# uninitialized constant RuboCop::Cop::Commissioner::ONE_CHILD_NODE -# uninitialized constant RuboCop::Cop::Commissioner::SECOND_CHILD_ONLY -# wrong constant name errors -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name investigate -# wrong constant name -# wrong constant name -# wrong constant name correct_negative_condition -# wrong constant name alternative_style -# wrong constant name alternative_styles -# wrong constant name ambiguous_style_detected -# wrong constant name conflicting_styles_detected -# wrong constant name correct_style_detected -# wrong constant name detected_style -# wrong constant name detected_style= -# wrong constant name no_acceptable_style! -# wrong constant name no_acceptable_style? -# wrong constant name opposite_style_detected -# wrong constant name style -# wrong constant name style_configured? -# wrong constant name style_detected -# wrong constant name style_parameter_name -# wrong constant name supported_styles -# wrong constant name unexpected_style_detected -# wrong constant name unrecognized_style_detected -# wrong constant name -# undefined method `valid_name?1' for module `RuboCop::Cop::ConfigurableFormatting' -# wrong constant name check_name -# wrong constant name class_emitter_method? -# wrong constant name report_opposing_styles -# wrong constant name valid_name?1 -# wrong constant name valid_name? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `add_offense1' for class `RuboCop::Cop::Cop' -# undefined method `add_offense2' for class `RuboCop::Cop::Cop' -# undefined method `add_offense3' for class `RuboCop::Cop::Cop' -# undefined method `initialize1' for class `RuboCop::Cop::Cop' -# undefined method `initialize2' for class `RuboCop::Cop::Cop' -# undefined method `message1' for class `RuboCop::Cop::Cop' -# undefined method `parse1' for class `RuboCop::Cop::Cop' -# wrong constant name # uninitialized constant RuboCop::Cop::Cop::LITERAL_REGEX -# wrong constant name add_offense1 -# wrong constant name add_offense2 -# wrong constant name add_offense3 -# wrong constant name add_offense -# wrong constant name config -# wrong constant name config_to_allow_offenses -# wrong constant name config_to_allow_offenses= -# wrong constant name cop_config -# wrong constant name cop_name -# wrong constant name correct -# wrong constant name corrections -# wrong constant name disable_uncorrectable -# wrong constant name duplicate_location? -# wrong constant name excluded_file? -# wrong constant name external_dependency_checksum -# wrong constant name find_location # wrong constant name highlights -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name join_force? -# wrong constant name message1 -# wrong constant name message # wrong constant name messages -# wrong constant name name -# wrong constant name offenses -# wrong constant name parse1 -# wrong constant name parse -# wrong constant name processed_source -# wrong constant name processed_source= -# wrong constant name reason_to_not_correct -# wrong constant name relevant_file? -# wrong constant name target_rails_version -# wrong constant name target_ruby_version -# uninitialized constant RuboCop::Cop::Cop::Correction::Elem -# wrong constant name call -# wrong constant name cop -# wrong constant name cop= -# wrong constant name lambda= -# wrong constant name node -# wrong constant name node= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name all -# wrong constant name autocorrect_incompatible_with -# wrong constant name badge -# wrong constant name cop_name -# wrong constant name department -# wrong constant name exclude_from_registry -# wrong constant name inherited -# wrong constant name lint? -# wrong constant name match? -# wrong constant name qualified_cop_name -# wrong constant name registry -# undefined method `initialize1' for class `RuboCop::Cop::Corrector' -# wrong constant name corrections -# wrong constant name diagnostics -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name insert_after -# wrong constant name insert_before -# wrong constant name remove -# wrong constant name remove_leading -# wrong constant name remove_preceding -# wrong constant name remove_trailing -# wrong constant name replace -# wrong constant name rewrite -# wrong constant name wrap -# wrong constant name -# undefined method `non_public_modifier?1' for module `RuboCop::Cop::DefNode' -# wrong constant name non_public_modifier?1 -# wrong constant name non_public_modifier? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name insert_before -# undefined method `empty_arguments?1' for module `RuboCop::Cop::EmptyParameter' -# wrong constant name empty_arguments?1 -# wrong constant name empty_arguments? -# wrong constant name -# uninitialized constant RuboCop::Cop::EndKeywordAlignment::BYTE_ORDER_MARK -# wrong constant name -# wrong constant name on_class -# wrong constant name on_send -# wrong constant name -# wrong constant name included -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name cops -# wrong constant name initialize -# wrong constant name investigate -# wrong constant name name -# wrong constant name run_hook -# wrong constant name -# wrong constant name all -# wrong constant name force_name -# wrong constant name inherited # undefined method `depends_on_node?1' for class `RuboCop::Cop::FormulaAudit::ComponentsOrder' # uninitialized constant RuboCop::Cop::FormulaAudit::ComponentsOrder::BYTE_ORDER_MARK # uninitialized constant RuboCop::Cop::FormulaAudit::ComponentsOrder::LITERAL_REGEX @@ -23972,5449 +11297,6 @@ # wrong constant name dependency_type_hash_match? # wrong constant name required_dependency? # wrong constant name required_dependency_name? -# wrong constant name -# wrong constant name frozen_string_literal_comment_exists? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Gemspec::DuplicatedAssignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Gemspec::DuplicatedAssignment::LITERAL_REGEX -# wrong constant name assignment_method_declarations -# wrong constant name gem_specification -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Gemspec::OrderedDependencies::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name dependency_declarations -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Gemspec::RequiredRubyVersion::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name required_ruby_version -# wrong constant name -# undefined method `ruby_version?1' for class `RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage' -# uninitialized constant RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::LITERAL_REGEX -# wrong constant name gem_specification? -# wrong constant name on_const -# wrong constant name ruby_version?1 -# wrong constant name ruby_version? -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Cop::Generator' -# undefined method `inject_config1' for class `RuboCop::Cop::Generator' -# undefined method `inject_config2' for class `RuboCop::Cop::Generator' -# undefined method `inject_require1' for class `RuboCop::Cop::Generator' -# wrong constant name -# wrong constant name -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name inject_config1 -# wrong constant name inject_config2 -# wrong constant name inject_config -# wrong constant name inject_require1 -# wrong constant name inject_require -# wrong constant name todo -# wrong constant name write_source -# wrong constant name write_spec -# wrong constant name initialize -# wrong constant name inject -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Cop::Generator::RequireFileInjector' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name inject -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name checkable_layout? -# wrong constant name deltas -# wrong constant name deltas_for_first_pair -# wrong constant name -# wrong constant name deltas_for_first_pair -# wrong constant name -# wrong constant name deltas_for_first_pair -# wrong constant name -# wrong constant name checkable_layout? -# wrong constant name deltas -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_csend -# wrong constant name on_send -# uninitialized constant RuboCop::Cop::HashTransformMethod::Autocorrection::Elem -# wrong constant name block_node -# wrong constant name block_node= -# wrong constant name leading -# wrong constant name leading= -# wrong constant name match -# wrong constant name match= -# wrong constant name set_new_arg_name -# wrong constant name set_new_body_expression -# wrong constant name set_new_method_name -# wrong constant name strip_prefix_and_suffix -# wrong constant name trailing -# wrong constant name trailing= -# wrong constant name -# wrong constant name [] -# wrong constant name from_each_with_object -# wrong constant name from_hash_brackets_map -# wrong constant name from_map_to_h -# wrong constant name members -# uninitialized constant RuboCop::Cop::HashTransformMethod::Captures::Elem -# wrong constant name noop_transformation? -# wrong constant name transformation_uses_both_args? -# wrong constant name transformed_argname -# wrong constant name transformed_argname= -# wrong constant name transforming_body_expr -# wrong constant name transforming_body_expr= -# wrong constant name unchanged_body_expr -# wrong constant name unchanged_body_expr= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name on_dstr -# wrong constant name on_heredoc -# wrong constant name on_str -# wrong constant name on_xstr -# wrong constant name -# wrong constant name -# wrong constant name ignore_node -# wrong constant name ignored_node? -# wrong constant name part_of_ignored_node? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name on_dstr -# wrong constant name on_dsym -# wrong constant name on_node_with_interpolations -# wrong constant name on_regexp -# wrong constant name on_xstr -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name on_sclass -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ArgumentAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ArgumentAlignment::SPACE -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ArrayAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ArrayAlignment::SPACE -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::AssignmentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::AssignmentIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name check_assignment -# wrong constant name leftmost_multiple_assignment -# wrong constant name -# undefined method `block_end_align_target?1' for class `RuboCop::Cop::Layout::BlockAlignment' -# uninitialized constant RuboCop::Cop::Layout::BlockAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::BlockAlignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name block_end_align_target?1 -# wrong constant name block_end_align_target? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::BlockEndNewline::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::BlockEndNewline::SPACE -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name -# undefined method `visibility_block?1' for class `RuboCop::Cop::Layout::ClassStructure' -# uninitialized constant RuboCop::Cop::Layout::ClassStructure::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name visibility_block?1 -# wrong constant name visibility_block? -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ClosingHeredocIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ClosingHeredocIndentation::OPENING_DELIMITER -# wrong constant name autocorrect -# wrong constant name on_heredoc -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ClosingParenthesisIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ClosingParenthesisIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_begin -# wrong constant name on_csend -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::CommentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::CommentIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ConditionPosition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ConditionPosition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::DefEndAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::DefEndAlignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::DotPosition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# undefined method `on_if1' for class `RuboCop::Cop::Layout::ElseAlignment' -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::SPACE -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name on_case_match -# wrong constant name on_if1 -# wrong constant name on_if -# wrong constant name on_rescue -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyComment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterGuardClause::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterGuardClause::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMagicComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMagicComment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLineBetweenDefs::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineBetweenDefs::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check_defs -# wrong constant name on_begin -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLines::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLines::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name on_sclass -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundArguments::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_kwbegin -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# undefined method `constant_definition?1' for module `RuboCop::Cop::Layout::EmptyLinesAroundBody' -# undefined method `empty_line_required?1' for module `RuboCop::Cop::Layout::EmptyLinesAroundBody' -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBody::BYTE_ORDER_MARK -# wrong constant name constant_definition?1 -# wrong constant name constant_definition? -# wrong constant name empty_line_required?1 -# wrong constant name empty_line_required? -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name on_sclass -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_kwbegin -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_MISSING -# wrong constant name autocorrect -# wrong constant name on_module -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EndAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EndAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EndAlignment::MSG -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name on_class -# wrong constant name on_if -# wrong constant name on_module -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::EndOfLine::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EndOfLine::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name offense_message -# wrong constant name unimportant_missing_cr? -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ExtraSpacing::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ExtraSpacing::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `eligible_method_call?1' for class `RuboCop::Cop::Layout::FirstArgumentIndentation' -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name eligible_method_call?1 -# wrong constant name eligible_method_call? -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementLineBreak::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_hash -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementLineBreak::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name on_super -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstMethodParameterLineBreak::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::FirstParameterIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstParameterIndentation::SPACE -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::HashAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::HashAlignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name column_deltas -# wrong constant name column_deltas= -# wrong constant name offences_by -# wrong constant name offences_by= -# wrong constant name on_hash -# wrong constant name on_send -# wrong constant name on_super -# wrong constant name on_yield -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::HeredocIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::HeredocIndentation::OPENING_DELIMITER -# wrong constant name autocorrect -# wrong constant name on_heredoc -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::IndentationConsistency::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationConsistency::SPACE -# wrong constant name autocorrect -# wrong constant name on_begin -# wrong constant name on_kwbegin -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::SPACE -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `access_modifier?1' for class `RuboCop::Cop::Layout::IndentationWidth' -# undefined method `on_if1' for class `RuboCop::Cop::Layout::IndentationWidth' -# undefined method `on_until1' for class `RuboCop::Cop::Layout::IndentationWidth' -# undefined method `on_while1' for class `RuboCop::Cop::Layout::IndentationWidth' -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::SPACE -# wrong constant name access_modifier?1 -# wrong constant name access_modifier? -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_case -# wrong constant name on_class -# wrong constant name on_csend -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_ensure -# wrong constant name on_for -# wrong constant name on_if1 -# wrong constant name on_if -# wrong constant name on_kwbegin -# wrong constant name on_module -# wrong constant name on_resbody -# wrong constant name on_rescue -# wrong constant name on_sclass -# wrong constant name on_until1 -# wrong constant name on_until -# wrong constant name on_while1 -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::InitialIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::InitialIndentation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::LeadingCommentSpace::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::LeadingCommentSpace::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::LeadingEmptyLines::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::LineLength::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::LineLength::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name investigate_post_walk -# wrong constant name on_array -# wrong constant name on_block -# wrong constant name on_hash -# wrong constant name on_potential_breakable_node -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayBraceLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayLineBreaks::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineAssignmentLayout::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::MultilineAssignmentLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check_assignment -# wrong constant name check_by_enforced_style -# wrong constant name check_new_line_offense -# wrong constant name check_same_line_offense -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineBlockLayout::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::MultilineBlockLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineHashBraceLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::ASSIGNMENT_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::DEFAULT_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::KEYWORD_ANCESTOR_TYPES -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::KEYWORD_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallIndentation::UNALIGNED_RHS_TYPES -# wrong constant name autocorrect -# wrong constant name validate_config -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::ASSIGNMENT_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::DEFAULT_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::KEYWORD_ANCESTOR_TYPES -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::KEYWORD_MESSAGE_TAIL -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::MultilineOperationIndentation::UNALIGNED_RHS_TYPES -# wrong constant name autocorrect -# wrong constant name on_and -# wrong constant name on_or -# wrong constant name validate_config -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::ParameterAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ParameterAlignment::SPACE -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::RescueEnsureAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::RescueEnsureAlignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name on_ensure -# wrong constant name on_resbody -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterColon::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_kwoptarg -# wrong constant name on_pair -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterComma::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterComma::MSG -# wrong constant name autocorrect -# wrong constant name kind -# wrong constant name space_style_before_rcurly -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterMethodName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterMethodName::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterNot::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterNot::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name whitespace_after_operator? -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterSemicolon::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterSemicolon::MSG -# wrong constant name autocorrect -# wrong constant name kind -# wrong constant name space_style_before_rcurly -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundBlockParameters::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundBlockParameters::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_optarg -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundKeyword::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_and -# wrong constant name on_block -# wrong constant name on_break -# wrong constant name on_case -# wrong constant name on_defined? -# wrong constant name on_ensure -# wrong constant name on_for -# wrong constant name on_if -# wrong constant name on_kwbegin -# wrong constant name on_next -# wrong constant name on_or -# wrong constant name on_postexe -# wrong constant name on_preexe -# wrong constant name on_resbody -# wrong constant name on_rescue -# wrong constant name on_return -# wrong constant name on_send -# wrong constant name on_super -# wrong constant name on_until -# wrong constant name on_when -# wrong constant name on_while -# wrong constant name on_yield -# wrong constant name on_zsuper -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_const -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundOperators::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundOperators::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_and -# wrong constant name on_and_asgn -# wrong constant name on_assignment -# wrong constant name on_binary -# wrong constant name on_casgn -# wrong constant name on_class -# wrong constant name on_cvasgn -# wrong constant name on_gvasgn -# wrong constant name on_if -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_op_asgn -# wrong constant name on_or -# wrong constant name on_or_asgn -# wrong constant name on_pair -# wrong constant name on_resbody -# wrong constant name on_send -# wrong constant name on_special_asgn -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBlockBraces::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBlockBraces::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComma::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComma::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComma::MSG -# wrong constant name autocorrect -# wrong constant name kind -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeFirstArg::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeFirstArg::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeSemicolon::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeSemicolon::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeSemicolon::MSG -# wrong constant name autocorrect -# wrong constant name kind -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInLambdaLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInLambdaLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name on_percent_literal -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideBlockBraces::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideBlockBraces::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideBlockBraces::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideBlockBraces::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideBlockBraces::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name on_percent_literal -# wrong constant name on_xstr -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideRangeLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_erange -# wrong constant name on_irange -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_interpolation -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::TrailingEmptyLines::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::TrailingEmptyLines::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# wrong constant name -# undefined singleton method `break_line_before1' for `RuboCop::Cop::LineBreakCorrector' -# wrong constant name -# wrong constant name break_line_before1 -# wrong constant name break_line_before -# wrong constant name correct_trailing_body -# wrong constant name move_comment -# wrong constant name processed_source -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::AmbiguousBlockAssociation::LITERAL_REGEX -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::AmbiguousOperator::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::AmbiguousRegexpLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::AssignmentInCondition::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# undefined method `big_decimal_new1' for class `RuboCop::Cop::Lint::BigDecimalNew' -# uninitialized constant RuboCop::Cop::Lint::BigDecimalNew::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name big_decimal_new1 -# wrong constant name big_decimal_new -# wrong constant name on_send -# wrong constant name -# undefined method `boolean_symbol?1' for class `RuboCop::Cop::Lint::BooleanSymbol' -# uninitialized constant RuboCop::Cop::Lint::BooleanSymbol::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name boolean_symbol?1 -# wrong constant name boolean_symbol? -# wrong constant name on_sym -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::CircularArgumentReference::LITERAL_REGEX -# wrong constant name on_kwoptarg -# wrong constant name on_optarg -# wrong constant name -# undefined method `binding_irb_call?1' for class `RuboCop::Cop::Lint::Debugger' -# undefined method `debugger_call?1' for class `RuboCop::Cop::Lint::Debugger' -# undefined method `kernel?1' for class `RuboCop::Cop::Lint::Debugger' -# uninitialized constant RuboCop::Cop::Lint::Debugger::LITERAL_REGEX -# wrong constant name binding_irb_call?1 -# wrong constant name binding_irb_call? -# wrong constant name debugger_call?1 -# wrong constant name debugger_call? -# wrong constant name kernel?1 -# wrong constant name kernel? -# wrong constant name on_send -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::DeprecatedClassMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# undefined method `initialize1' for class `RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod' -# wrong constant name class_constant -# wrong constant name class_nodes -# wrong constant name deprecated_method -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name replacement_method -# wrong constant name -# wrong constant name -# undefined method `algorithm_const1' for class `RuboCop::Cop::Lint::DeprecatedOpenSSLConstant' -# uninitialized constant RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::LITERAL_REGEX -# wrong constant name algorithm_const1 -# wrong constant name algorithm_const -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::DuplicateCaseCondition::LITERAL_REGEX -# wrong constant name on_case -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::DuplicateHashKey::LITERAL_REGEX -# wrong constant name on_hash -# wrong constant name -# undefined method `alias_method?1' for class `RuboCop::Cop::Lint::DuplicateMethods' -# undefined method `method_alias?1' for class `RuboCop::Cop::Lint::DuplicateMethods' -# undefined method `sym_name1' for class `RuboCop::Cop::Lint::DuplicateMethods' -# uninitialized constant RuboCop::Cop::Lint::DuplicateMethods::LITERAL_REGEX -# wrong constant name alias_method?1 -# wrong constant name alias_method? -# wrong constant name method_alias?1 -# wrong constant name method_alias? -# wrong constant name on_alias -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name sym_name1 -# wrong constant name sym_name -# wrong constant name -# undefined method `each_with_object?1' for class `RuboCop::Cop::Lint::EachWithObjectArgument' -# uninitialized constant RuboCop::Cop::Lint::EachWithObjectArgument::LITERAL_REGEX -# wrong constant name each_with_object?1 -# wrong constant name each_with_object? -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ElseLayout::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::EmptyEnsure::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_ensure -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::EmptyExpression::LITERAL_REGEX -# wrong constant name on_begin -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::EmptyInterpolation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_interpolation -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::EmptyWhen::LITERAL_REGEX -# wrong constant name on_case -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::EnsureReturn::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::EnsureReturn::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_ensure -# wrong constant name -# undefined method `erb_new_with_non_keyword_arguments1' for class `RuboCop::Cop::Lint::ErbNewArguments' -# uninitialized constant RuboCop::Cop::Lint::ErbNewArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ErbNewArguments::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name erb_new_with_non_keyword_arguments1 -# wrong constant name erb_new_with_non_keyword_arguments -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::FlipFlop::LITERAL_REGEX -# wrong constant name on_eflipflop -# wrong constant name on_iflipflop -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::FloatOutOfRange::LITERAL_REGEX -# wrong constant name on_float -# wrong constant name -# undefined method `called_on_string?1' for class `RuboCop::Cop::Lint::FormatParameterMismatch' -# uninitialized constant RuboCop::Cop::Lint::FormatParameterMismatch::LITERAL_REGEX -# wrong constant name called_on_string?1 -# wrong constant name called_on_string? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::HeredocMethodCallPosition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::HeredocMethodCallPosition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ImplicitStringConcatenation::LITERAL_REGEX -# wrong constant name on_dstr -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::IneffectiveAccessModifier::LITERAL_REGEX -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name private_class_methods -# wrong constant name -# undefined method `class_new_call?1' for class `RuboCop::Cop::Lint::InheritException' -# uninitialized constant RuboCop::Cop::Lint::InheritException::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name class_new_call?1 -# wrong constant name class_new_call? -# wrong constant name on_class -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::InterpolationCheck::LITERAL_REGEX -# wrong constant name heredoc? -# wrong constant name on_str -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::LiteralAsCondition::LITERAL_REGEX -# wrong constant name message -# wrong constant name on_case -# wrong constant name on_if -# wrong constant name on_send -# wrong constant name on_until -# wrong constant name on_until_post -# wrong constant name on_while -# wrong constant name on_while_post -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::LiteralInInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::LiteralInInterpolation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_interpolation -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::Loop::LITERAL_REGEX -# wrong constant name on_until_post -# wrong constant name on_while_post -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::MissingCopEnableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::MissingCopEnableDirective::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::MixedRegexpCaptureTypes::LITERAL_REGEX -# wrong constant name on_regexp -# wrong constant name -# undefined method `multiple_compare?1' for class `RuboCop::Cop::Lint::MultipleComparison' -# uninitialized constant RuboCop::Cop::Lint::MultipleComparison::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name multiple_compare?1 -# wrong constant name multiple_compare? -# wrong constant name on_send -# wrong constant name -# undefined method `class_or_module_or_struct_new_call?1' for class `RuboCop::Cop::Lint::NestedMethodDefinition' -# undefined method `eval_call?1' for class `RuboCop::Cop::Lint::NestedMethodDefinition' -# undefined method `exec_call?1' for class `RuboCop::Cop::Lint::NestedMethodDefinition' -# uninitialized constant RuboCop::Cop::Lint::NestedMethodDefinition::LITERAL_REGEX -# wrong constant name class_or_module_or_struct_new_call?1 -# wrong constant name class_or_module_or_struct_new_call? -# wrong constant name eval_call?1 -# wrong constant name eval_call? -# wrong constant name exec_call?1 -# wrong constant name exec_call? -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::NestedPercentLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::NestedPercentLiteral::LITERAL_REGEX -# wrong constant name on_array -# wrong constant name on_percent_literal -# wrong constant name -# undefined method `on_body_of_reduce1' for class `RuboCop::Cop::Lint::NextWithoutAccumulator' -# uninitialized constant RuboCop::Cop::Lint::NextWithoutAccumulator::LITERAL_REGEX -# wrong constant name on_block -# wrong constant name on_body_of_reduce1 -# wrong constant name on_body_of_reduce -# wrong constant name -# undefined method `loop_variable1' for class `RuboCop::Cop::Lint::NonDeterministicRequireOrder' -# undefined method `unsorted_dir_block?1' for class `RuboCop::Cop::Lint::NonDeterministicRequireOrder' -# undefined method `unsorted_dir_each?1' for class `RuboCop::Cop::Lint::NonDeterministicRequireOrder' -# uninitialized constant RuboCop::Cop::Lint::NonDeterministicRequireOrder::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name loop_variable1 -# wrong constant name loop_variable -# wrong constant name on_block -# wrong constant name unsorted_dir_block?1 -# wrong constant name unsorted_dir_block? -# wrong constant name unsorted_dir_each?1 -# wrong constant name unsorted_dir_each? -# wrong constant name var_is_required? -# wrong constant name -# undefined method `chained_send?1' for class `RuboCop::Cop::Lint::NonLocalExitFromIterator' -# undefined method `define_method?1' for class `RuboCop::Cop::Lint::NonLocalExitFromIterator' -# uninitialized constant RuboCop::Cop::Lint::NonLocalExitFromIterator::LITERAL_REGEX -# wrong constant name chained_send?1 -# wrong constant name chained_send? -# wrong constant name define_method?1 -# wrong constant name define_method? -# wrong constant name on_return -# wrong constant name -# undefined method `datetime?1' for class `RuboCop::Cop::Lint::NumberConversion' -# undefined method `to_method1' for class `RuboCop::Cop::Lint::NumberConversion' -# uninitialized constant RuboCop::Cop::Lint::NumberConversion::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name datetime?1 -# wrong constant name datetime? -# wrong constant name on_send -# wrong constant name to_method1 -# wrong constant name to_method -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::FROZEN_STRING_LITERAL -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::FROZEN_STRING_LITERAL_TYPES -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::PercentStringArray::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::PercentStringArray::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name on_percent_literal -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::PercentSymbolArray::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::PercentSymbolArray::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name on_percent_literal -# wrong constant name -# undefined method `exception?1' for class `RuboCop::Cop::Lint::RaiseException' -# undefined method `exception_new_with_message?1' for class `RuboCop::Cop::Lint::RaiseException' -# uninitialized constant RuboCop::Cop::Lint::RaiseException::LITERAL_REGEX -# wrong constant name exception?1 -# wrong constant name exception? -# wrong constant name exception_new_with_message?1 -# wrong constant name exception_new_with_message? -# wrong constant name on_send -# wrong constant name -# undefined method `rand_one?1' for class `RuboCop::Cop::Lint::RandOne' -# uninitialized constant RuboCop::Cop::Lint::RandOne::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name rand_one?1 -# wrong constant name rand_one? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RedundantCopDisableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantCopDisableDirective::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `unnecessary_require_statement?1' for class `RuboCop::Cop::Lint::RedundantRequireStatement' -# uninitialized constant RuboCop::Cop::Lint::RedundantRequireStatement::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantRequireStatement::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name unnecessary_require_statement?1 -# wrong constant name unnecessary_require_statement? -# wrong constant name -# undefined method `array_new?1' for class `RuboCop::Cop::Lint::RedundantSplatExpansion' -# undefined method `literal_expansion1' for class `RuboCop::Cop::Lint::RedundantSplatExpansion' -# uninitialized constant RuboCop::Cop::Lint::RedundantSplatExpansion::LITERAL_REGEX -# wrong constant name array_new?1 -# wrong constant name array_new? -# wrong constant name autocorrect -# wrong constant name literal_expansion1 -# wrong constant name literal_expansion -# wrong constant name on_splat -# wrong constant name -# undefined method `to_s_without_args?1' for class `RuboCop::Cop::Lint::RedundantStringCoercion' -# uninitialized constant RuboCop::Cop::Lint::RedundantStringCoercion::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_interpolation -# wrong constant name to_s_without_args?1 -# wrong constant name to_s_without_args? -# wrong constant name -# undefined method `redundant_with_index?1' for class `RuboCop::Cop::Lint::RedundantWithIndex' -# uninitialized constant RuboCop::Cop::Lint::RedundantWithIndex::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantWithIndex::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name redundant_with_index?1 -# wrong constant name redundant_with_index? -# wrong constant name -# undefined method `redundant_with_object?1' for class `RuboCop::Cop::Lint::RedundantWithObject' -# uninitialized constant RuboCop::Cop::Lint::RedundantWithObject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantWithObject::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name redundant_with_object?1 -# wrong constant name redundant_with_object? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RegexpAsCondition::LITERAL_REGEX -# wrong constant name on_match_current_line -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RequireParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RequireParentheses::LITERAL_REGEX -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RescueException::LITERAL_REGEX -# wrong constant name on_resbody -# wrong constant name targets_exception? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::RescueType::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_resbody -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ReturnInVoidContext::LITERAL_REGEX -# wrong constant name on_return -# wrong constant name -# undefined method `bad_method?1' for class `RuboCop::Cop::Lint::SafeNavigationChain' -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationChain::LITERAL_REGEX -# wrong constant name bad_method?1 -# wrong constant name bad_method? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationConsistency::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check -# wrong constant name on_csend -# wrong constant name -# undefined method `safe_navigation_empty_in_conditional?1' for class `RuboCop::Cop::Lint::SafeNavigationWithEmpty' -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationWithEmpty::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name safe_navigation_empty_in_conditional?1 -# wrong constant name safe_navigation_empty_in_conditional? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ScriptPermission::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `send_with_mixin_argument?1' for class `RuboCop::Cop::Lint::SendWithMixinArgument' -# uninitialized constant RuboCop::Cop::Lint::SendWithMixinArgument::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::SendWithMixinArgument::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name send_with_mixin_argument?1 -# wrong constant name send_with_mixin_argument? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ShadowedArgument::LITERAL_REGEX -# wrong constant name after_leaving_scope -# wrong constant name join_force? -# wrong constant name uses_var? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ShadowedException::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ShadowedException::LITERAL_REGEX -# wrong constant name on_rescue -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::ShadowingOuterLocalVariable::LITERAL_REGEX -# wrong constant name before_declaring_variable -# wrong constant name join_force? -# wrong constant name -# undefined method `struct_new1' for class `RuboCop::Cop::Lint::StructNewOverride' -# uninitialized constant RuboCop::Cop::Lint::StructNewOverride::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name struct_new1 -# wrong constant name struct_new -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::SuppressedException::LITERAL_REGEX -# wrong constant name on_resbody -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::Syntax::LITERAL_REGEX -# wrong constant name -# wrong constant name add_offense_from_diagnostic -# wrong constant name add_offense_from_error -# uninitialized constant RuboCop::Cop::Lint::Syntax::PseudoSourceRange::Elem -# wrong constant name begin_pos -# wrong constant name begin_pos= -# wrong constant name column -# wrong constant name column= -# wrong constant name end_pos -# wrong constant name end_pos= -# wrong constant name line -# wrong constant name line= -# wrong constant name source_line -# wrong constant name source_line= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name offenses_from_processed_source -# uninitialized constant RuboCop::Cop::Lint::ToJSON::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::UnderscorePrefixedVariableName::LITERAL_REGEX -# wrong constant name after_leaving_scope -# wrong constant name check_variable -# wrong constant name join_force? -# wrong constant name -# undefined method `fixnum_or_bignum_const1' for class `RuboCop::Cop::Lint::UnifiedInteger' -# uninitialized constant RuboCop::Cop::Lint::UnifiedInteger::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name fixnum_or_bignum_const1 -# wrong constant name fixnum_or_bignum_const -# wrong constant name on_const -# wrong constant name -# undefined method `flow_command?1' for class `RuboCop::Cop::Lint::UnreachableCode' -# uninitialized constant RuboCop::Cop::Lint::UnreachableCode::LITERAL_REGEX -# wrong constant name flow_command?1 -# wrong constant name flow_command? -# wrong constant name on_begin -# wrong constant name on_kwbegin -# wrong constant name -# wrong constant name after_leaving_scope -# wrong constant name join_force? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::UnusedBlockArgument::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name -# undefined method `not_implemented?1' for class `RuboCop::Cop::Lint::UnusedMethodArgument' -# uninitialized constant RuboCop::Cop::Lint::UnusedMethodArgument::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name not_implemented?1 -# wrong constant name not_implemented? -# wrong constant name -# undefined method `uri_escape_unescape?1' for class `RuboCop::Cop::Lint::UriEscapeUnescape' -# uninitialized constant RuboCop::Cop::Lint::UriEscapeUnescape::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name uri_escape_unescape?1 -# wrong constant name uri_escape_unescape? -# wrong constant name -# undefined method `uri_regexp_with_argument?1' for class `RuboCop::Cop::Lint::UriRegexp' -# undefined method `uri_regexp_without_argument?1' for class `RuboCop::Cop::Lint::UriRegexp' -# uninitialized constant RuboCop::Cop::Lint::UriRegexp::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name uri_regexp_with_argument?1 -# wrong constant name uri_regexp_with_argument? -# wrong constant name uri_regexp_without_argument?1 -# wrong constant name uri_regexp_without_argument? -# wrong constant name -# undefined method `class_or_instance_eval?1' for class `RuboCop::Cop::Lint::UselessAccessModifier' -# undefined method `class_or_module_or_struct_new_call?1' for class `RuboCop::Cop::Lint::UselessAccessModifier' -# undefined method `dynamic_method_definition?1' for class `RuboCop::Cop::Lint::UselessAccessModifier' -# undefined method `static_method_definition?1' for class `RuboCop::Cop::Lint::UselessAccessModifier' -# uninitialized constant RuboCop::Cop::Lint::UselessAccessModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::UselessAccessModifier::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name class_or_instance_eval?1 -# wrong constant name class_or_instance_eval? -# wrong constant name class_or_module_or_struct_new_call?1 -# wrong constant name class_or_module_or_struct_new_call? -# wrong constant name dynamic_method_definition?1 -# wrong constant name dynamic_method_definition? -# wrong constant name on_block -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name on_sclass -# wrong constant name static_method_definition?1 -# wrong constant name static_method_definition? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::UselessAssignment::LITERAL_REGEX -# wrong constant name after_leaving_scope -# wrong constant name check_for_unused_assignments -# wrong constant name collect_variable_like_names -# wrong constant name join_force? -# wrong constant name message_for_useless_assignment -# wrong constant name message_specification -# wrong constant name multiple_assignment_message -# wrong constant name operator_assignment_message -# wrong constant name return_value_node_of_scope -# wrong constant name similar_name_message -# wrong constant name variable_like_method_invocation? -# wrong constant name -# undefined method `useless_comparison?1' for class `RuboCop::Cop::Lint::UselessComparison' -# uninitialized constant RuboCop::Cop::Lint::UselessComparison::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name useless_comparison?1 -# wrong constant name useless_comparison? -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::UselessElseWithoutRescue::LITERAL_REGEX -# wrong constant name -# undefined method `setter_call_to_local_variable?1' for class `RuboCop::Cop::Lint::UselessSetterCall' -# uninitialized constant RuboCop::Cop::Lint::UselessSetterCall::LITERAL_REGEX -# wrong constant name -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name setter_call_to_local_variable?1 -# wrong constant name setter_call_to_local_variable? -# wrong constant name constructor? -# wrong constant name contain_local_object? -# wrong constant name initialize -# wrong constant name process_assignment -# wrong constant name process_assignment_node -# wrong constant name process_binary_operator_assignment -# wrong constant name process_logical_operator_assignment -# wrong constant name process_multiple_assignment -# wrong constant name scan -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Lint::Void::LITERAL_REGEX -# wrong constant name on_begin -# wrong constant name on_block -# wrong constant name on_kwbegin -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::MatchRange::BYTE_ORDER_MARK -# wrong constant name -# wrong constant name annotate -# wrong constant name config -# wrong constant name cop_config -# wrong constant name cop_name -# wrong constant name initialize -# wrong constant name options -# wrong constant name urls -# wrong constant name -# wrong constant name style_guide_urls -# undefined method `define_method?1' for module `RuboCop::Cop::MethodComplexity' -# wrong constant name define_method?1 -# wrong constant name define_method? -# wrong constant name on_block -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::AbcSize::LITERAL_REGEX -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::BlockLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::BlockLength::MSG -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::BlockNesting::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# undefined method `class_definition?1' for class `RuboCop::Cop::Metrics::ClassLength' -# uninitialized constant RuboCop::Cop::Metrics::ClassLength::LITERAL_REGEX -# wrong constant name class_definition?1 -# wrong constant name class_definition? -# wrong constant name on_casgn -# wrong constant name on_class -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::CyclomaticComplexity::LITERAL_REGEX -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::MethodLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::MethodLength::MSG -# wrong constant name on_block -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `module_definition?1' for class `RuboCop::Cop::Metrics::ModuleLength' -# uninitialized constant RuboCop::Cop::Metrics::ModuleLength::LITERAL_REGEX -# wrong constant name module_definition?1 -# wrong constant name module_definition? -# wrong constant name on_casgn -# wrong constant name on_module -# wrong constant name -# undefined method `argument_to_lambda_or_proc?1' for class `RuboCop::Cop::Metrics::ParameterLists' -# uninitialized constant RuboCop::Cop::Metrics::ParameterLists::LITERAL_REGEX -# wrong constant name argument_to_lambda_or_proc?1 -# wrong constant name argument_to_lambda_or_proc? -# wrong constant name on_args -# wrong constant name -# uninitialized constant RuboCop::Cop::Metrics::PerceivedComplexity::LITERAL_REGEX -# wrong constant name -# wrong constant name -# wrong constant name calculate -# wrong constant name else_branch? -# wrong constant name evaluate_branch_nodes -# wrong constant name evaluate_condition_node -# wrong constant name initialize -# wrong constant name -# wrong constant name calculate -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Migration::DepartmentName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Migration::DepartmentName::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::MultilineLiteralBraceCorrector::BYTE_ORDER_MARK -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::AccessorMethodName::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::AsciiIdentifiers::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::AsciiIdentifiers::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# undefined method `op_method_candidate?1' for class `RuboCop::Cop::Naming::BinaryOperatorParameterName' -# uninitialized constant RuboCop::Cop::Naming::BinaryOperatorParameterName::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name op_method_candidate?1 -# wrong constant name op_method_candidate? -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::BlockParameterName::CASE_MSG -# uninitialized constant RuboCop::Cop::Naming::BlockParameterName::FORBIDDEN_MSG -# uninitialized constant RuboCop::Cop::Naming::BlockParameterName::LENGTH_MSG -# uninitialized constant RuboCop::Cop::Naming::BlockParameterName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::BlockParameterName::NUM_MSG -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::ClassAndModuleCamelCase::LITERAL_REGEX -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name -# undefined method `class_or_struct_return_method?1' for class `RuboCop::Cop::Naming::ConstantName' -# undefined method `literal_receiver?1' for class `RuboCop::Cop::Naming::ConstantName' -# uninitialized constant RuboCop::Cop::Naming::ConstantName::LITERAL_REGEX -# wrong constant name class_or_struct_return_method?1 -# wrong constant name class_or_struct_return_method? -# wrong constant name literal_receiver?1 -# wrong constant name literal_receiver? -# wrong constant name on_casgn -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::FileName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::FileName::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterCase::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterCase::OPENING_DELIMITER -# wrong constant name on_heredoc -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterNaming::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterNaming::OPENING_DELIMITER -# wrong constant name on_heredoc -# wrong constant name -# undefined method `memoized?1' for class `RuboCop::Cop::Naming::MemoizedInstanceVariableName' -# uninitialized constant RuboCop::Cop::Naming::MemoizedInstanceVariableName::LITERAL_REGEX -# wrong constant name memoized?1 -# wrong constant name memoized? -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `str_name1' for class `RuboCop::Cop::Naming::MethodName' -# undefined method `sym_name1' for class `RuboCop::Cop::Naming::MethodName' -# uninitialized constant RuboCop::Cop::Naming::MethodName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::MethodName::FORMATS -# uninitialized constant RuboCop::Cop::Naming::MethodName::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name str_name1 -# wrong constant name str_name -# wrong constant name sym_name1 -# wrong constant name sym_name -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::MethodParameterName::CASE_MSG -# uninitialized constant RuboCop::Cop::Naming::MethodParameterName::FORBIDDEN_MSG -# uninitialized constant RuboCop::Cop::Naming::MethodParameterName::LENGTH_MSG -# uninitialized constant RuboCop::Cop::Naming::MethodParameterName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::MethodParameterName::NUM_MSG -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `dynamic_method_define1' for class `RuboCop::Cop::Naming::PredicateName' -# uninitialized constant RuboCop::Cop::Naming::PredicateName::LITERAL_REGEX -# wrong constant name dynamic_method_define1 -# wrong constant name dynamic_method_define -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::RescuedExceptionsVariableName::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_resbody -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::VariableName::FORMATS -# uninitialized constant RuboCop::Cop::Naming::VariableName::LITERAL_REGEX -# wrong constant name on_arg -# wrong constant name on_blockarg -# wrong constant name on_cvasgn -# wrong constant name on_ivasgn -# wrong constant name on_kwarg -# wrong constant name on_kwoptarg -# wrong constant name on_kwrestarg -# wrong constant name on_lvar -# wrong constant name on_lvasgn -# wrong constant name on_optarg -# wrong constant name on_restarg -# wrong constant name -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::FORMATS -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::LITERAL_REGEX -# wrong constant name on_arg -# wrong constant name on_cvasgn -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name -# wrong constant name -# undefined method `empty_condition?1' for module `RuboCop::Cop::NegativeConditional' -# undefined method `single_negative?1' for module `RuboCop::Cop::NegativeConditional' -# wrong constant name empty_condition?1 -# wrong constant name empty_condition? -# wrong constant name single_negative?1 -# wrong constant name single_negative? -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Cop::Offense' -# wrong constant name <=> -# wrong constant name == -# wrong constant name column -# wrong constant name column_length -# wrong constant name column_range -# wrong constant name cop_name -# wrong constant name correctable? -# wrong constant name corrected? -# wrong constant name corrected_with_todo? -# wrong constant name disabled? -# wrong constant name eql? -# wrong constant name first_line -# wrong constant name highlighted_area -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name last_column -# wrong constant name last_line -# wrong constant name line -# wrong constant name location -# wrong constant name message -# wrong constant name real_column -# wrong constant name severity -# wrong constant name source_line -# wrong constant name status -# wrong constant name -# wrong constant name on_if -# wrong constant name -# wrong constant name -# wrong constant name comments_as_separators -# wrong constant name correct -# wrong constant name processed_source -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name investigate -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::PercentLiteral::BYTE_ORDER_MARK -# wrong constant name -# uninitialized constant RuboCop::Cop::PercentLiteralCorrector::LITERAL_REGEX -# wrong constant name config -# wrong constant name correct -# wrong constant name initialize -# wrong constant name preferred_delimiters -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `bind_with_call_method?1' for class `RuboCop::Cop::Performance::BindCall' -# uninitialized constant RuboCop::Cop::Performance::BindCall::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::BindCall::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name bind_with_call_method?1 -# wrong constant name bind_with_call_method? -# wrong constant name on_send -# wrong constant name -# undefined method `caller_with_scope_method?1' for class `RuboCop::Cop::Performance::Caller' -# undefined method `slow_caller?1' for class `RuboCop::Cop::Performance::Caller' -# uninitialized constant RuboCop::Cop::Performance::Caller::LITERAL_REGEX -# wrong constant name caller_with_scope_method?1 -# wrong constant name caller_with_scope_method? -# wrong constant name on_send -# wrong constant name slow_caller?1 -# wrong constant name slow_caller? -# wrong constant name -# uninitialized constant RuboCop::Cop::Performance::CaseWhenSplat::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::CaseWhenSplat::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::CaseWhenSplat::SPACE -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name -# undefined method `downcase_downcase1' for class `RuboCop::Cop::Performance::Casecmp' -# undefined method `downcase_eq1' for class `RuboCop::Cop::Performance::Casecmp' -# undefined method `eq_downcase1' for class `RuboCop::Cop::Performance::Casecmp' -# uninitialized constant RuboCop::Cop::Performance::Casecmp::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name downcase_downcase1 -# wrong constant name downcase_downcase -# wrong constant name downcase_eq1 -# wrong constant name downcase_eq -# wrong constant name eq_downcase1 -# wrong constant name eq_downcase -# wrong constant name on_send -# wrong constant name -# undefined method `flat_map_candidate?1' for class `RuboCop::Cop::Performance::ChainArrayAllocation' -# uninitialized constant RuboCop::Cop::Performance::ChainArrayAllocation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ChainArrayAllocation::LITERAL_REGEX -# wrong constant name flat_map_candidate?1 -# wrong constant name flat_map_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `compare?1' for class `RuboCop::Cop::Performance::CompareWithBlock' -# undefined method `replaceable_body?1' for class `RuboCop::Cop::Performance::CompareWithBlock' -# uninitialized constant RuboCop::Cop::Performance::CompareWithBlock::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::CompareWithBlock::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name compare?1 -# wrong constant name compare? -# wrong constant name on_block -# wrong constant name replaceable_body?1 -# wrong constant name replaceable_body? -# wrong constant name -# undefined method `count_candidate?1' for class `RuboCop::Cop::Performance::Count' -# uninitialized constant RuboCop::Cop::Performance::Count::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::Count::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name count_candidate?1 -# wrong constant name count_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `delete_prefix_candidate?1' for class `RuboCop::Cop::Performance::DeletePrefix' -# uninitialized constant RuboCop::Cop::Performance::DeletePrefix::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name delete_prefix_candidate?1 -# wrong constant name delete_prefix_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `delete_suffix_candidate?1' for class `RuboCop::Cop::Performance::DeleteSuffix' -# uninitialized constant RuboCop::Cop::Performance::DeleteSuffix::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name delete_suffix_candidate?1 -# wrong constant name delete_suffix_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `detect_candidate?1' for class `RuboCop::Cop::Performance::Detect' -# uninitialized constant RuboCop::Cop::Performance::Detect::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name detect_candidate?1 -# wrong constant name detect_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `check_with_active_support_aliases1' for class `RuboCop::Cop::Performance::DoubleStartEndWith' -# undefined method `two_start_end_with_calls1' for class `RuboCop::Cop::Performance::DoubleStartEndWith' -# uninitialized constant RuboCop::Cop::Performance::DoubleStartEndWith::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check_with_active_support_aliases1 -# wrong constant name check_with_active_support_aliases -# wrong constant name on_or -# wrong constant name two_start_end_with_calls1 -# wrong constant name two_start_end_with_calls -# wrong constant name -# undefined method `redundant_regex?1' for class `RuboCop::Cop::Performance::EndWith' -# uninitialized constant RuboCop::Cop::Performance::EndWith::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_match_with_lvasgn -# wrong constant name on_send -# wrong constant name redundant_regex?1 -# wrong constant name redundant_regex? -# wrong constant name -# undefined method `counter1' for class `RuboCop::Cop::Performance::FixedSize' -# uninitialized constant RuboCop::Cop::Performance::FixedSize::LITERAL_REGEX -# wrong constant name counter1 -# wrong constant name counter -# wrong constant name on_send -# wrong constant name -# undefined method `flat_map_candidate?1' for class `RuboCop::Cop::Performance::FlatMap' -# uninitialized constant RuboCop::Cop::Performance::FlatMap::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::FlatMap::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name flat_map_candidate?1 -# wrong constant name flat_map_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `inefficient_include?1' for class `RuboCop::Cop::Performance::InefficientHashSearch' -# uninitialized constant RuboCop::Cop::Performance::InefficientHashSearch::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name inefficient_include?1 -# wrong constant name inefficient_include? -# wrong constant name on_send -# wrong constant name -# undefined method `open_struct1' for class `RuboCop::Cop::Performance::OpenStruct' -# uninitialized constant RuboCop::Cop::Performance::OpenStruct::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name open_struct1 -# wrong constant name open_struct -# wrong constant name -# undefined method `range_include1' for class `RuboCop::Cop::Performance::RangeInclude' -# uninitialized constant RuboCop::Cop::Performance::RangeInclude::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name range_include1 -# wrong constant name range_include -# wrong constant name -# undefined method `blockarg_def1' for class `RuboCop::Cop::Performance::RedundantBlockCall' -# uninitialized constant RuboCop::Cop::Performance::RedundantBlockCall::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name blockarg_assigned? -# wrong constant name blockarg_calls -# wrong constant name blockarg_def1 -# wrong constant name blockarg_def -# wrong constant name on_def -# wrong constant name -# undefined method `match_call?1' for class `RuboCop::Cop::Performance::RedundantMatch' -# undefined method `only_truthiness_matters?1' for class `RuboCop::Cop::Performance::RedundantMatch' -# uninitialized constant RuboCop::Cop::Performance::RedundantMatch::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name match_call?1 -# wrong constant name match_call? -# wrong constant name on_send -# wrong constant name only_truthiness_matters?1 -# wrong constant name only_truthiness_matters? -# wrong constant name -# undefined method `modifier_flow_control?1' for class `RuboCop::Cop::Performance::RedundantMerge' -# undefined method `redundant_merge_candidate1' for class `RuboCop::Cop::Performance::RedundantMerge' -# wrong constant name -# uninitialized constant RuboCop::Cop::Performance::RedundantMerge::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name modifier_flow_control?1 -# wrong constant name modifier_flow_control? -# wrong constant name on_send -# wrong constant name redundant_merge_candidate1 -# wrong constant name redundant_merge_candidate -# undefined method `each_with_object_node1' for class `#' -# wrong constant name each_with_object_node1 -# wrong constant name each_with_object_node -# wrong constant name initialize -# wrong constant name value_used? -# wrong constant name -# wrong constant name -# undefined method `match_method?1' for class `RuboCop::Cop::Performance::RegexpMatch' -# undefined method `match_node?1' for class `RuboCop::Cop::Performance::RegexpMatch' -# undefined method `match_operator?1' for class `RuboCop::Cop::Performance::RegexpMatch' -# undefined method `match_threequals?1' for class `RuboCop::Cop::Performance::RegexpMatch' -# undefined method `match_with_int_arg_method?1' for class `RuboCop::Cop::Performance::RegexpMatch' -# uninitialized constant RuboCop::Cop::Performance::RegexpMatch::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name last_matches -# wrong constant name match_method?1 -# wrong constant name match_method? -# wrong constant name match_node?1 -# wrong constant name match_node? -# wrong constant name match_operator?1 -# wrong constant name match_operator? -# wrong constant name match_threequals?1 -# wrong constant name match_threequals? -# wrong constant name match_with_int_arg_method?1 -# wrong constant name match_with_int_arg_method? -# wrong constant name match_with_lvasgn? -# wrong constant name on_case -# wrong constant name on_if -# wrong constant name search_match_nodes -# wrong constant name -# undefined method `reverse_each?1' for class `RuboCop::Cop::Performance::ReverseEach' -# uninitialized constant RuboCop::Cop::Performance::ReverseEach::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ReverseEach::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name reverse_each?1 -# wrong constant name reverse_each? -# wrong constant name -# uninitialized constant RuboCop::Cop::Performance::Size::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# undefined method `redundant_regex?1' for class `RuboCop::Cop::Performance::StartWith' -# uninitialized constant RuboCop::Cop::Performance::StartWith::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_match_with_lvasgn -# wrong constant name on_send -# wrong constant name redundant_regex?1 -# wrong constant name redundant_regex? -# wrong constant name -# undefined method `string_replacement?1' for class `RuboCop::Cop::Performance::StringReplacement' -# uninitialized constant RuboCop::Cop::Performance::StringReplacement::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::StringReplacement::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name replace_method -# wrong constant name string_replacement?1 -# wrong constant name string_replacement? -# wrong constant name -# undefined method `times_map_call1' for class `RuboCop::Cop::Performance::TimesMap' -# uninitialized constant RuboCop::Cop::Performance::TimesMap::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name times_map_call1 -# wrong constant name times_map_call -# wrong constant name -# undefined method `dup_string?1' for class `RuboCop::Cop::Performance::UnfreezeString' -# undefined method `string_new?1' for class `RuboCop::Cop::Performance::UnfreezeString' -# uninitialized constant RuboCop::Cop::Performance::UnfreezeString::LITERAL_REGEX -# wrong constant name dup_string?1 -# wrong constant name dup_string? -# wrong constant name on_send -# wrong constant name string_new?1 -# wrong constant name string_new? -# wrong constant name -# undefined method `uri_parser_new?1' for class `RuboCop::Cop::Performance::UriDefaultParser' -# uninitialized constant RuboCop::Cop::Performance::UriDefaultParser::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name uri_parser_new?1 -# wrong constant name uri_parser_new? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name config -# wrong constant name delimiters -# wrong constant name initialize -# wrong constant name type -# wrong constant name -# wrong constant name -# wrong constant name add_space -# wrong constant name remove_space -# wrong constant name swap_comma -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::ALL -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::RSPEC -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::ALL -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::RSPEC -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `disallowed_stub1' for class `RuboCop::Cop::RSpec::AnyInstance' -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::ALL -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::RSPEC -# wrong constant name disallowed_stub1 -# wrong constant name disallowed_stub -# wrong constant name on_send -# wrong constant name -# undefined method `hook1' for class `RuboCop::Cop::RSpec::AroundBlock' -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::ALL -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::RSPEC -# wrong constant name find_arg_usage -# wrong constant name hook1 -# wrong constant name hook -# wrong constant name on_block -# wrong constant name -# undefined method `be_without_args1' for class `RuboCop::Cop::RSpec::Be' -# uninitialized constant RuboCop::Cop::RSpec::Be::ALL -# uninitialized constant RuboCop::Cop::RSpec::Be::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Be::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Be::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Be::RSPEC -# wrong constant name be_without_args1 -# wrong constant name be_without_args -# wrong constant name on_send -# wrong constant name -# undefined method `eql_type_with_identity1' for class `RuboCop::Cop::RSpec::BeEql' -# uninitialized constant RuboCop::Cop::RSpec::BeEql::ALL -# uninitialized constant RuboCop::Cop::RSpec::BeEql::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::BeEql::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::BeEql::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::BeEql::RSPEC -# wrong constant name autocorrect -# wrong constant name eql_type_with_identity1 -# wrong constant name eql_type_with_identity -# wrong constant name on_send -# wrong constant name -# undefined method `before_or_after_all1' for class `RuboCop::Cop::RSpec::BeforeAfterAll' -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::ALL -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::RSPEC -# wrong constant name before_or_after_all1 -# wrong constant name before_or_after_all -# wrong constant name on_send -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `as_is_matcher1' for class `RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation' -# undefined method `expectation_set_on_current_path1' for class `RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation' -# undefined method `regexp_str_matcher1' for class `RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation' -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::ALL -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::RSPEC -# wrong constant name as_is_matcher1 -# wrong constant name as_is_matcher -# wrong constant name autocorrect -# wrong constant name expectation_set_on_current_path1 -# wrong constant name expectation_set_on_current_path -# wrong constant name on_send -# wrong constant name regexp_str_matcher1 -# wrong constant name regexp_str_matcher -# wrong constant name -# undefined method `feature_method1' for class `RuboCop::Cop::RSpec::Capybara::FeatureMethods' -# undefined method `spec?1' for class `RuboCop::Cop::RSpec::Capybara::FeatureMethods' -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::ALL -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::RSPEC -# wrong constant name autocorrect -# wrong constant name feature_method1 -# wrong constant name feature_method -# wrong constant name on_block -# wrong constant name spec?1 -# wrong constant name spec? -# wrong constant name -# undefined method `visible_false?1' for class `RuboCop::Cop::RSpec::Capybara::VisibilityMatcher' -# undefined method `visible_true?1' for class `RuboCop::Cop::RSpec::Capybara::VisibilityMatcher' -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::ALL -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::RSPEC -# wrong constant name on_send -# wrong constant name visible_false?1 -# wrong constant name visible_false? -# wrong constant name visible_true?1 -# wrong constant name visible_true? -# wrong constant name -# wrong constant name -# undefined method `context_method1' for class `RuboCop::Cop::RSpec::ContextMethod' -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::ALL -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::RSPEC -# wrong constant name autocorrect -# wrong constant name context_method1 -# wrong constant name context_method -# wrong constant name on_block -# wrong constant name -# undefined method `context_wording1' for class `RuboCop::Cop::RSpec::ContextWording' -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::ALL -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::RSPEC -# wrong constant name context_wording1 -# wrong constant name context_wording -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::Cop::ALL -# uninitialized constant RuboCop::Cop::RSpec::Cop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Cop::RSPEC -# wrong constant name -# undefined method `describe_with_rails_metadata?1' for class `RuboCop::Cop::RSpec::DescribeClass' -# undefined method `rails_metadata?1' for class `RuboCop::Cop::RSpec::DescribeClass' -# undefined method `shared_group?1' for class `RuboCop::Cop::RSpec::DescribeClass' -# undefined method `valid_describe?1' for class `RuboCop::Cop::RSpec::DescribeClass' -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::ALL -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::RSPEC -# wrong constant name describe_with_rails_metadata?1 -# wrong constant name describe_with_rails_metadata? -# wrong constant name on_top_level_describe -# wrong constant name rails_metadata?1 -# wrong constant name rails_metadata? -# wrong constant name shared_group?1 -# wrong constant name shared_group? -# wrong constant name valid_describe?1 -# wrong constant name valid_describe? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::ALL -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::RSPEC -# wrong constant name on_top_level_describe -# wrong constant name -# undefined method `describe_symbol?1' for class `RuboCop::Cop::RSpec::DescribeSymbol' -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::ALL -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::RSPEC -# wrong constant name describe_symbol?1 -# wrong constant name describe_symbol? -# wrong constant name on_send -# wrong constant name -# undefined method `common_instance_exec_closure?1' for class `RuboCop::Cop::RSpec::DescribedClass' -# undefined method `described_constant1' for class `RuboCop::Cop::RSpec::DescribedClass' -# undefined method `rspec_block?1' for class `RuboCop::Cop::RSpec::DescribedClass' -# undefined method `scope_changing_syntax?1' for class `RuboCop::Cop::RSpec::DescribedClass' -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::ALL -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::RSPEC -# wrong constant name autocorrect -# wrong constant name common_instance_exec_closure?1 -# wrong constant name common_instance_exec_closure? -# wrong constant name contains_described_class? -# wrong constant name described_constant1 -# wrong constant name described_constant -# wrong constant name on_block -# wrong constant name rspec_block?1 -# wrong constant name rspec_block? -# wrong constant name scope_changing_syntax?1 -# wrong constant name scope_changing_syntax? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::ALL -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::RSPEC -# wrong constant name find_rspec_blocks -# wrong constant name on_module -# wrong constant name -# undefined method `rspec_method?1' for class `RuboCop::Cop::RSpec::Dialect' -# uninitialized constant RuboCop::Cop::RSpec::Dialect::ALL -# uninitialized constant RuboCop::Cop::RSpec::Dialect::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Dialect::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Dialect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Dialect::RSPEC -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name rspec_method?1 -# wrong constant name rspec_method? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::RSPEC -# wrong constant name contains_example? -# wrong constant name on_block -# wrong constant name -# undefined method `empty_hook?1' for class `RuboCop::Cop::RSpec::EmptyHook' -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::RSPEC -# wrong constant name autocorrect -# wrong constant name empty_hook?1 -# wrong constant name empty_hook? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::RSPEC -# wrong constant name allow_consecutive_one_liners? -# wrong constant name allowed_one_liner? -# wrong constant name consecutive_one_liner? -# wrong constant name next_one_line_example? -# wrong constant name next_sibling -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::ALL -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::RSPEC -# wrong constant name on_block -# wrong constant name -# undefined method `example_description1' for class `RuboCop::Cop::RSpec::ExampleWithoutDescription' -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::RSPEC -# wrong constant name example_description1 -# wrong constant name example_description -# wrong constant name on_block -# wrong constant name -# undefined method `it_description1' for class `RuboCop::Cop::RSpec::ExampleWording' -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::RSPEC -# wrong constant name autocorrect -# wrong constant name it_description1 -# wrong constant name it_description -# wrong constant name on_block -# wrong constant name -# undefined method `expect_literal1' for class `RuboCop::Cop::RSpec::ExpectActual' -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::RSPEC -# wrong constant name autocorrect -# wrong constant name expect_literal1 -# wrong constant name expect_literal -# wrong constant name on_send -# wrong constant name -# undefined method `expect_change_with_arguments1' for class `RuboCop::Cop::RSpec::ExpectChange' -# undefined method `expect_change_with_block1' for class `RuboCop::Cop::RSpec::ExpectChange' -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::RSPEC -# wrong constant name autocorrect -# wrong constant name expect_change_with_arguments1 -# wrong constant name expect_change_with_arguments -# wrong constant name expect_change_with_block1 -# wrong constant name expect_change_with_block -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::RSPEC -# wrong constant name expectation -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::RSPEC -# wrong constant name on_gvasgn -# wrong constant name -# undefined method `predicate_matcher?1' for module `RuboCop::Cop::RSpec::ExplicitHelper' -# undefined method `predicate_matcher_block?1' for module `RuboCop::Cop::RSpec::ExplicitHelper' -# uninitialized constant RuboCop::Cop::RSpec::ExplicitHelper::ALL -# uninitialized constant RuboCop::Cop::RSpec::ExplicitHelper::RSPEC -# wrong constant name predicate_matcher?1 -# wrong constant name predicate_matcher? -# wrong constant name predicate_matcher_block?1 -# wrong constant name predicate_matcher_block? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `association?1' for class `RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically' -# undefined method `value_matcher1' for class `RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically' -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::ALL -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::RSPEC -# wrong constant name association?1 -# wrong constant name association? -# wrong constant name autocorrect -# wrong constant name factory_attributes -# wrong constant name on_block -# wrong constant name value_matcher1 -# wrong constant name value_matcher -# wrong constant name -# undefined method `factory_call1' for class `RuboCop::Cop::RSpec::FactoryBot::CreateList' -# undefined method `factory_list_call1' for class `RuboCop::Cop::RSpec::FactoryBot::CreateList' -# undefined method `n_times_block_without_arg?1' for class `RuboCop::Cop::RSpec::FactoryBot::CreateList' -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::ALL -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::RSPEC -# wrong constant name -# wrong constant name autocorrect -# wrong constant name factory_call1 -# wrong constant name factory_call -# wrong constant name factory_list_call1 -# wrong constant name factory_list_call -# wrong constant name n_times_block_without_arg?1 -# wrong constant name n_times_block_without_arg? -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# undefined method `class_name1' for class `RuboCop::Cop::RSpec::FactoryBot::FactoryClassName' -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::ALL -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::RSPEC -# wrong constant name autocorrect -# wrong constant name class_name1 -# wrong constant name class_name -# wrong constant name on_send -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::FilePath::ALL -# uninitialized constant RuboCop::Cop::RSpec::FilePath::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::FilePath::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::FilePath::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FilePath::RSPEC -# wrong constant name const_described? -# wrong constant name on_top_level_describe -# wrong constant name routing_metadata? -# wrong constant name -# undefined method `focused_block?1' for class `RuboCop::Cop::RSpec::Focus' -# undefined method `metadata1' for class `RuboCop::Cop::RSpec::Focus' -# uninitialized constant RuboCop::Cop::RSpec::Focus::ALL -# uninitialized constant RuboCop::Cop::RSpec::Focus::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Focus::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Focus::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Focus::RSPEC -# wrong constant name focused_block?1 -# wrong constant name focused_block? -# wrong constant name metadata1 -# wrong constant name metadata -# wrong constant name on_send -# wrong constant name -# undefined method `scoped_hook1' for class `RuboCop::Cop::RSpec::HookArgument' -# undefined method `unscoped_hook1' for class `RuboCop::Cop::RSpec::HookArgument' -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::ALL -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::RSPEC -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name scoped_hook1 -# wrong constant name scoped_hook -# wrong constant name unscoped_hook1 -# wrong constant name unscoped_hook -# wrong constant name -# undefined method `example_or_group?1' for class `RuboCop::Cop::RSpec::HooksBeforeExamples' -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::ALL -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::RSPEC -# wrong constant name autocorrect -# wrong constant name example_or_group?1 -# wrong constant name example_or_group? -# wrong constant name on_block -# wrong constant name -# undefined method `implicit_expect1' for class `RuboCop::Cop::RSpec::ImplicitBlockExpectation' -# undefined method `lambda?1' for class `RuboCop::Cop::RSpec::ImplicitBlockExpectation' -# undefined method `lambda_subject?1' for class `RuboCop::Cop::RSpec::ImplicitBlockExpectation' -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::ALL -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::RSPEC -# wrong constant name implicit_expect1 -# wrong constant name implicit_expect -# wrong constant name lambda?1 -# wrong constant name lambda? -# wrong constant name lambda_subject?1 -# wrong constant name lambda_subject? -# wrong constant name on_send -# wrong constant name -# undefined method `implicit_expect1' for class `RuboCop::Cop::RSpec::ImplicitExpect' -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::ALL -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::RSPEC -# wrong constant name autocorrect -# wrong constant name implicit_expect1 -# wrong constant name implicit_expect -# wrong constant name on_send -# wrong constant name -# undefined method `implicit_subject?1' for class `RuboCop::Cop::RSpec::ImplicitSubject' -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::ALL -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::RSPEC -# wrong constant name autocorrect -# wrong constant name implicit_subject?1 -# wrong constant name implicit_subject? -# wrong constant name on_send -# wrong constant name -# undefined method `be_bool?1' for module `RuboCop::Cop::RSpec::InflectedHelper' -# undefined method `be_boolthy?1' for module `RuboCop::Cop::RSpec::InflectedHelper' -# undefined method `predicate_in_actual?1' for module `RuboCop::Cop::RSpec::InflectedHelper' -# uninitialized constant RuboCop::Cop::RSpec::InflectedHelper::ALL -# uninitialized constant RuboCop::Cop::RSpec::InflectedHelper::RSPEC -# wrong constant name be_bool?1 -# wrong constant name be_bool? -# wrong constant name be_boolthy?1 -# wrong constant name be_boolthy? -# wrong constant name predicate_in_actual?1 -# wrong constant name predicate_in_actual? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::ALL -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::RSPEC -# wrong constant name autocorrect -# wrong constant name have_received_usage -# wrong constant name null_double -# wrong constant name on_block -# wrong constant name -# undefined method `custom_matcher?1' for class `RuboCop::Cop::RSpec::InstanceVariable' -# undefined method `dynamic_class?1' for class `RuboCop::Cop::RSpec::InstanceVariable' -# undefined method `spec_group?1' for class `RuboCop::Cop::RSpec::InstanceVariable' -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::ALL -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::RSPEC -# wrong constant name custom_matcher?1 -# wrong constant name custom_matcher? -# wrong constant name dynamic_class?1 -# wrong constant name dynamic_class? -# wrong constant name ivar_assigned? -# wrong constant name ivar_usage -# wrong constant name on_block -# wrong constant name spec_group?1 -# wrong constant name spec_group? -# wrong constant name -# undefined method `invalid_predicate_matcher?1' for class `RuboCop::Cop::RSpec::InvalidPredicateMatcher' -# uninitialized constant RuboCop::Cop::RSpec::InvalidPredicateMatcher::ALL -# uninitialized constant RuboCop::Cop::RSpec::InvalidPredicateMatcher::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::InvalidPredicateMatcher::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::InvalidPredicateMatcher::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InvalidPredicateMatcher::RSPEC -# wrong constant name invalid_predicate_matcher?1 -# wrong constant name invalid_predicate_matcher? -# wrong constant name on_send -# wrong constant name -# undefined method `example_inclusion_offense1' for class `RuboCop::Cop::RSpec::ItBehavesLike' -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::ALL -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::RSPEC -# wrong constant name autocorrect -# wrong constant name example_inclusion_offense1 -# wrong constant name example_inclusion_offense -# wrong constant name on_send -# wrong constant name -# undefined method `each?1' for class `RuboCop::Cop::RSpec::IteratedExpectation' -# undefined method `expectation?1' for class `RuboCop::Cop::RSpec::IteratedExpectation' -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::ALL -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::RSPEC -# wrong constant name each?1 -# wrong constant name each? -# wrong constant name expectation?1 -# wrong constant name expectation? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::ALL -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::RSPEC -# wrong constant name autocorrect -# wrong constant name check_previous_nodes -# wrong constant name on_block -# wrong constant name -# undefined method `in_example_or_shared_group?1' for class `RuboCop::Cop::RSpec::LeakyConstantDeclaration' -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::ALL -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::RSPEC -# wrong constant name in_example_or_shared_group?1 -# wrong constant name in_example_or_shared_group? -# wrong constant name on_casgn -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name -# undefined method `example_or_group?1' for class `RuboCop::Cop::RSpec::LetBeforeExamples' -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::ALL -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::RSPEC -# wrong constant name autocorrect -# wrong constant name example_or_group?1 -# wrong constant name example_or_group? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::ALL -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::RSPEC -# wrong constant name let_bang -# wrong constant name method_called? -# wrong constant name on_block -# wrong constant name -# undefined method `message_chain1' for class `RuboCop::Cop::RSpec::MessageChain' -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::ALL -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::RSPEC -# wrong constant name message -# wrong constant name message_chain1 -# wrong constant name message_chain -# wrong constant name on_send -# wrong constant name -# undefined method `message_expectation1' for class `RuboCop::Cop::RSpec::MessageExpectation' -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::ALL -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::RSPEC -# wrong constant name message_expectation1 -# wrong constant name message_expectation -# wrong constant name on_send -# wrong constant name receive_message? -# wrong constant name -# undefined method `message_expectation1' for class `RuboCop::Cop::RSpec::MessageSpies' -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::ALL -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::RSPEC -# wrong constant name message_expectation1 -# wrong constant name message_expectation -# wrong constant name on_send -# wrong constant name receive_message -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::ALL -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::ALL -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::RSPEC -# wrong constant name on_top_level_describe -# wrong constant name -# undefined method `aggregate_failures?1' for class `RuboCop::Cop::RSpec::MultipleExpectations' -# undefined method `aggregate_failures_block?1' for class `RuboCop::Cop::RSpec::MultipleExpectations' -# undefined method `aggregate_failures_present?1' for class `RuboCop::Cop::RSpec::MultipleExpectations' -# undefined method `expect?1' for class `RuboCop::Cop::RSpec::MultipleExpectations' -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::ALL -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::RSPEC -# wrong constant name aggregate_failures?1 -# wrong constant name aggregate_failures? -# wrong constant name aggregate_failures_block?1 -# wrong constant name aggregate_failures_block? -# wrong constant name aggregate_failures_present?1 -# wrong constant name aggregate_failures_present? -# wrong constant name expect?1 -# wrong constant name expect? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::ALL -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::RSPEC -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# undefined method `rspec_block?1' for class `RuboCop::Cop::RSpec::NamedSubject' -# undefined method `shared_example?1' for class `RuboCop::Cop::RSpec::NamedSubject' -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::ALL -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::RSPEC -# wrong constant name ignored_shared_example? -# wrong constant name on_block -# wrong constant name rspec_block?1 -# wrong constant name rspec_block? -# wrong constant name shared_example?1 -# wrong constant name shared_example? -# wrong constant name subject_usage -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::ALL -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::RSPEC -# wrong constant name find_contexts -# wrong constant name on_top_level_describe -# wrong constant name -# undefined method `not_to_not_offense1' for class `RuboCop::Cop::RSpec::NotToNot' -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::ALL -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::RSPEC -# wrong constant name autocorrect -# wrong constant name not_to_not_offense1 -# wrong constant name not_to_not_offense -# wrong constant name on_send -# wrong constant name -# undefined method `first_argument_name1' for class `RuboCop::Cop::RSpec::OverwritingSetup' -# undefined method `setup?1' for class `RuboCop::Cop::RSpec::OverwritingSetup' -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::ALL -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::RSPEC -# wrong constant name first_argument_name1 -# wrong constant name first_argument_name -# wrong constant name on_block -# wrong constant name setup?1 -# wrong constant name setup? -# wrong constant name -# undefined method `pending_block?1' for class `RuboCop::Cop::RSpec::Pending' -# undefined method `skip_or_pending?1' for class `RuboCop::Cop::RSpec::Pending' -# undefined method `skippable?1' for class `RuboCop::Cop::RSpec::Pending' -# undefined method `skipped_in_metadata?1' for class `RuboCop::Cop::RSpec::Pending' -# uninitialized constant RuboCop::Cop::RSpec::Pending::ALL -# uninitialized constant RuboCop::Cop::RSpec::Pending::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Pending::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Pending::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Pending::RSPEC -# wrong constant name on_send -# wrong constant name pending_block?1 -# wrong constant name pending_block? -# wrong constant name skip_or_pending?1 -# wrong constant name skip_or_pending? -# wrong constant name skippable?1 -# wrong constant name skippable? -# wrong constant name skipped_in_metadata?1 -# wrong constant name skipped_in_metadata? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::ALL -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::BUILT_IN_MATCHERS -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::MSG_EXPLICIT -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::MSG_INFLECTED -# uninitialized constant RuboCop::Cop::RSpec::PredicateMatcher::RSPEC -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# undefined method `receive_counts1' for class `RuboCop::Cop::RSpec::ReceiveCounts' -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::ALL -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::RSPEC -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name receive_counts1 -# wrong constant name receive_counts -# wrong constant name stub? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::ALL -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::RSPEC -# wrong constant name autocorrect -# wrong constant name method_on_stub? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::ALL -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::RSPEC -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::ALL -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::RSPEC -# wrong constant name on_block -# wrong constant name -# undefined method `body1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupBody' -# undefined method `const_arg1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupBody' -# undefined method `metadata1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupBody' -# undefined method `several_example_groups?1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupBody' -# undefined method `skip_or_pending?1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupBody' -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::ALL -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::RSPEC -# wrong constant name body1 -# wrong constant name body -# wrong constant name const_arg1 -# wrong constant name const_arg -# wrong constant name metadata1 -# wrong constant name metadata -# wrong constant name on_begin -# wrong constant name several_example_groups?1 -# wrong constant name several_example_groups? -# wrong constant name skip_or_pending?1 -# wrong constant name skip_or_pending? -# wrong constant name -# undefined method `doc_string_and_metadata1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupDescription' -# undefined method `empty_description?1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupDescription' -# undefined method `several_example_groups?1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupDescription' -# undefined method `skip_or_pending?1' for class `RuboCop::Cop::RSpec::RepeatedExampleGroupDescription' -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::ALL -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::RSPEC -# wrong constant name doc_string_and_metadata1 -# wrong constant name doc_string_and_metadata -# wrong constant name empty_description?1 -# wrong constant name empty_description? -# wrong constant name on_begin -# wrong constant name several_example_groups?1 -# wrong constant name several_example_groups? -# wrong constant name skip_or_pending?1 -# wrong constant name skip_or_pending? -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::ALL -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::RSPEC -# wrong constant name and_return_value -# wrong constant name autocorrect -# wrong constant name contains_stub? -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name call -# wrong constant name initialize -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::ALL -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::RSPEC -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::ALL -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::RSPEC -# wrong constant name lines_msg -# wrong constant name on_block -# wrong constant name repeated_hooks -# wrong constant name -# undefined method `shared_context1' for class `RuboCop::Cop::RSpec::SharedContext' -# undefined method `shared_example1' for class `RuboCop::Cop::RSpec::SharedContext' -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::ALL -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::RSPEC -# wrong constant name autocorrect -# wrong constant name context? -# wrong constant name examples? -# wrong constant name on_block -# wrong constant name shared_context1 -# wrong constant name shared_context -# wrong constant name shared_example1 -# wrong constant name shared_example -# wrong constant name -# undefined method `shared_examples1' for class `RuboCop::Cop::RSpec::SharedExamples' -# uninitialized constant RuboCop::Cop::RSpec::SharedExamples::ALL -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::SharedExamples::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::SharedExamples::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::SharedExamples::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SharedExamples::RSPEC -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name shared_examples1 -# wrong constant name shared_examples -# wrong constant name initialize -# wrong constant name message -# wrong constant name node -# wrong constant name preferred_style -# wrong constant name -# wrong constant name -# undefined method `message_chain1' for class `RuboCop::Cop::RSpec::SingleArgumentMessageChain' -# undefined method `single_key_hash?1' for class `RuboCop::Cop::RSpec::SingleArgumentMessageChain' -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::ALL -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::RSPEC -# wrong constant name autocorrect -# wrong constant name message_chain1 -# wrong constant name message_chain -# wrong constant name on_send -# wrong constant name single_key_hash?1 -# wrong constant name single_key_hash? -# wrong constant name -# undefined method `message_expectation?1' for class `RuboCop::Cop::RSpec::SubjectStub' -# undefined method `subject1' for class `RuboCop::Cop::RSpec::SubjectStub' -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::ALL -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::RSPEC -# wrong constant name message_expectation?1 -# wrong constant name message_expectation? -# wrong constant name message_expectation_matcher? -# wrong constant name on_block -# wrong constant name subject1 -# wrong constant name subject -# wrong constant name -# undefined method `empty_raise_error_or_exception1' for class `RuboCop::Cop::RSpec::UnspecifiedException' -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::ALL -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::RSPEC -# wrong constant name block_with_args? -# wrong constant name empty_exception_matcher? -# wrong constant name empty_raise_error_or_exception1 -# wrong constant name empty_raise_error_or_exception -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::ALL -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::RSPEC -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::RSpec::VariableName::ALL -# uninitialized constant RuboCop::Cop::RSpec::VariableName::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::VariableName::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::VariableName::FORMATS -# uninitialized constant RuboCop::Cop::RSpec::VariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VariableName::RSPEC -# wrong constant name on_send -# wrong constant name -# undefined method `unverified_double1' for class `RuboCop::Cop::RSpec::VerifiedDoubles' -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::ALL -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::RSPEC -# wrong constant name on_send -# wrong constant name unverified_double1 -# wrong constant name unverified_double -# wrong constant name -# undefined method `expect?1' for class `RuboCop::Cop::RSpec::VoidExpect' -# undefined method `expect_block?1' for class `RuboCop::Cop::RSpec::VoidExpect' -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::ALL -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::RSPEC -# wrong constant name expect?1 -# wrong constant name expect? -# wrong constant name expect_block?1 -# wrong constant name expect_block? -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# undefined method `block_arg1' for class `RuboCop::Cop::RSpec::Yield' -# undefined method `block_call?1' for class `RuboCop::Cop::RSpec::Yield' -# uninitialized constant RuboCop::Cop::RSpec::Yield::ALL -# uninitialized constant RuboCop::Cop::RSpec::Yield::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::Yield::DEFAULT_CONFIGURATION -# uninitialized constant RuboCop::Cop::RSpec::Yield::DEFAULT_PATTERN_RE -# uninitialized constant RuboCop::Cop::RSpec::Yield::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Yield::RSPEC -# wrong constant name autocorrect -# wrong constant name block_arg1 -# wrong constant name block_arg -# wrong constant name block_call?1 -# wrong constant name block_call? -# wrong constant name method_on_stub? -# wrong constant name on_block -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `rational_literal?1' for module `RuboCop::Cop::RationalLiteral' -# wrong constant name rational_literal?1 -# wrong constant name rational_literal? -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `enabled1' for class `RuboCop::Cop::Registry' -# undefined method `enabled2' for class `RuboCop::Cop::Registry' -# undefined method `initialize1' for class `RuboCop::Cop::Registry' -# undefined method `initialize2' for class `RuboCop::Cop::Registry' -# undefined method `qualified_cop_name1' for class `RuboCop::Cop::Registry' -# wrong constant name == -# uninitialized constant RuboCop::Cop::Registry::Elem -# wrong constant name contains_cop_matching? -# wrong constant name cops -# wrong constant name department_missing? -# wrong constant name departments -# wrong constant name dismiss -# wrong constant name each -# wrong constant name enabled1 -# wrong constant name enabled2 -# wrong constant name enabled -# wrong constant name enabled? -# wrong constant name enabled_pending_cop? -# wrong constant name enlist -# wrong constant name find_by_cop_name -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name length -# wrong constant name names -# wrong constant name options -# wrong constant name print_warning -# wrong constant name qualified_cop_name1 -# wrong constant name qualified_cop_name -# wrong constant name select -# wrong constant name sort! -# wrong constant name to_h -# wrong constant name unqualified_cop_names -# wrong constant name with_department -# wrong constant name without_department -# undefined singleton method `with_temporary_global1' for `RuboCop::Cop::Registry' -# wrong constant name -# wrong constant name all -# wrong constant name global -# wrong constant name qualified_cop_name -# wrong constant name with_temporary_global1 -# wrong constant name with_temporary_global -# wrong constant name investigate -# wrong constant name -# undefined method `empty_condition?1' for module `RuboCop::Cop::SafeAssignment' -# undefined method `safe_assignment?1' for module `RuboCop::Cop::SafeAssignment' -# undefined method `setter_method?1' for module `RuboCop::Cop::SafeAssignment' -# wrong constant name empty_condition?1 -# wrong constant name empty_condition? -# wrong constant name safe_assignment?1 -# wrong constant name safe_assignment? -# wrong constant name setter_method?1 -# wrong constant name setter_method? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `eval?1' for class `RuboCop::Cop::Security::Eval' -# uninitialized constant RuboCop::Cop::Security::Eval::LITERAL_REGEX -# wrong constant name eval?1 -# wrong constant name eval? -# wrong constant name on_send -# wrong constant name -# undefined method `json_load1' for class `RuboCop::Cop::Security::JSONLoad' -# uninitialized constant RuboCop::Cop::Security::JSONLoad::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name json_load1 -# wrong constant name json_load -# wrong constant name on_send -# wrong constant name -# undefined method `marshal_load1' for class `RuboCop::Cop::Security::MarshalLoad' -# uninitialized constant RuboCop::Cop::Security::MarshalLoad::LITERAL_REGEX -# wrong constant name marshal_load1 -# wrong constant name marshal_load -# wrong constant name on_send -# wrong constant name -# undefined method `open?1' for class `RuboCop::Cop::Security::Open' -# uninitialized constant RuboCop::Cop::Security::Open::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name open?1 -# wrong constant name open? -# wrong constant name -# undefined method `yaml_load1' for class `RuboCop::Cop::Security::YAMLLoad' -# uninitialized constant RuboCop::Cop::Security::YAMLLoad::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name yaml_load1 -# wrong constant name yaml_load -# wrong constant name -# wrong constant name -# wrong constant name <=> -# wrong constant name == -# wrong constant name code -# wrong constant name initialize -# wrong constant name level -# wrong constant name name -# wrong constant name -# wrong constant name name_from_code -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::SpaceBeforePunctuation::BYTE_ORDER_MARK -# wrong constant name investigate -# wrong constant name -# wrong constant name -# wrong constant name add_space -# wrong constant name empty_corrections -# wrong constant name processed_source -# wrong constant name remove_space -# wrong constant name -# wrong constant name on_regexp -# wrong constant name on_str -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# undefined method `access_modifier_with_symbol?1' for class `RuboCop::Cop::Style::AccessModifierDeclarations' -# uninitialized constant RuboCop::Cop::Style::AccessModifierDeclarations::LITERAL_REGEX -# wrong constant name access_modifier_with_symbol?1 -# wrong constant name access_modifier_with_symbol? -# wrong constant name on_send -# wrong constant name -# undefined method `identifier1' for class `RuboCop::Cop::Style::Alias' -# uninitialized constant RuboCop::Cop::Style::Alias::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name identifier1 -# wrong constant name identifier -# wrong constant name on_alias -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::AndOr::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AndOr::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_and -# wrong constant name on_if -# wrong constant name on_or -# wrong constant name on_until -# wrong constant name on_until_post -# wrong constant name on_while -# wrong constant name on_while_post -# wrong constant name -# wrong constant name -# undefined method `join_candidate?1' for class `RuboCop::Cop::Style::ArrayJoin' -# uninitialized constant RuboCop::Cop::Style::ArrayJoin::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name join_candidate?1 -# wrong constant name join_candidate? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::AsciiComments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AsciiComments::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# undefined method `class_eval?1' for class `RuboCop::Cop::Style::Attr' -# uninitialized constant RuboCop::Cop::Style::Attr::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Attr::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name class_eval?1 -# wrong constant name class_eval? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::AutoResourceCleanup::LITERAL_REGEX -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::BarePercentLiterals::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_dstr -# wrong constant name on_str -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::BeginBlock::LITERAL_REGEX -# wrong constant name on_preexe -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::BlockComments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::BlockComments::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::BlockDelimiters::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name move_assignment_inside_condition -# undefined method `case_equality?1' for class `RuboCop::Cop::Style::CaseEquality' -# uninitialized constant RuboCop::Cop::Style::CaseEquality::LITERAL_REGEX -# wrong constant name case_equality?1 -# wrong constant name case_equality? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::CharacterLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name correct_style_detected -# wrong constant name offense? -# wrong constant name opposite_style_detected -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ClassAndModuleChildren::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ClassAndModuleChildren::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name -# undefined method `class_check?1' for class `RuboCop::Cop::Style::ClassCheck' -# uninitialized constant RuboCop::Cop::Style::ClassCheck::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name class_check?1 -# wrong constant name class_check? -# wrong constant name message -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ClassMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ClassVars::LITERAL_REGEX -# wrong constant name message -# wrong constant name on_cvasgn -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::CollectionMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# undefined method `java_type_node?1' for class `RuboCop::Cop::Style::ColonMethodCall' -# uninitialized constant RuboCop::Cop::Style::ColonMethodCall::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name java_type_node?1 -# wrong constant name java_type_node? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ColonMethodDefinition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::CommandLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_xstr -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::CommentAnnotation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::CommentAnnotation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::CommentedKeyword::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# undefined method `assignment_type?1' for class `RuboCop::Cop::Style::ConditionalAssignment' -# undefined method `candidate_condition?1' for class `RuboCop::Cop::Style::ConditionalAssignment' -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::ALIGN_WITH -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::END_ALIGNMENT -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::EQUAL -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::KEYWORD -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::LITERAL_REGEX -# wrong constant name assignment_type?1 -# wrong constant name assignment_type? -# wrong constant name autocorrect -# wrong constant name candidate_condition?1 -# wrong constant name candidate_condition? -# wrong constant name on_and_asgn -# wrong constant name on_case -# wrong constant name on_casgn -# wrong constant name on_cvasgn -# wrong constant name on_gvasgn -# wrong constant name on_if -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_op_asgn -# wrong constant name on_or_asgn -# wrong constant name on_send -# wrong constant name -# wrong constant name end_with_eq? -# wrong constant name expand_elses -# wrong constant name expand_when_branches -# wrong constant name indent -# wrong constant name lhs -# wrong constant name tail -# wrong constant name -# wrong constant name assignment -# wrong constant name correct_branches -# wrong constant name correct_if_branches -# wrong constant name remove_whitespace_in_branches -# wrong constant name replace_branch_assignment -# wrong constant name white_space_range -# wrong constant name -# undefined method `visibility_declaration_for?1' for class `RuboCop::Cop::Style::ConstantVisibility' -# uninitialized constant RuboCop::Cop::Style::ConstantVisibility::LITERAL_REGEX -# wrong constant name on_casgn -# wrong constant name visibility_declaration_for?1 -# wrong constant name visibility_declaration_for? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Copyright::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Copyright::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `date_time?1' for class `RuboCop::Cop::Style::DateTime' -# undefined method `historic_date?1' for class `RuboCop::Cop::Style::DateTime' -# undefined method `to_datetime?1' for class `RuboCop::Cop::Style::DateTime' -# uninitialized constant RuboCop::Cop::Style::DateTime::LITERAL_REGEX -# wrong constant name date_time?1 -# wrong constant name date_time? -# wrong constant name historic_date?1 -# wrong constant name historic_date? -# wrong constant name on_send -# wrong constant name to_datetime?1 -# wrong constant name to_datetime? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::DefWithParentheses::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `dir_replacement?1' for class `RuboCop::Cop::Style::Dir' -# uninitialized constant RuboCop::Cop::Style::Dir::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name dir_replacement?1 -# wrong constant name dir_replacement? -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `constant_definition?1' for class `RuboCop::Cop::Style::Documentation' -# undefined method `constant_visibility_declaration?1' for class `RuboCop::Cop::Style::Documentation' -# uninitialized constant RuboCop::Cop::Style::Documentation::LITERAL_REGEX -# wrong constant name constant_definition?1 -# wrong constant name constant_definition? -# wrong constant name constant_visibility_declaration?1 -# wrong constant name constant_visibility_declaration? -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name outer_module -# wrong constant name -# undefined method `module_function_node?1' for class `RuboCop::Cop::Style::DocumentationMethod' -# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::NON_PUBLIC_MODIFIERS -# wrong constant name module_function_node?1 -# wrong constant name module_function_node? -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::DoubleCopDisableDirective::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# undefined method `double_negative?1' for class `RuboCop::Cop::Style::DoubleNegation' -# uninitialized constant RuboCop::Cop::Style::DoubleNegation::LITERAL_REGEX -# wrong constant name double_negative?1 -# wrong constant name double_negative? -# wrong constant name on_send -# wrong constant name -# undefined method `offending_each_range1' for class `RuboCop::Cop::Style::EachForSimpleLoop' -# uninitialized constant RuboCop::Cop::Style::EachForSimpleLoop::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name offending_each_range1 -# wrong constant name offending_each_range -# wrong constant name on_block -# wrong constant name -# undefined method `each_with_object_candidate?1' for class `RuboCop::Cop::Style::EachWithObject' -# uninitialized constant RuboCop::Cop::Style::EachWithObject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EachWithObject::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name each_with_object_candidate?1 -# wrong constant name each_with_object_candidate? -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EmptyBlockParameter::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyBlockParameter::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EmptyCaseCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyCaseCondition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EmptyElse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyElse::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_case -# wrong constant name on_normal_if_unless -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EmptyLambdaParameter::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyLambdaParameter::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# undefined method `array_node1' for class `RuboCop::Cop::Style::EmptyLiteral' -# undefined method `array_with_block1' for class `RuboCop::Cop::Style::EmptyLiteral' -# undefined method `hash_node1' for class `RuboCop::Cop::Style::EmptyLiteral' -# undefined method `hash_with_block1' for class `RuboCop::Cop::Style::EmptyLiteral' -# undefined method `str_node1' for class `RuboCop::Cop::Style::EmptyLiteral' -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::FROZEN_STRING_LITERAL -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::FROZEN_STRING_LITERAL_TYPES -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::LITERAL_REGEX -# wrong constant name array_node1 -# wrong constant name array_node -# wrong constant name array_with_block1 -# wrong constant name array_with_block -# wrong constant name autocorrect -# wrong constant name hash_node1 -# wrong constant name hash_node -# wrong constant name hash_with_block1 -# wrong constant name hash_with_block -# wrong constant name on_send -# wrong constant name str_node1 -# wrong constant name str_node -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EmptyMethod::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Encoding::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Encoding::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::EndBlock::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_postexe -# wrong constant name -# undefined method `eval_without_location?1' for class `RuboCop::Cop::Style::EvalWithLocation' -# undefined method `line_with_offset?1' for class `RuboCop::Cop::Style::EvalWithLocation' -# uninitialized constant RuboCop::Cop::Style::EvalWithLocation::LITERAL_REGEX -# wrong constant name eval_without_location?1 -# wrong constant name eval_without_location? -# wrong constant name line_with_offset?1 -# wrong constant name line_with_offset? -# wrong constant name on_send -# wrong constant name -# undefined method `even_odd_candidate?1' for class `RuboCop::Cop::Style::EvenOdd' -# uninitialized constant RuboCop::Cop::Style::EvenOdd::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name even_odd_candidate?1 -# wrong constant name even_odd_candidate? -# wrong constant name on_send -# wrong constant name -# undefined method `file_expand_path1' for class `RuboCop::Cop::Style::ExpandPathArguments' -# undefined method `pathname_new_parent_expand_path1' for class `RuboCop::Cop::Style::ExpandPathArguments' -# undefined method `pathname_parent_expand_path1' for class `RuboCop::Cop::Style::ExpandPathArguments' -# uninitialized constant RuboCop::Cop::Style::ExpandPathArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ExpandPathArguments::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name file_expand_path1 -# wrong constant name file_expand_path -# wrong constant name on_send -# wrong constant name pathname_new_parent_expand_path1 -# wrong constant name pathname_new_parent_expand_path -# wrong constant name pathname_parent_expand_path1 -# wrong constant name pathname_parent_expand_path -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ExponentialNotation::LITERAL_REGEX -# wrong constant name on_float -# wrong constant name -# undefined method `any_coerce?1' for class `RuboCop::Cop::Style::FloatDivision' -# undefined method `both_coerce?1' for class `RuboCop::Cop::Style::FloatDivision' -# undefined method `left_coerce?1' for class `RuboCop::Cop::Style::FloatDivision' -# undefined method `right_coerce?1' for class `RuboCop::Cop::Style::FloatDivision' -# uninitialized constant RuboCop::Cop::Style::FloatDivision::LITERAL_REGEX -# wrong constant name any_coerce?1 -# wrong constant name any_coerce? -# wrong constant name both_coerce?1 -# wrong constant name both_coerce? -# wrong constant name left_coerce?1 -# wrong constant name left_coerce? -# wrong constant name on_send -# wrong constant name right_coerce?1 -# wrong constant name right_coerce? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::For::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::For::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_for -# wrong constant name -# undefined method `formatter1' for class `RuboCop::Cop::Style::FormatString' -# undefined method `variable_argument?1' for class `RuboCop::Cop::Style::FormatString' -# uninitialized constant RuboCop::Cop::Style::FormatString::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name formatter1 -# wrong constant name formatter -# wrong constant name message -# wrong constant name method_name -# wrong constant name on_send -# wrong constant name variable_argument?1 -# wrong constant name variable_argument? -# wrong constant name -# undefined method `format_string_in_typical_context?1' for class `RuboCop::Cop::Style::FormatStringToken' -# uninitialized constant RuboCop::Cop::Style::FormatStringToken::LITERAL_REGEX -# wrong constant name format_string_in_typical_context?1 -# wrong constant name format_string_in_typical_context? -# wrong constant name on_str -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::FROZEN_STRING_LITERAL -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::FROZEN_STRING_LITERAL_TYPES -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::GlobalVars::LITERAL_REGEX -# wrong constant name allowed_var? -# wrong constant name check -# wrong constant name on_gvar -# wrong constant name on_gvasgn -# wrong constant name user_vars -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::GuardClause::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_if -# wrong constant name -# undefined method `kv_each1' for class `RuboCop::Cop::Style::HashEachMethods' -# uninitialized constant RuboCop::Cop::Style::HashEachMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name kv_each1 -# wrong constant name kv_each -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::HashSyntax::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::HashSyntax::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name hash_rockets_check -# wrong constant name no_mixed_keys_check -# wrong constant name on_hash -# wrong constant name ruby19_check -# wrong constant name ruby19_no_mixed_keys_check -# wrong constant name -# undefined method `on_bad_each_with_object1' for class `RuboCop::Cop::Style::HashTransformKeys' -# undefined method `on_bad_hash_brackets_map1' for class `RuboCop::Cop::Style::HashTransformKeys' -# undefined method `on_bad_map_to_h1' for class `RuboCop::Cop::Style::HashTransformKeys' -# uninitialized constant RuboCop::Cop::Style::HashTransformKeys::LITERAL_REGEX -# wrong constant name on_bad_each_with_object1 -# wrong constant name on_bad_each_with_object -# wrong constant name on_bad_hash_brackets_map1 -# wrong constant name on_bad_hash_brackets_map -# wrong constant name on_bad_map_to_h1 -# wrong constant name on_bad_map_to_h -# wrong constant name -# undefined method `on_bad_each_with_object1' for class `RuboCop::Cop::Style::HashTransformValues' -# undefined method `on_bad_hash_brackets_map1' for class `RuboCop::Cop::Style::HashTransformValues' -# undefined method `on_bad_map_to_h1' for class `RuboCop::Cop::Style::HashTransformValues' -# uninitialized constant RuboCop::Cop::Style::HashTransformValues::LITERAL_REGEX -# wrong constant name on_bad_each_with_object1 -# wrong constant name on_bad_each_with_object -# wrong constant name on_bad_hash_brackets_map1 -# wrong constant name on_bad_hash_brackets_map -# wrong constant name on_bad_map_to_h1 -# wrong constant name on_bad_map_to_h -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::IdenticalConditionalBranches::LITERAL_REGEX -# wrong constant name on_case -# wrong constant name on_if -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name move_assignment_inside_condition -# uninitialized constant RuboCop::Cop::Style::IfInsideElse::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifier::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::IfWithSemicolon::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_normal_if_unless -# wrong constant name -# undefined method `implicit_runtime_error_raise_or_fail1' for class `RuboCop::Cop::Style::ImplicitRuntimeError' -# uninitialized constant RuboCop::Cop::Style::ImplicitRuntimeError::LITERAL_REGEX -# wrong constant name implicit_runtime_error_raise_or_fail1 -# wrong constant name implicit_runtime_error_raise_or_fail -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::InfiniteLoop::LITERAL_REGEX -# wrong constant name after_leaving_scope -# wrong constant name autocorrect -# wrong constant name join_force? -# wrong constant name on_until -# wrong constant name on_until_post -# wrong constant name on_while -# wrong constant name on_while_post -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::InlineComment::LITERAL_REGEX -# wrong constant name investigate -# wrong constant name -# undefined method `inverse_block?1' for class `RuboCop::Cop::Style::InverseMethods' -# undefined method `inverse_candidate?1' for class `RuboCop::Cop::Style::InverseMethods' -# uninitialized constant RuboCop::Cop::Style::InverseMethods::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::InverseMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name correct_inverse_block -# wrong constant name correct_inverse_method -# wrong constant name correct_inverse_selector -# wrong constant name inverse_block?1 -# wrong constant name inverse_block? -# wrong constant name inverse_candidate?1 -# wrong constant name inverse_candidate? -# wrong constant name on_block -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::IpAddresses::LITERAL_REGEX -# wrong constant name correct_style_detected -# wrong constant name offense? -# wrong constant name opposite_style_detected -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Lambda::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_numblock -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::LambdaCall::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::LineEndConcatenation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::LineEndConcatenation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MethodCallWithArgsParentheses::LITERAL_REGEX -# wrong constant name -# wrong constant name -# wrong constant name autocorrect -# wrong constant name initialize -# undefined method `message1' for module `#' -# wrong constant name autocorrect -# wrong constant name message1 -# wrong constant name message -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name on_super -# wrong constant name on_yield -# wrong constant name -# undefined method `message1' for module `#' -# wrong constant name autocorrect -# wrong constant name message1 -# wrong constant name message -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name on_super -# wrong constant name on_yield -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MethodCalledOnDoEndBlock::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MethodCalledOnDoEndBlock::LITERAL_REGEX -# wrong constant name on_block -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MethodDefParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MethodDefParentheses::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MethodMissingSuper::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `min_max_candidate1' for class `RuboCop::Cop::Style::MinMax' -# uninitialized constant RuboCop::Cop::Style::MinMax::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name min_max_candidate1 -# wrong constant name min_max_candidate -# wrong constant name on_array -# wrong constant name on_return -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MissingElse::LITERAL_REGEX -# wrong constant name on_case -# wrong constant name on_normal_if_unless -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MissingRespondToMissing::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MixinGrouping::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name on_module -# wrong constant name -# undefined method `include_statement1' for class `RuboCop::Cop::Style::MixinUsage' -# undefined method `wrapped_macro_scope?1' for class `RuboCop::Cop::Style::MixinUsage' -# uninitialized constant RuboCop::Cop::Style::MixinUsage::LITERAL_REGEX -# wrong constant name include_statement1 -# wrong constant name include_statement -# wrong constant name on_send -# wrong constant name wrapped_macro_scope?1 -# wrong constant name wrapped_macro_scope? -# wrong constant name -# undefined method `extend_self_node?1' for class `RuboCop::Cop::Style::ModuleFunction' -# undefined method `module_function_node?1' for class `RuboCop::Cop::Style::ModuleFunction' -# undefined method `private_directive?1' for class `RuboCop::Cop::Style::ModuleFunction' -# uninitialized constant RuboCop::Cop::Style::ModuleFunction::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name extend_self_node?1 -# wrong constant name extend_self_node? -# wrong constant name module_function_node?1 -# wrong constant name module_function_node? -# wrong constant name on_module -# wrong constant name private_directive?1 -# wrong constant name private_directive? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineBlockChain::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineBlockChain::LITERAL_REGEX -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineIfModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineIfModifier::SPACE -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineIfThen::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineIfThen::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_normal_if_unless -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineMemoization::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_or_asgn -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineMethodSignature::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineTernaryOperator::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::MultilineWhenThen::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineWhenThen::LITERAL_REGEX -# wrong constant name accept_node_type? -# wrong constant name autocorrect -# wrong constant name on_when -# wrong constant name require_then? -# wrong constant name -# undefined method `simple_comparison?1' for class `RuboCop::Cop::Style::MultipleComparison' -# undefined method `simple_double_comparison?1' for class `RuboCop::Cop::Style::MultipleComparison' -# uninitialized constant RuboCop::Cop::Style::MultipleComparison::LITERAL_REGEX -# wrong constant name on_or -# wrong constant name simple_comparison?1 -# wrong constant name simple_comparison? -# wrong constant name simple_double_comparison?1 -# wrong constant name simple_double_comparison? -# wrong constant name -# undefined method `operation_produces_immutable_object?1' for class `RuboCop::Cop::Style::MutableConstant' -# undefined method `range_enclosed_in_parentheses?1' for class `RuboCop::Cop::Style::MutableConstant' -# undefined method `splat_value1' for class `RuboCop::Cop::Style::MutableConstant' -# uninitialized constant RuboCop::Cop::Style::MutableConstant::FROZEN_STRING_LITERAL -# uninitialized constant RuboCop::Cop::Style::MutableConstant::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::MutableConstant::FROZEN_STRING_LITERAL_TYPES -# uninitialized constant RuboCop::Cop::Style::MutableConstant::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_casgn -# wrong constant name on_or_asgn -# wrong constant name operation_produces_immutable_object?1 -# wrong constant name operation_produces_immutable_object? -# wrong constant name range_enclosed_in_parentheses?1 -# wrong constant name range_enclosed_in_parentheses? -# wrong constant name splat_value1 -# wrong constant name splat_value -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NegatedIf::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NegatedIf::MSG -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NegatedUnless::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NegatedUnless::MSG -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NegatedWhile::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NegatedWhile::MSG -# wrong constant name autocorrect -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NestedModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedModifier::LITERAL_REGEX -# wrong constant name add_parentheses_to_method_arguments -# wrong constant name autocorrect -# wrong constant name check -# wrong constant name left_hand_operand -# wrong constant name modifier? -# wrong constant name new_expression -# wrong constant name on_if -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name replacement_operator -# wrong constant name requires_parens? -# wrong constant name right_hand_operand -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NestedParenthesizedCalls::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedParenthesizedCalls::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NestedTernaryOperator::LITERAL_REGEX -# wrong constant name on_if -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Next::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Next::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name on_block -# wrong constant name on_for -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# undefined method `nil_check?1' for class `RuboCop::Cop::Style::NilComparison' -# undefined method `nil_comparison?1' for class `RuboCop::Cop::Style::NilComparison' -# uninitialized constant RuboCop::Cop::Style::NilComparison::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name nil_check?1 -# wrong constant name nil_check? -# wrong constant name nil_comparison?1 -# wrong constant name nil_comparison? -# wrong constant name on_send -# wrong constant name -# undefined method `nil_check?1' for class `RuboCop::Cop::Style::NonNilCheck' -# undefined method `not_and_nil_check?1' for class `RuboCop::Cop::Style::NonNilCheck' -# undefined method `not_equal_to_nil?1' for class `RuboCop::Cop::Style::NonNilCheck' -# undefined method `unless_check?1' for class `RuboCop::Cop::Style::NonNilCheck' -# uninitialized constant RuboCop::Cop::Style::NonNilCheck::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name nil_check?1 -# wrong constant name nil_check? -# wrong constant name not_and_nil_check?1 -# wrong constant name not_and_nil_check? -# wrong constant name not_equal_to_nil?1 -# wrong constant name not_equal_to_nil? -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_send -# wrong constant name unless_check?1 -# wrong constant name unless_check? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Not::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Not::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NumericLiteralPrefix::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_int -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::NumericLiterals::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_float -# wrong constant name on_int -# wrong constant name -# undefined method `comparison1' for class `RuboCop::Cop::Style::NumericPredicate' -# undefined method `inverted_comparison1' for class `RuboCop::Cop::Style::NumericPredicate' -# undefined method `predicate1' for class `RuboCop::Cop::Style::NumericPredicate' -# uninitialized constant RuboCop::Cop::Style::NumericPredicate::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name comparison1 -# wrong constant name comparison -# wrong constant name inverted_comparison1 -# wrong constant name inverted_comparison -# wrong constant name on_send -# wrong constant name predicate1 -# wrong constant name predicate -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::OneLineConditional::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_normal_if_unless -# wrong constant name -# undefined method `option_hash1' for class `RuboCop::Cop::Style::OptionHash' -# uninitialized constant RuboCop::Cop::Style::OptionHash::LITERAL_REGEX -# wrong constant name on_args -# wrong constant name option_hash1 -# wrong constant name option_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::OptionalArguments::LITERAL_REGEX -# wrong constant name on_def -# wrong constant name -# undefined method `ternary_assignment?1' for class `RuboCop::Cop::Style::OrAssignment' -# undefined method `unless_assignment?1' for class `RuboCop::Cop::Style::OrAssignment' -# uninitialized constant RuboCop::Cop::Style::OrAssignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_cvasgn -# wrong constant name on_gvasgn -# wrong constant name on_if -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name ternary_assignment?1 -# wrong constant name ternary_assignment? -# wrong constant name unless_assignment?1 -# wrong constant name unless_assignment? -# wrong constant name -# undefined method `implicit_self_getter?1' for class `RuboCop::Cop::Style::ParallelAssignment' -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::LITERAL_REGEX -# wrong constant name -# wrong constant name -# wrong constant name autocorrect -# wrong constant name implicit_self_getter?1 -# wrong constant name implicit_self_getter? -# wrong constant name on_masgn -# undefined method `var_name1' for class `RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter' -# wrong constant name accesses? -# wrong constant name dependency? -# wrong constant name initialize -# wrong constant name matching_calls -# wrong constant name tsort_each_child -# wrong constant name uses_var? -# wrong constant name var_name1 -# wrong constant name var_name -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::GenericCorrector::SPACE -# wrong constant name assignment -# wrong constant name config -# wrong constant name correction -# wrong constant name correction_range -# wrong constant name initialize -# wrong constant name node -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector::SPACE -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::RescueCorrector::SPACE -# wrong constant name -# wrong constant name -# undefined method `control_op_condition1' for class `RuboCop::Cop::Style::ParenthesesAroundCondition' -# uninitialized constant RuboCop::Cop::Style::ParenthesesAroundCondition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name control_op_condition1 -# wrong constant name control_op_condition -# wrong constant name on_if -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::PercentLiteralDelimiters::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::PercentLiteralDelimiters::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name message -# wrong constant name on_array -# wrong constant name on_dstr -# wrong constant name on_regexp -# wrong constant name on_str -# wrong constant name on_sym -# wrong constant name on_xstr -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::PercentQLiterals::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::PercentQLiterals::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_str -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::PerlBackrefs::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_nth_ref -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::PreferredHashMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# undefined method `proc_new?1' for class `RuboCop::Cop::Style::Proc' -# uninitialized constant RuboCop::Cop::Style::Proc::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name proc_new?1 -# wrong constant name proc_new? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RaiseArgs::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# undefined method `integer_op_rand?1' for class `RuboCop::Cop::Style::RandomWithOffset' -# undefined method `namespace1' for class `RuboCop::Cop::Style::RandomWithOffset' -# undefined method `rand_modified?1' for class `RuboCop::Cop::Style::RandomWithOffset' -# undefined method `rand_op_integer?1' for class `RuboCop::Cop::Style::RandomWithOffset' -# undefined method `random_call1' for class `RuboCop::Cop::Style::RandomWithOffset' -# undefined method `to_int1' for class `RuboCop::Cop::Style::RandomWithOffset' -# uninitialized constant RuboCop::Cop::Style::RandomWithOffset::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name integer_op_rand?1 -# wrong constant name integer_op_rand? -# wrong constant name namespace1 -# wrong constant name namespace -# wrong constant name on_send -# wrong constant name rand_modified?1 -# wrong constant name rand_modified? -# wrong constant name rand_op_integer?1 -# wrong constant name rand_op_integer? -# wrong constant name random_call1 -# wrong constant name random_call -# wrong constant name to_int1 -# wrong constant name to_int -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantBegin::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantCapitalW::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantCapitalW::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantCondition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name -# undefined method `redundant_condition?1' for class `RuboCop::Cop::Style::RedundantConditional' -# undefined method `redundant_condition_inverted?1' for class `RuboCop::Cop::Style::RedundantConditional' -# uninitialized constant RuboCop::Cop::Style::RedundantConditional::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantConditional::SPACE -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name redundant_condition?1 -# wrong constant name redundant_condition? -# wrong constant name redundant_condition_inverted?1 -# wrong constant name redundant_condition_inverted? -# wrong constant name -# undefined method `compact?1' for class `RuboCop::Cop::Style::RedundantException' -# undefined method `exploded?1' for class `RuboCop::Cop::Style::RedundantException' -# uninitialized constant RuboCop::Cop::Style::RedundantException::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name compact?1 -# wrong constant name compact? -# wrong constant name exploded?1 -# wrong constant name exploded? -# wrong constant name on_send -# wrong constant name -# undefined method `operation_produces_immutable_object?1' for class `RuboCop::Cop::Style::RedundantFreeze' -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::FROZEN_STRING_LITERAL -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::FROZEN_STRING_LITERAL_TYPES -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name operation_produces_immutable_object?1 -# wrong constant name operation_produces_immutable_object? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantInterpolation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_dstr -# wrong constant name -# undefined method `arg_in_call_with_block?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `first_send_argument?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `first_super_argument?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `method_node_and_args1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `range_end?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `rescue?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# undefined method `square_brackets?1' for class `RuboCop::Cop::Style::RedundantParentheses' -# uninitialized constant RuboCop::Cop::Style::RedundantParentheses::LITERAL_REGEX -# wrong constant name arg_in_call_with_block?1 -# wrong constant name arg_in_call_with_block? -# wrong constant name autocorrect -# wrong constant name first_send_argument?1 -# wrong constant name first_send_argument? -# wrong constant name first_super_argument?1 -# wrong constant name first_super_argument? -# wrong constant name method_node_and_args1 -# wrong constant name method_node_and_args -# wrong constant name on_begin -# wrong constant name range_end?1 -# wrong constant name range_end? -# wrong constant name rescue?1 -# wrong constant name rescue? -# wrong constant name square_brackets?1 -# wrong constant name square_brackets? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantPercentQ::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_dstr -# wrong constant name on_str -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpCharacterClass::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpCharacterClass::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name each_redundant_character_class -# wrong constant name on_regexp -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpEscape::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpEscape::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_regexp -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantReturn::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantReturn::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RedundantSelf::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_and_asgn -# wrong constant name on_args -# wrong constant name on_block -# wrong constant name on_blockarg -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name on_lvasgn -# wrong constant name on_masgn -# wrong constant name on_op_asgn -# wrong constant name on_or_asgn -# wrong constant name on_send -# wrong constant name -# undefined method `redundant_sort?1' for class `RuboCop::Cop::Style::RedundantSort' -# uninitialized constant RuboCop::Cop::Style::RedundantSort::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSort::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name redundant_sort?1 -# wrong constant name redundant_sort? -# wrong constant name -# undefined method `redundant_sort_by1' for class `RuboCop::Cop::Style::RedundantSortBy' -# uninitialized constant RuboCop::Cop::Style::RedundantSortBy::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSortBy::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name redundant_sort_by1 -# wrong constant name redundant_sort_by -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RegexpLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RegexpLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_regexp -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::RescueModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RescueModifier::SPACE -# wrong constant name autocorrect -# wrong constant name on_resbody -# wrong constant name -# undefined method `rescue_standard_error?1' for class `RuboCop::Cop::Style::RescueStandardError' -# undefined method `rescue_without_error_class?1' for class `RuboCop::Cop::Style::RescueStandardError' -# uninitialized constant RuboCop::Cop::Style::RescueStandardError::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RescueStandardError::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_resbody -# wrong constant name rescue_standard_error?1 -# wrong constant name rescue_standard_error? -# wrong constant name rescue_without_error_class?1 -# wrong constant name rescue_without_error_class? -# wrong constant name -# undefined method `chained_send?1' for class `RuboCop::Cop::Style::ReturnNil' -# undefined method `define_method?1' for class `RuboCop::Cop::Style::ReturnNil' -# undefined method `return_nil_node?1' for class `RuboCop::Cop::Style::ReturnNil' -# undefined method `return_node?1' for class `RuboCop::Cop::Style::ReturnNil' -# uninitialized constant RuboCop::Cop::Style::ReturnNil::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name chained_send?1 -# wrong constant name chained_send? -# wrong constant name define_method?1 -# wrong constant name define_method? -# wrong constant name on_return -# wrong constant name return_nil_node?1 -# wrong constant name return_nil_node? -# wrong constant name return_node?1 -# wrong constant name return_node? -# wrong constant name -# undefined method `modifier_if_safe_navigation_candidate1' for class `RuboCop::Cop::Style::SafeNavigation' -# undefined method `not_nil_check?1' for class `RuboCop::Cop::Style::SafeNavigation' -# uninitialized constant RuboCop::Cop::Style::SafeNavigation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SafeNavigation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name check_node -# wrong constant name modifier_if_safe_navigation_candidate1 -# wrong constant name modifier_if_safe_navigation_candidate -# wrong constant name not_nil_check?1 -# wrong constant name not_nil_check? -# wrong constant name on_and -# wrong constant name on_if -# wrong constant name use_var_only_in_unless_modifier? -# wrong constant name -# undefined method `sample_candidate?1' for class `RuboCop::Cop::Style::Sample' -# uninitialized constant RuboCop::Cop::Style::Sample::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name sample_candidate?1 -# wrong constant name sample_candidate? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::SelfAssignment::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_cvasgn -# wrong constant name on_ivasgn -# wrong constant name on_lvasgn -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::Semicolon::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Semicolon::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name investigate -# wrong constant name on_begin -# wrong constant name -# undefined method `sending?1' for class `RuboCop::Cop::Style::Send' -# uninitialized constant RuboCop::Cop::Style::Send::LITERAL_REGEX -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name sending?1 -# wrong constant name sending? -# wrong constant name -# undefined method `kernel_call?1' for class `RuboCop::Cop::Style::SignalException' -# uninitialized constant RuboCop::Cop::Style::SignalException::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name custom_fail_methods -# wrong constant name investigate -# wrong constant name kernel_call?1 -# wrong constant name kernel_call? -# wrong constant name on_rescue -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::SingleLineBlockParams::LITERAL_REGEX -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::SingleLineMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SingleLineMethods::SPACE -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# undefined method `range_till_minus_one?1' for class `RuboCop::Cop::Style::SlicingWithRange' -# uninitialized constant RuboCop::Cop::Style::SlicingWithRange::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name range_till_minus_one?1 -# wrong constant name range_till_minus_one? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::SpecialGlobalVars::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name message -# wrong constant name on_gvar -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::StabbyLambdaParentheses::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name -# undefined method `stderr_puts?1' for class `RuboCop::Cop::Style::StderrPuts' -# uninitialized constant RuboCop::Cop::Style::StderrPuts::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::StderrPuts::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name stderr_puts?1 -# wrong constant name stderr_puts? -# wrong constant name -# undefined method `receive_environments_method?1' for class `RuboCop::Cop::Style::StringHashKeys' -# undefined method `string_hash_key?1' for class `RuboCop::Cop::Style::StringHashKeys' -# uninitialized constant RuboCop::Cop::Style::StringHashKeys::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_pair -# wrong constant name receive_environments_method?1 -# wrong constant name receive_environments_method? -# wrong constant name string_hash_key?1 -# wrong constant name string_hash_key? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::StringLiterals::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_dstr -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::StringLiteralsInInterpolation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::StringMethods::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# undefined method `lstrip_rstrip1' for class `RuboCop::Cop::Style::Strip' -# uninitialized constant RuboCop::Cop::Style::Strip::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Strip::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name lstrip_rstrip1 -# wrong constant name lstrip_rstrip -# wrong constant name on_send -# wrong constant name -# undefined method `struct_constructor?1' for class `RuboCop::Cop::Style::StructInheritance' -# uninitialized constant RuboCop::Cop::Style::StructInheritance::LITERAL_REGEX -# wrong constant name on_class -# wrong constant name struct_constructor?1 -# wrong constant name struct_constructor? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::SymbolArray::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# wrong constant name largest_brackets -# wrong constant name largest_brackets= -# uninitialized constant RuboCop::Cop::Style::SymbolLiteral::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_sym -# wrong constant name -# undefined method `proc_node?1' for class `RuboCop::Cop::Style::SymbolProc' -# undefined method `symbol_proc?1' for class `RuboCop::Cop::Style::SymbolProc' -# uninitialized constant RuboCop::Cop::Style::SymbolProc::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SymbolProc::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name destructuring_block_argument? -# wrong constant name on_block -# wrong constant name proc_node?1 -# wrong constant name proc_node? -# wrong constant name symbol_proc?1 -# wrong constant name symbol_proc? -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name move_assignment_inside_condition -# undefined method `method_name1' for class `RuboCop::Cop::Style::TernaryParentheses' -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name method_name1 -# wrong constant name method_name -# wrong constant name on_if -# wrong constant name only_closing_parenthesis_is_last_line? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnClass::SPACE -# wrong constant name autocorrect -# wrong constant name on_class -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::SPACE -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnModule::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnModule::SPACE -# wrong constant name autocorrect -# wrong constant name on_module -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArguments::MSG -# wrong constant name autocorrect -# wrong constant name on_csend -# wrong constant name on_send -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArrayLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArrayLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInArrayLiteral::MSG -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInBlockArgs::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_block -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInHashLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInHashLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInHashLiteral::MSG -# wrong constant name autocorrect -# wrong constant name on_hash -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingMethodEndStatement::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingMethodEndStatement::SPACE -# wrong constant name autocorrect -# wrong constant name on_def -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::SPACE_COMMAND -# wrong constant name autocorrect -# wrong constant name on_masgn -# wrong constant name -# undefined method `looks_like_trivial_writer?1' for class `RuboCop::Cop::Style::TrivialAccessors' -# uninitialized constant RuboCop::Cop::Style::TrivialAccessors::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name looks_like_trivial_writer?1 -# wrong constant name looks_like_trivial_writer? -# wrong constant name on_def -# wrong constant name on_defs -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::UnlessElse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::UnlessElse::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_if -# wrong constant name range_between_condition_and_else -# wrong constant name range_between_else_and_end -# wrong constant name -# undefined method `unpack_and_first_element?1' for class `RuboCop::Cop::Style::UnpackFirst' -# uninitialized constant RuboCop::Cop::Style::UnpackFirst::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_send -# wrong constant name unpack_and_first_element?1 -# wrong constant name unpack_and_first_element? -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::VariableInterpolation::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::WhenThen::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_when -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::WhileUntilDo::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name handle -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::WhileUntilModifier::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_until -# wrong constant name on_while -# wrong constant name -# uninitialized constant RuboCop::Cop::Style::WordArray::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name on_array -# wrong constant name -# wrong constant name largest_brackets -# wrong constant name largest_brackets= -# undefined method `file_constant_equal_program_name?1' for class `RuboCop::Cop::Style::YodaCondition' -# uninitialized constant RuboCop::Cop::Style::YodaCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::YodaCondition::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name file_constant_equal_program_name?1 -# wrong constant name file_constant_equal_program_name? -# wrong constant name on_send -# wrong constant name -# undefined method `non_polymorphic_collection?1' for class `RuboCop::Cop::Style::ZeroLengthPredicate' -# undefined method `nonzero_length_predicate1' for class `RuboCop::Cop::Style::ZeroLengthPredicate' -# undefined method `other_receiver1' for class `RuboCop::Cop::Style::ZeroLengthPredicate' -# undefined method `zero_length_predicate1' for class `RuboCop::Cop::Style::ZeroLengthPredicate' -# undefined method `zero_length_receiver1' for class `RuboCop::Cop::Style::ZeroLengthPredicate' -# uninitialized constant RuboCop::Cop::Style::ZeroLengthPredicate::LITERAL_REGEX -# wrong constant name autocorrect -# wrong constant name non_polymorphic_collection?1 -# wrong constant name non_polymorphic_collection? -# wrong constant name nonzero_length_predicate1 -# wrong constant name nonzero_length_predicate -# wrong constant name on_send -# wrong constant name other_receiver1 -# wrong constant name other_receiver -# wrong constant name zero_length_predicate1 -# wrong constant name zero_length_predicate -# wrong constant name zero_length_receiver1 -# wrong constant name zero_length_receiver -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::SurroundingSpace::BYTE_ORDER_MARK -# wrong constant name -# wrong constant name minimum_target_ruby_version -# wrong constant name required_minimum_ruby_version -# wrong constant name support_target_ruby_version? -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Cop::Team' -# undefined method `initialize2' for class `RuboCop::Cop::Team' -# wrong constant name -# wrong constant name autocorrect -# wrong constant name autocorrect? -# wrong constant name cops -# wrong constant name debug? -# wrong constant name errors -# wrong constant name external_dependency_checksum -# wrong constant name forces -# wrong constant name forces_for -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize -# wrong constant name inspect_file -# wrong constant name updated_source_file -# wrong constant name updated_source_file? -# wrong constant name warnings -# uninitialized constant RuboCop::Cop::Team::Investigation::Elem -# wrong constant name errors -# wrong constant name errors= -# wrong constant name offenses -# wrong constant name offenses= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# undefined singleton method `mobilize1' for `RuboCop::Cop::Team' -# undefined singleton method `mobilize_cops1' for `RuboCop::Cop::Team' -# undefined singleton method `new1' for `RuboCop::Cop::Team' -# wrong constant name -# wrong constant name mobilize1 -# wrong constant name mobilize -# wrong constant name mobilize_cops1 -# wrong constant name mobilize_cops -# wrong constant name new1 -# wrong constant name new -# wrong constant name -# wrong constant name body_on_first_line? -# wrong constant name first_part_of -# wrong constant name trailing_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::TrailingComma::BYTE_ORDER_MARK -# wrong constant name -# wrong constant name check -# wrong constant name -# wrong constant name -# wrong constant name correct -# wrong constant name correct_for_blockarg_type -# wrong constant name processed_source -# undefined singleton method `on_node1' for `RuboCop::Cop::Util' -# wrong constant name -# wrong constant name add_parentheses -# wrong constant name args_begin -# wrong constant name args_end -# wrong constant name begins_its_line? -# wrong constant name comment_line? -# wrong constant name comment_lines? -# wrong constant name double_quotes_required? -# wrong constant name escape_string -# wrong constant name first_part_of_call_chain -# wrong constant name interpret_string_escapes -# wrong constant name line_range -# wrong constant name needs_escaping? -# wrong constant name on_node1 -# wrong constant name on_node -# wrong constant name parentheses? -# wrong constant name same_line? -# wrong constant name to_string_literal -# wrong constant name to_supported_styles -# wrong constant name tokens -# wrong constant name trim_string_interporation_escape_character -# wrong constant name -# wrong constant name -# wrong constant name format_sequences -# wrong constant name initialize -# wrong constant name max_digit_dollar_num -# wrong constant name named_interpolation? -# wrong constant name valid? -# wrong constant name annotated? -# wrong constant name arity -# wrong constant name begin_pos -# wrong constant name end_pos -# wrong constant name flags -# wrong constant name initialize -# wrong constant name max_digit_dollar_num -# wrong constant name name -# wrong constant name percent? -# wrong constant name precision -# wrong constant name style -# wrong constant name template? -# wrong constant name type -# wrong constant name width -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name investigate -# wrong constant name process_node -# wrong constant name variable_table -# wrong constant name initialize -# wrong constant name meta_assignment_node -# wrong constant name multiple_assignment? -# wrong constant name name -# wrong constant name node -# wrong constant name operator -# wrong constant name operator_assignment? -# wrong constant name reference! -# wrong constant name referenced -# wrong constant name referenced? -# wrong constant name references -# wrong constant name regexp_named_capture? -# wrong constant name scope -# wrong constant name used? -# wrong constant name variable -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::AssignmentReference::Elem -# wrong constant name assignment? -# wrong constant name node -# wrong constant name node= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::And::Elem -# wrong constant name left_body? -# wrong constant name right_body? -# wrong constant name -# undefined method `each_ancestor1' for class `RuboCop::Cop::VariableForce::Branch::Base' -# wrong constant name == -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Base::Elem -# wrong constant name always_run? -# wrong constant name branched? -# wrong constant name child_node -# wrong constant name child_node= -# wrong constant name control_node -# wrong constant name each_ancestor1 -# wrong constant name each_ancestor -# wrong constant name eql? -# wrong constant name exclusive_with? -# wrong constant name may_jump_to_other_branch? -# wrong constant name may_run_incompletely? -# wrong constant name parent -# wrong constant name scope -# wrong constant name scope= -# undefined singleton method `define_predicate1' for `RuboCop::Cop::VariableForce::Branch::Base' -# wrong constant name -# wrong constant name [] -# wrong constant name classes -# wrong constant name define_predicate1 -# wrong constant name define_predicate -# wrong constant name inherited -# wrong constant name members -# wrong constant name type -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Case::Elem -# wrong constant name else_body? -# wrong constant name target? -# wrong constant name when_clause? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Ensure::Elem -# wrong constant name ensure_body? -# wrong constant name main_body? -# wrong constant name -# wrong constant name may_jump_to_other_branch? -# wrong constant name may_run_incompletely? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::For::Elem -# wrong constant name collection? -# wrong constant name element? -# wrong constant name loop_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::If::Elem -# wrong constant name falsey_body? -# wrong constant name truthy_body? -# wrong constant name -# wrong constant name always_run? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Or::Elem -# wrong constant name left_body? -# wrong constant name right_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Rescue::Elem -# wrong constant name else_body? -# wrong constant name main_body? -# wrong constant name rescue_clause? -# wrong constant name -# wrong constant name always_run? -# wrong constant name conditional_clause? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::Until::Elem -# wrong constant name loop_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::UntilPost::Elem -# wrong constant name loop_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::While::Elem -# wrong constant name loop_body? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::Branch::WhilePost::Elem -# wrong constant name loop_body? -# wrong constant name -# undefined singleton method `of1' for `RuboCop::Cop::VariableForce::Branch' -# wrong constant name -# wrong constant name of1 -# wrong constant name of -# wrong constant name branch -# wrong constant name run_exclusively_with? -# wrong constant name -# wrong constant name explicit? -# wrong constant name initialize -# wrong constant name node -# wrong constant name scope -# wrong constant name -# wrong constant name == -# wrong constant name body_node -# wrong constant name each_node -# wrong constant name include? -# wrong constant name initialize -# wrong constant name naked_top_level -# wrong constant name naked_top_level? -# wrong constant name name -# wrong constant name node -# wrong constant name variables -# wrong constant name -# wrong constant name argument? -# wrong constant name assign -# wrong constant name assignments -# wrong constant name block_argument? -# wrong constant name capture_with_block! -# wrong constant name captured_by_block -# wrong constant name captured_by_block? -# wrong constant name declaration_node -# wrong constant name explicit_block_local_variable? -# wrong constant name in_modifier_if? -# wrong constant name initialize -# wrong constant name keyword_argument? -# wrong constant name method_argument? -# wrong constant name name -# wrong constant name reference! -# wrong constant name referenced? -# wrong constant name references -# wrong constant name scope -# wrong constant name should_be_unused? -# wrong constant name used? -# wrong constant name -# uninitialized constant RuboCop::Cop::VariableForce::VariableReference::Elem -# wrong constant name assignment? -# wrong constant name name -# wrong constant name name= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# undefined method `initialize1' for class `RuboCop::Cop::VariableForce::VariableTable' -# wrong constant name accessible_variables -# wrong constant name assign_to_variable -# wrong constant name current_scope -# wrong constant name current_scope_level -# wrong constant name declare_variable -# wrong constant name find_variable -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name invoke_hook -# wrong constant name pop_scope -# wrong constant name push_scope -# wrong constant name reference_variable -# wrong constant name scope_stack -# wrong constant name variable_exist? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name column -# wrong constant name cop -# wrong constant name initialize -# wrong constant name line -# wrong constant name -# wrong constant name -# wrong constant name comment_config -# wrong constant name disabled_line_ranges -# wrong constant name -# wrong constant name -# wrong constant name find_file_upwards -# wrong constant name find_files_upwards -# wrong constant name -# wrong constant name root_level= -# wrong constant name root_level? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Formatter::AutoGenConfigFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::AutoGenConfigFormatter::DOT -# uninitialized constant RuboCop::Formatter::AutoGenConfigFormatter::ELLIPSES -# wrong constant name -# undefined method `initialize1' for class `RuboCop::Formatter::BaseFormatter' -# wrong constant name file_finished -# wrong constant name file_started -# wrong constant name finished -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name options -# wrong constant name output -# wrong constant name started -# wrong constant name -# uninitialized constant RuboCop::Formatter::ClangStyleFormatter::COLOR_FOR_SEVERITY -# wrong constant name -# wrong constant name black -# wrong constant name blue -# wrong constant name colorize -# wrong constant name cyan -# wrong constant name green -# wrong constant name magenta -# wrong constant name rainbow -# wrong constant name red -# wrong constant name white -# wrong constant name yellow -# wrong constant name -# wrong constant name file_started -# wrong constant name finished -# wrong constant name -# wrong constant name config_to_allow_offenses -# wrong constant name config_to_allow_offenses= -# wrong constant name detected_styles -# wrong constant name detected_styles= -# wrong constant name -# wrong constant name -# undefined method `add_formatter1' for class `RuboCop::Formatter::FormatterSet' -# undefined method `initialize1' for class `RuboCop::Formatter::FormatterSet' -# uninitialized constant RuboCop::Formatter::FormatterSet::DEFAULT_INDENT -# uninitialized constant RuboCop::Formatter::FormatterSet::Elem -# wrong constant name add_formatter1 -# wrong constant name add_formatter -# wrong constant name close_output_files -# wrong constant name file_finished -# wrong constant name file_started -# wrong constant name finished -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name started -# wrong constant name -# uninitialized constant RuboCop::Formatter::FuubarStyleFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::FuubarStyleFormatter::ELLIPSES -# wrong constant name initialize -# wrong constant name progressbar_color -# wrong constant name started -# wrong constant name with_color -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name files -# wrong constant name render_html -# wrong constant name summary -# uninitialized constant RuboCop::Formatter::HTMLFormatter::Color::Elem -# wrong constant name alpha -# wrong constant name alpha= -# wrong constant name blue -# wrong constant name blue= -# wrong constant name fade_out -# wrong constant name green -# wrong constant name green= -# wrong constant name red -# wrong constant name red= -# wrong constant name -# wrong constant name [] -# wrong constant name members -# wrong constant name base64_encoded_logo_image -# wrong constant name decorated_message -# wrong constant name escape -# wrong constant name files -# wrong constant name highlighted_source_line -# wrong constant name hightlight_source_tag -# wrong constant name initialize -# wrong constant name possible_ellipses -# wrong constant name source_after_highlight -# wrong constant name source_before_highlight -# wrong constant name summary -# wrong constant name -# wrong constant name -# wrong constant name hash_for_file -# wrong constant name hash_for_location -# wrong constant name hash_for_offense -# wrong constant name metadata_hash -# wrong constant name output_hash -# wrong constant name -# wrong constant name classname_attribute_value -# wrong constant name finished -# wrong constant name offenses_for_cop -# wrong constant name relevant_for_output? -# wrong constant name -# wrong constant name file_finished -# wrong constant name finished -# wrong constant name offense_counts -# wrong constant name ordered_offense_counts -# wrong constant name report_summary -# wrong constant name total_offense_count -# wrong constant name -# uninitialized constant RuboCop::Formatter::PacmanFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::PacmanFormatter::ELLIPSES -# wrong constant name cols -# wrong constant name file_started -# wrong constant name next_step -# wrong constant name pacdots -# wrong constant name progress_line -# wrong constant name progress_line= -# wrong constant name started -# wrong constant name step -# wrong constant name update_progress_line -# wrong constant name -# uninitialized constant RuboCop::Formatter::ProgressFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::ProgressFormatter::ELLIPSES -# wrong constant name report_file_as_mark -# wrong constant name started -# wrong constant name -# uninitialized constant RuboCop::Formatter::QuietFormatter::COLOR_FOR_SEVERITY -# wrong constant name -# wrong constant name -# wrong constant name report_file -# wrong constant name report_summary -# wrong constant name started -# wrong constant name initialize -# wrong constant name summary -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::Formatter::TapFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::TapFormatter::ELLIPSES -# wrong constant name started -# wrong constant name -# undefined singleton method `pluralize1' for `RuboCop::Formatter::TextUtil' -# wrong constant name -# wrong constant name pluralize1 -# wrong constant name pluralize -# wrong constant name finished -# wrong constant name offense_counts -# wrong constant name ordered_offense_counts -# wrong constant name report_summary -# wrong constant name total_offense_count -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name any? -# wrong constant name encoding_specified? -# wrong constant name frozen_string_literal -# wrong constant name frozen_string_literal? -# wrong constant name frozen_string_literal_specified? -# wrong constant name initialize -# wrong constant name valid_literal_value? -# uninitialized constant RuboCop::MagicComment::EditorComment::TOKEN -# wrong constant name -# uninitialized constant RuboCop::MagicComment::EmacsComment::TOKEN -# wrong constant name encoding -# wrong constant name -# uninitialized constant RuboCop::MagicComment::SimpleComment::TOKEN -# wrong constant name encoding -# wrong constant name -# uninitialized constant RuboCop::MagicComment::VimComment::TOKEN -# wrong constant name encoding -# wrong constant name -# wrong constant name -# wrong constant name parse -# wrong constant name -# wrong constant name find_similar_name -# wrong constant name find_similar_names -# wrong constant name -# wrong constant name parse -# wrong constant name -# wrong constant name -# wrong constant name boolean_or_empty_cache? -# wrong constant name display_only_fail_level_offenses_with_autocorrect? -# wrong constant name except_syntax? -# wrong constant name incompatible_options -# wrong constant name initialize -# wrong constant name only_includes_redundant_disable? -# wrong constant name validate_auto_correct -# wrong constant name validate_auto_gen_config -# wrong constant name validate_compatibility -# wrong constant name validate_cop_options -# wrong constant name validate_display_only_failed -# wrong constant name validate_exclude_limit_option -# wrong constant name validate_parallel -# wrong constant name validate_parallel_with_combo_option -# wrong constant name -# wrong constant name validate_cop_list -# undefined singleton method `relative_path1' for `RuboCop::PathUtil' -# wrong constant name -# wrong constant name absolute? -# wrong constant name chdir -# wrong constant name hidden_dir? -# wrong constant name hidden_file_in_not_hidden_dir? -# wrong constant name match_path? -# wrong constant name pwd -# wrong constant name relative_path1 -# wrong constant name relative_path -# wrong constant name reset_pwd -# wrong constant name smart_path -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name defaults! -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name windows? -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name indent_for -# wrong constant name initialize -# wrong constant name offending_tokens -# wrong constant name -# uninitialized constant RuboCop::RSpec::BlankLineSeparation::BYTE_ORDER_MARK -# wrong constant name autocorrect -# wrong constant name last_child? -# wrong constant name missing_separating_line -# wrong constant name offending_loc -# wrong constant name -# wrong constant name == -# uninitialized constant RuboCop::RSpec::Concept::ALL -# uninitialized constant RuboCop::RSpec::Concept::RSPEC -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name node -# wrong constant name to_node -# wrong constant name -# wrong constant name -# uninitialized constant RuboCop::RSpec::Corrector::MoveNode::BYTE_ORDER_MARK -# wrong constant name corrector -# wrong constant name initialize -# wrong constant name move_after -# wrong constant name move_before -# wrong constant name original -# wrong constant name processed_source -# wrong constant name -# wrong constant name -# undefined method `extract_doc_string1' for class `RuboCop::RSpec::Example' -# undefined method `extract_implementation1' for class `RuboCop::RSpec::Example' -# undefined method `extract_metadata1' for class `RuboCop::RSpec::Example' -# uninitialized constant RuboCop::RSpec::Example::ALL -# uninitialized constant RuboCop::RSpec::Example::RSPEC -# wrong constant name definition -# wrong constant name doc_string -# wrong constant name extract_doc_string1 -# wrong constant name extract_doc_string -# wrong constant name extract_implementation1 -# wrong constant name extract_implementation -# wrong constant name extract_metadata1 -# wrong constant name extract_metadata -# wrong constant name implementation -# wrong constant name metadata -# wrong constant name -# undefined method `scope_change?1' for class `RuboCop::RSpec::ExampleGroup' -# uninitialized constant RuboCop::RSpec::ExampleGroup::ALL -# uninitialized constant RuboCop::RSpec::ExampleGroup::RSPEC -# wrong constant name examples -# wrong constant name hooks -# wrong constant name scope_change?1 -# wrong constant name scope_change? -# wrong constant name subjects -# wrong constant name # undefined method `expect_correction1' for module `RuboCop::RSpec::ExpectOffense' # undefined method `expect_no_offenses1' for module `RuboCop::RSpec::ExpectOffense' # undefined method `expect_offense1' for module `RuboCop::RSpec::ExpectOffense' @@ -29433,149 +11315,6 @@ # wrong constant name # wrong constant name parse # wrong constant name -# wrong constant name -# wrong constant name attribute_defining_methods -# wrong constant name reserved_methods -# wrong constant name final_end_location -# wrong constant name -# undefined method `extract_metadata1' for class `RuboCop::RSpec::Hook' -# uninitialized constant RuboCop::RSpec::Hook::ALL -# uninitialized constant RuboCop::RSpec::Hook::RSPEC -# wrong constant name example? -# wrong constant name extract_metadata1 -# wrong constant name extract_metadata -# wrong constant name knowable_scope? -# wrong constant name metadata -# wrong constant name name -# wrong constant name scope -# wrong constant name -# wrong constant name -# wrong constant name defaults! -# wrong constant name -# undefined method `example?1' for module `RuboCop::RSpec::Language::NodePattern' -# undefined method `example_group?1' for module `RuboCop::RSpec::Language::NodePattern' -# undefined method `example_group_with_body?1' for module `RuboCop::RSpec::Language::NodePattern' -# undefined method `hook?1' for module `RuboCop::RSpec::Language::NodePattern' -# undefined method `let?1' for module `RuboCop::RSpec::Language::NodePattern' -# undefined method `subject?1' for module `RuboCop::RSpec::Language::NodePattern' -# wrong constant name example?1 -# wrong constant name example? -# wrong constant name example_group?1 -# wrong constant name example_group? -# wrong constant name example_group_with_body?1 -# wrong constant name example_group_with_body? -# wrong constant name hook?1 -# wrong constant name hook? -# wrong constant name let?1 -# wrong constant name let? -# wrong constant name subject?1 -# wrong constant name subject? -# wrong constant name -# wrong constant name -# wrong constant name recursive_literal_or_const? -# wrong constant name -# wrong constant name on_send -# wrong constant name -# undefined method `variable_definition?1' for module `RuboCop::RSpec::Variable' -# uninitialized constant RuboCop::RSpec::Variable::ALL -# uninitialized constant RuboCop::RSpec::Variable::RSPEC -# wrong constant name variable_definition?1 -# wrong constant name variable_definition? -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name rewrite -# wrong constant name -# wrong constant name -# wrong constant name file -# wrong constant name inherit_from_remote -# wrong constant name initialize -# wrong constant name uri -# wrong constant name -# undefined method `initialize1' for class `RuboCop::ResultCache' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name load -# wrong constant name save -# wrong constant name valid? -# undefined singleton method `cleanup1' for `RuboCop::ResultCache' -# wrong constant name -# wrong constant name allow_symlinks_in_cache_location? -# wrong constant name cache_root -# wrong constant name cleanup1 -# wrong constant name cleanup -# wrong constant name inhibit_cleanup -# wrong constant name inhibit_cleanup= -# wrong constant name source_checksum -# wrong constant name source_checksum= -# wrong constant name -# wrong constant name aborting= -# wrong constant name aborting? -# wrong constant name errors -# wrong constant name initialize -# wrong constant name run -# wrong constant name warnings -# wrong constant name initialize -# wrong constant name offenses -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name interpret -# undefined method `initialize1' for class `RuboCop::TargetFinder' -# undefined method `target_files_in_dir1' for class `RuboCop::TargetFinder' -# wrong constant name all_cops_include -# wrong constant name configured_include? -# wrong constant name debug? -# wrong constant name excluded_dirs -# wrong constant name fail_fast? -# wrong constant name find -# wrong constant name find_files -# wrong constant name force_exclusion? -# wrong constant name included_file? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name process_explicit_path -# wrong constant name ruby_executable? -# wrong constant name ruby_extension? -# wrong constant name ruby_extensions -# wrong constant name ruby_file? -# wrong constant name ruby_filename? -# wrong constant name ruby_filenames -# wrong constant name ruby_interpreters -# wrong constant name stdin? -# wrong constant name target_files_in_dir1 -# wrong constant name target_files_in_dir -# wrong constant name to_inspect? -# wrong constant name toplevel_dirs -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name rubocop_version_with_support -# wrong constant name source -# wrong constant name supported? -# wrong constant name version -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name name -# wrong constant name version -# wrong constant name -# wrong constant name -# wrong constant name supported_versions -# wrong constant name -# undefined singleton method `version1' for `RuboCop::Version' -# wrong constant name -# wrong constant name version1 -# wrong constant name version -# wrong constant name -# wrong constant name -# wrong constant name check # undefined method `Fail1' for class `RubyLex' # undefined method `Raise1' for class `RubyLex' # undefined method `identify_string1' for class `RubyLex' @@ -31336,7 +13075,7 @@ # wrong constant name # wrong constant name # wrong constant name -# undefined method `weighted_euclidean_distance_to1' for module `#' +# undefined method `weighted_euclidean_distance_to1' for module `#' # wrong constant name weighted_euclidean_distance_to1 # wrong constant name weighted_euclidean_distance_to # wrong constant name @@ -31379,535 +13118,26 @@ # wrong constant name coloring? # wrong constant name create_color_method # wrong constant name -# undefined method `help1' for class `Thor' -# undefined method `help2' for class `Thor' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# uninitialized constant Thor::SHELL_DELEGATED_METHODS -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name help1 -# wrong constant name help2 -# wrong constant name help -# undefined method `apply1' for module `Thor::Actions' -# undefined method `chmod1' for module `Thor::Actions' -# undefined method `empty_directory1' for module `Thor::Actions' -# undefined method `initialize1' for module `Thor::Actions' -# undefined method `initialize2' for module `Thor::Actions' -# undefined method `initialize3' for module `Thor::Actions' -# undefined method `inside1' for module `Thor::Actions' -# undefined method `inside2' for module `Thor::Actions' -# undefined method `relative_to_original_destination_root1' for module `Thor::Actions' -# undefined method `remove_dir1' for module `Thor::Actions' -# undefined method `remove_file1' for module `Thor::Actions' -# undefined method `run1' for module `Thor::Actions' -# undefined method `run_ruby_script1' for module `Thor::Actions' -# wrong constant name _cleanup_options_and_set -# wrong constant name _shared_configuration -# wrong constant name action -# wrong constant name add_file -# wrong constant name add_link -# wrong constant name append_file -# wrong constant name append_to_file -# wrong constant name apply1 -# wrong constant name apply -# wrong constant name behavior -# wrong constant name behavior= -# wrong constant name chmod1 -# wrong constant name chmod -# wrong constant name comment_lines -# wrong constant name copy_file -# wrong constant name create_file -# wrong constant name create_link -# wrong constant name destination_root -# wrong constant name destination_root= -# wrong constant name directory -# wrong constant name empty_directory1 -# wrong constant name empty_directory -# wrong constant name find_in_source_paths -# wrong constant name get -# wrong constant name gsub_file -# wrong constant name in_root -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name inject_into_class -# wrong constant name inject_into_file -# wrong constant name inject_into_module -# wrong constant name insert_into_file -# wrong constant name inside1 -# wrong constant name inside2 -# wrong constant name inside -# wrong constant name link_file -# wrong constant name prepend_file -# wrong constant name prepend_to_file -# wrong constant name relative_to_original_destination_root1 -# wrong constant name relative_to_original_destination_root -# wrong constant name remove_dir1 -# wrong constant name remove_dir -# wrong constant name remove_file1 -# wrong constant name remove_file -# wrong constant name run1 -# wrong constant name run -# wrong constant name run_ruby_script1 -# wrong constant name run_ruby_script -# wrong constant name source_paths -# wrong constant name template -# wrong constant name thor -# wrong constant name uncomment_lines -# wrong constant name -# wrong constant name included -# wrong constant name -# undefined method `initialize1' for class `Thor::Argument' # wrong constant name banner -# wrong constant name default -# wrong constant name default_banner -# wrong constant name description -# wrong constant name enum -# wrong constant name human_name -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name name -# wrong constant name required -# wrong constant name required? -# wrong constant name show_default? -# wrong constant name type -# wrong constant name usage -# wrong constant name valid_type? -# wrong constant name validate! -# wrong constant name -# undefined method `initialize1' for class `Thor::Arguments' -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name parse -# wrong constant name remaining -# wrong constant name -# wrong constant name parse -# wrong constant name split -# undefined method `initialize1' for module `Thor::Base' -# undefined method `initialize2' for module `Thor::Base' -# undefined method `initialize3' for module `Thor::Base' -# wrong constant name args -# wrong constant name args= -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name options -# wrong constant name options= -# wrong constant name parent_options -# wrong constant name parent_options= -# wrong constant name -# wrong constant name included -# wrong constant name register_klass_file -# wrong constant name shell -# wrong constant name shell= -# wrong constant name subclass_files -# wrong constant name subclasses -# undefined method `formatted_usage1' for class `Thor::Command' -# undefined method `formatted_usage2' for class `Thor::Command' -# undefined method `initialize1' for class `Thor::Command' -# undefined method `run1' for class `Thor::Command' -# wrong constant name formatted_usage1 -# wrong constant name formatted_usage2 -# wrong constant name formatted_usage -# wrong constant name handle_argument_error? -# wrong constant name handle_no_method_error? -# wrong constant name hidden? -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name local_method? -# wrong constant name not_debugging? -# wrong constant name private_method? -# wrong constant name public_method? -# wrong constant name required_arguments_for -# wrong constant name required_options -# wrong constant name run1 -# wrong constant name run -# wrong constant name sans_backtrace -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Thor::CoreExt::HashWithIndifferentAccess' -# uninitialized constant Thor::CoreExt::HashWithIndifferentAccess::DEFAULT_INDENT -# uninitialized constant Thor::CoreExt::HashWithIndifferentAccess::Elem -# uninitialized constant Thor::CoreExt::HashWithIndifferentAccess::K -# uninitialized constant Thor::CoreExt::HashWithIndifferentAccess::V -# wrong constant name [] -# wrong constant name []= -# wrong constant name convert_key -# wrong constant name delete -# wrong constant name fetch -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name key? -# wrong constant name merge -# wrong constant name merge! -# wrong constant name method_missing -# wrong constant name replace -# wrong constant name reverse_merge -# wrong constant name reverse_merge! -# wrong constant name values_at -# wrong constant name -# wrong constant name -# undefined method `initialize1' for class `Thor::DynamicCommand' -# uninitialized constant Thor::DynamicCommand::FILE_REGEXP -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name -# wrong constant name -# undefined method `_invoke_for_class_method1' for class `Thor::Group' -# uninitialized constant Thor::Group::SHELL_DELEGATED_METHODS -# wrong constant name _invoke_for_class_method1 -# wrong constant name _invoke_for_class_method -# undefined singleton method `desc1' for `Thor::Group' -# wrong constant name -# wrong constant name banner -# wrong constant name desc1 -# wrong constant name desc -# wrong constant name get_options_from_invocations -# wrong constant name handle_argument_error -# wrong constant name help -# wrong constant name invocation_blocks -# wrong constant name invocations -# wrong constant name invoke -# wrong constant name invoke_from_option -# wrong constant name printable_commands -# wrong constant name printable_tasks -# wrong constant name remove_invocation # wrong constant name self_command # wrong constant name self_task -# uninitialized constant Thor::HiddenCommand::FILE_REGEXP -# wrong constant name -# undefined method `_retrieve_class_and_command1' for module `Thor::Invocation' -# undefined method `_retrieve_class_and_task1' for module `Thor::Invocation' -# undefined method `initialize1' for module `Thor::Invocation' -# undefined method `initialize2' for module `Thor::Invocation' -# undefined method `initialize3' for module `Thor::Invocation' -# undefined method `invoke1' for module `Thor::Invocation' -# wrong constant name _parse_initialization_options -# wrong constant name _retrieve_class_and_command1 -# wrong constant name _retrieve_class_and_command -# wrong constant name _retrieve_class_and_task1 -# wrong constant name _retrieve_class_and_task -# wrong constant name _shared_configuration -# wrong constant name current_command_chain -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name invoke1 -# wrong constant name invoke -# wrong constant name invoke_all -# wrong constant name invoke_command -# wrong constant name invoke_task -# wrong constant name invoke_with_padding -# wrong constant name -# wrong constant name included -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name options -# wrong constant name prompt -# wrong constant name readline -# wrong constant name -# wrong constant name available? -# wrong constant name -# wrong constant name initialize -# wrong constant name matches -# wrong constant name -# wrong constant name -# undefined singleton method `readline1' for `Thor::LineEditor' -# wrong constant name -# wrong constant name best_available -# wrong constant name readline1 -# wrong constant name readline -# wrong constant name -# wrong constant name enter -# wrong constant name entered? -# wrong constant name -# undefined method `usage1' for class `Thor::Option' -# wrong constant name aliases -# wrong constant name array? -# wrong constant name boolean? -# wrong constant name dasherize -# wrong constant name dasherized? -# wrong constant name group -# wrong constant name hash? -# wrong constant name hide -# wrong constant name lazy_default -# wrong constant name numeric? -# wrong constant name repeatable -# wrong constant name string? -# wrong constant name switch_name -# wrong constant name undasherize -# wrong constant name usage1 -# wrong constant name usage -# wrong constant name validate_default_type! -# wrong constant name -# wrong constant name parse -# undefined method `initialize1' for class `Thor::Options' -# undefined method `initialize2' for class `Thor::Options' -# undefined method `initialize3' for class `Thor::Options' -# undefined method `initialize4' for class `Thor::Options' -# uninitialized constant Thor::Options::NUMERIC -# wrong constant name assign_result! -# wrong constant name check_unknown! -# wrong constant name current_is_switch? -# wrong constant name current_is_switch_formatted? -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize4 -# wrong constant name initialize -# wrong constant name normalize_switch -# wrong constant name parse_boolean -# wrong constant name parse_peek -# wrong constant name parsing_options? -# wrong constant name switch? -# wrong constant name switch_option -# wrong constant name -# wrong constant name to_switches -# wrong constant name -# wrong constant name -# undefined method `initialize1' for module `Thor::Shell' -# undefined method `initialize2' for module `Thor::Shell' -# undefined method `initialize3' for module `Thor::Shell' -# wrong constant name -# wrong constant name -# wrong constant name _shared_configuration -# wrong constant name ask -# wrong constant name error -# wrong constant name file_collision -# wrong constant name initialize1 -# wrong constant name initialize2 -# wrong constant name initialize3 -# wrong constant name initialize -# wrong constant name no? -# wrong constant name print_in_columns -# wrong constant name print_table -# wrong constant name print_wrapped -# wrong constant name say -# wrong constant name say_status -# wrong constant name set_color -# wrong constant name shell -# wrong constant name shell= -# wrong constant name terminal_width -# wrong constant name with_padding -# wrong constant name yes? -# undefined method `indent1' for class `Thor::Shell::Basic' -# undefined method `no?1' for class `Thor::Shell::Basic' -# undefined method `print_table1' for class `Thor::Shell::Basic' -# undefined method `print_wrapped1' for class `Thor::Shell::Basic' -# undefined method `say1' for class `Thor::Shell::Basic' -# undefined method `say2' for class `Thor::Shell::Basic' -# undefined method `say3' for class `Thor::Shell::Basic' -# undefined method `say_status1' for class `Thor::Shell::Basic' -# undefined method `yes?1' for class `Thor::Shell::Basic' -# wrong constant name answer_match -# wrong constant name as_unicode -# wrong constant name ask -# wrong constant name ask_filtered -# wrong constant name ask_simply -# wrong constant name base -# wrong constant name base= -# wrong constant name can_display_colors? -# wrong constant name dynamic_width -# wrong constant name dynamic_width_stty -# wrong constant name dynamic_width_tput -# wrong constant name error -# wrong constant name file_collision -# wrong constant name file_collision_help -# wrong constant name git_merge_tool -# wrong constant name indent1 -# wrong constant name indent -# wrong constant name is? -# wrong constant name lookup_color -# wrong constant name merge -# wrong constant name merge_tool -# wrong constant name mute -# wrong constant name mute? -# wrong constant name no?1 -# wrong constant name no? -# wrong constant name padding -# wrong constant name padding= -# wrong constant name prepare_message -# wrong constant name print_in_columns -# wrong constant name print_table1 -# wrong constant name print_table -# wrong constant name print_wrapped1 -# wrong constant name print_wrapped -# wrong constant name quiet? -# wrong constant name say1 -# wrong constant name say2 -# wrong constant name say3 -# wrong constant name say -# wrong constant name say_status1 -# wrong constant name say_status -# wrong constant name set_color -# wrong constant name show_diff -# wrong constant name stderr -# wrong constant name stdout -# wrong constant name terminal_width -# wrong constant name truncate -# wrong constant name unix? -# wrong constant name yes?1 -# wrong constant name yes? -# wrong constant name -# uninitialized constant Thor::Shell::Color::DEFAULT_TERMINAL_WIDTH -# wrong constant name are_colors_disabled? -# wrong constant name diff_lcs_loaded? -# wrong constant name output_diff_line -# wrong constant name set_color -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name all_commands -# wrong constant name command -# wrong constant name initialize -# wrong constant name corrections -# wrong constant name error -# wrong constant name initialize -# wrong constant name spell_checker -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name initialize -# wrong constant name switches -# wrong constant name unknown -# wrong constant name corrections -# wrong constant name error -# wrong constant name initialize -# wrong constant name spell_checker -# wrong constant name -# wrong constant name -# undefined singleton method `find_class_and_command_by_namespace1' for `Thor::Util' -# undefined singleton method `find_class_and_task_by_namespace1' for `Thor::Util' -# undefined singleton method `load_thorfile1' for `Thor::Util' -# undefined singleton method `load_thorfile2' for `Thor::Util' -# undefined singleton method `namespaces_in_content1' for `Thor::Util' -# wrong constant name -# wrong constant name camel_case -# wrong constant name escape_globs -# wrong constant name escape_html -# wrong constant name find_by_namespace -# wrong constant name find_class_and_command_by_namespace1 -# wrong constant name find_class_and_command_by_namespace -# wrong constant name find_class_and_task_by_namespace1 -# wrong constant name find_class_and_task_by_namespace -# wrong constant name globs_for -# wrong constant name load_thorfile1 -# wrong constant name load_thorfile2 -# wrong constant name load_thorfile -# wrong constant name namespace_from_thor_class -# wrong constant name namespaces_in_content1 -# wrong constant name namespaces_in_content -# wrong constant name ruby_command -# wrong constant name snake_case -# wrong constant name thor_classes_in -# wrong constant name thor_root -# wrong constant name thor_root_glob -# wrong constant name user_home # undefined singleton method `banner1' for `Thor' # undefined singleton method `banner2' for `Thor' -# undefined singleton method `check_unknown_options!1' for `Thor' -# undefined singleton method `default_command1' for `Thor' -# undefined singleton method `default_task1' for `Thor' -# undefined singleton method `desc1' for `Thor' -# undefined singleton method `help1' for `Thor' -# undefined singleton method `long_desc1' for `Thor' -# undefined singleton method `map1' for `Thor' -# undefined singleton method `method_option1' for `Thor' -# undefined singleton method `method_options1' for `Thor' -# undefined singleton method `option1' for `Thor' -# undefined singleton method `options1' for `Thor' -# undefined singleton method `package_name1' for `Thor' -# undefined singleton method `printable_commands1' for `Thor' -# undefined singleton method `printable_commands2' for `Thor' -# undefined singleton method `printable_tasks1' for `Thor' -# undefined singleton method `printable_tasks2' for `Thor' -# undefined singleton method `register1' for `Thor' -# wrong constant name # wrong constant name banner1 # wrong constant name banner2 # wrong constant name banner -# wrong constant name check_unknown_options!1 -# wrong constant name check_unknown_options! -# wrong constant name command_help -# wrong constant name default_command1 -# wrong constant name default_command -# wrong constant name default_task1 -# wrong constant name default_task -# wrong constant name deprecation_warning -# wrong constant name desc1 -# wrong constant name desc # wrong constant name disable_required_check -# wrong constant name disable_required_check! -# wrong constant name disable_required_check? # wrong constant name dispatch # wrong constant name dynamic_command_class # wrong constant name find_command_possibilities # wrong constant name find_task_possibilities -# wrong constant name help1 -# wrong constant name help -# wrong constant name long_desc1 -# wrong constant name long_desc -# wrong constant name map1 -# wrong constant name map -# wrong constant name method_option1 -# wrong constant name method_option -# wrong constant name method_options1 -# wrong constant name method_options # wrong constant name normalize_command_name # wrong constant name normalize_task_name -# wrong constant name option1 -# wrong constant name option -# wrong constant name options1 -# wrong constant name options -# wrong constant name package_name1 -# wrong constant name package_name -# wrong constant name printable_commands1 -# wrong constant name printable_commands2 -# wrong constant name printable_commands -# wrong constant name printable_tasks1 -# wrong constant name printable_tasks2 -# wrong constant name printable_tasks -# wrong constant name register1 -# wrong constant name register # wrong constant name retrieve_command_name # wrong constant name retrieve_task_name # wrong constant name stop_on_unknown_option -# wrong constant name stop_on_unknown_option! -# wrong constant name stop_on_unknown_option? -# wrong constant name subcommand -# wrong constant name subcommand_classes # wrong constant name subcommand_help -# wrong constant name subcommands -# wrong constant name subtask # wrong constant name subtask_help -# wrong constant name subtasks -# wrong constant name task_help # wrong constant name # wrong constant name # wrong constant name @@ -32931,12 +14161,6 @@ # wrong constant name strikethrough # wrong constant name underline # wrong constant name yellow -# wrong constant name -# wrong constant name normalize -# wrong constant name -# wrong constant name instance -# wrong constant name normalize -# wrong constant name # wrong constant name # undefined singleton method `new21' for `URI::FTP' # undefined singleton method `new22' for `URI::FTP' @@ -33012,23 +14236,6 @@ # wrong constant name trust_cert # wrong constant name user_agent # wrong constant name using -# wrong constant name -# undefined singleton method `emoji_extra_width_of1' for `Unicode::DisplayWidth' -# undefined singleton method `emoji_extra_width_of2' for `Unicode::DisplayWidth' -# undefined singleton method `emoji_extra_width_of3' for `Unicode::DisplayWidth' -# undefined singleton method `of1' for `Unicode::DisplayWidth' -# undefined singleton method `of2' for `Unicode::DisplayWidth' -# undefined singleton method `of3' for `Unicode::DisplayWidth' -# wrong constant name -# wrong constant name emoji_extra_width_of1 -# wrong constant name emoji_extra_width_of2 -# wrong constant name emoji_extra_width_of3 -# wrong constant name emoji_extra_width_of -# wrong constant name of1 -# wrong constant name of2 -# wrong constant name of3 -# wrong constant name of -# wrong constant name # wrong constant name # wrong constant name [] # wrong constant name []= @@ -33076,72 +14283,6 @@ # uninitialized constant WEBrick::Utils # uninitialized constant WEBrick::Utils # wrong constant name initialize -# undefined method `initialize1' for class `WebRobots' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name allowed? -# wrong constant name crawl_delay -# wrong constant name create_cache -# wrong constant name disallowed? -# wrong constant name error -# wrong constant name error! -# wrong constant name flush_cache -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name option -# wrong constant name options -# wrong constant name reset -# wrong constant name sitemaps -# wrong constant name user_agent -# wrong constant name -# wrong constant name initialize -# wrong constant name site -# wrong constant name -# undefined method `allow?1' for class `WebRobots::RobotsTxt' -# undefined method `crawl_delay1' for class `WebRobots::RobotsTxt' -# undefined method `initialize1' for class `WebRobots::RobotsTxt' -# undefined method `options1' for class `WebRobots::RobotsTxt' -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name -# wrong constant name allow?1 -# wrong constant name allow? -# wrong constant name crawl_delay1 -# wrong constant name crawl_delay -# wrong constant name error -# wrong constant name error! -# wrong constant name error= -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name options1 -# wrong constant name options -# wrong constant name site -# wrong constant name sitemaps -# wrong constant name timestamp -# wrong constant name match? -# wrong constant name -# wrong constant name pattern -# wrong constant name -# wrong constant name allow? -# wrong constant name -# wrong constant name delay -# wrong constant name -# wrong constant name allow? -# wrong constant name -# wrong constant name -# wrong constant name compile -# wrong constant name initialize -# wrong constant name token -# wrong constant name value -# wrong constant name -# undefined method `initialize1' for class `WebRobots::RobotsTxt::Parser' # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_Main_Parsing_Routine # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_Runtime_Core_Id_C # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_Runtime_Core_Revision @@ -33154,44 +14295,6 @@ # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_Runtime_Type # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_Runtime_Version # uninitialized constant WebRobots::RobotsTxt::Parser::Racc_YY_Parse_Method -# wrong constant name _reduce_1 -# wrong constant name _reduce_17 -# wrong constant name _reduce_18 -# wrong constant name _reduce_19 -# wrong constant name _reduce_2 -# wrong constant name _reduce_20 -# wrong constant name _reduce_21 -# wrong constant name _reduce_24 -# wrong constant name _reduce_25 -# wrong constant name _reduce_26 -# wrong constant name _reduce_28 -# wrong constant name _reduce_31 -# wrong constant name _reduce_32 -# wrong constant name _reduce_38 -# wrong constant name _reduce_39 -# wrong constant name _reduce_40 -# wrong constant name _reduce_41 -# wrong constant name _reduce_none -# wrong constant name initialize1 -# wrong constant name initialize -# wrong constant name on_error -# wrong constant name parse -# wrong constant name parse! -# wrong constant name parse_error -# wrong constant name -# wrong constant name allow? -# wrong constant name default? -# wrong constant name delay -# wrong constant name initialize -# wrong constant name match? -# wrong constant name options -# wrong constant name -# undefined singleton method `unfetchable1' for `WebRobots::RobotsTxt' -# wrong constant name -# wrong constant name unfetchable1 -# wrong constant name unfetchable -# wrong constant name -# wrong constant name # wrong constant name # wrong constant name # wrong constant name diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index 1604f58231..8cc6dd1179 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -3,80 +3,6 @@ # typed: autogenerated -module AST -end - -class AST::Node - def +(array); end - - def <<(element); end - - def ==(other); end - - def append(element); end - - def assign_properties(properties); end - - def children(); end - - def clone(); end - - def concat(array); end - - def eql?(other); end - - def fancy_type(); end - - def initialize(type, children=T.unsafe(nil), properties=T.unsafe(nil)); end - - def inspect(indent=T.unsafe(nil)); end - - def to_a(); end - - def to_ast(); end - - def to_s(indent=T.unsafe(nil)); end - - def to_sexp(indent=T.unsafe(nil)); end - - def to_sexp_array(); end - - def type(); end - - def updated(type=T.unsafe(nil), children=T.unsafe(nil), properties=T.unsafe(nil)); end -end - -class AST::Node -end - -class AST::Processor - include ::AST::Processor::Mixin -end - -module AST::Processor::Mixin - def handler_missing(node); end - - def process(node); end - - def process_all(nodes); end -end - -module AST::Processor::Mixin -end - -class AST::Processor -end - -module AST::Sexp - def s(type, *children); end -end - -module AST::Sexp -end - -module AST -end - class AbstractDownloadStrategy include ::FileUtils::StreamUtils_ end @@ -2983,8 +2909,6 @@ class Addrinfo end class Array - include ::JSON::Ext::Generator::GeneratorMethods::Array - include ::Plist::Emit def excluding(*elements); end def extract_options!(); end @@ -5457,8 +5381,6 @@ module Byebug def self.actual_port(); end - def self.attach(); end - def self.handle_post_mortem(); end def self.interrupt(); end @@ -5467,8 +5389,6 @@ module Byebug def self.parse_host_and_port(host_port_spec); end - def self.spawn(host=T.unsafe(nil), port=T.unsafe(nil)); end - def self.start_client(host=T.unsafe(nil), port=T.unsafe(nil)); end def self.start_control(host=T.unsafe(nil), port=T.unsafe(nil)); end @@ -5934,8 +5854,6 @@ class Class def any_instance(); end def class_attribute(*attrs, instance_accessor: T.unsafe(nil), instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_predicate: T.unsafe(nil), default: T.unsafe(nil)); end - - def json_creatable?(); end end module CodeRay @@ -6325,2346 +6243,14 @@ class CompilerSelector::Compiler def self.members(); end end -module Concurrent - NULL = ::T.let(nil, ::T.untyped) - NULL_LOGGER = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Concurrent::AbstractExchanger - def exchange(value, timeout=T.unsafe(nil)); end - - def exchange!(value, timeout=T.unsafe(nil)); end - - def try_exchange(value, timeout=T.unsafe(nil)); end -end - -class Concurrent::AbstractExchanger -end - -class Concurrent::AbstractExecutorService - include ::Concurrent::ExecutorService - include ::Concurrent::Concern::Deprecation - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def auto_terminate=(value); end - - def auto_terminate?(); end - - def fallback_policy(); end - - def initialize(opts=T.unsafe(nil), &block); end - - def kill(); end - - def name(); end - - def running?(); end - - def shutdown(); end - - def shutdown?(); end - - def shuttingdown?(); end - - def wait_for_termination(timeout=T.unsafe(nil)); end - FALLBACK_POLICIES = ::T.let(nil, ::T.untyped) -end - -class Concurrent::AbstractExecutorService -end - -class Concurrent::AbstractThreadLocalVar - def allocate_storage(); end - - def bind(value, &block); end - - def default(); end - - def initialize(default=T.unsafe(nil), &default_block); end - - def value(); end - - def value=(value); end -end - -class Concurrent::AbstractThreadLocalVar -end - -class Concurrent::Agent - include ::Concurrent::Concern::Observable - def <<(action); end - - def await(); end - - def await_for(timeout); end - - def await_for!(timeout); end - - def deref(); end - - def error(); end - - def error_mode(); end - - def failed?(); end - - def initialize(initial, opts=T.unsafe(nil)); end - - def post(*args, &action); end - - def reason(); end - - def restart(new_value, opts=T.unsafe(nil)); end - - def send(*args, &action); end - - def send!(*args, &action); end - - def send_off(*args, &action); end - - def send_off!(*args, &action); end - - def send_via(executor, *args, &action); end - - def send_via!(executor, *args, &action); end - - def stopped?(); end - - def value(); end - - def wait(timeout=T.unsafe(nil)); end -end - -class Concurrent::Agent::Error - def initialize(message=T.unsafe(nil)); end -end - -class Concurrent::Agent::Error -end - -class Concurrent::Agent::ValidationError -end - -class Concurrent::Agent::ValidationError -end - -class Concurrent::Agent - def self.await(*agents); end - - def self.await_for(timeout, *agents); end - - def self.await_for!(timeout, *agents); end -end - -class Concurrent::Array -end - -class Concurrent::Array -end - -module Concurrent::Async - def async(); end - - def await(); end - - def call(); end - - def cast(); end - - def init_synchronization(); end -end - -module Concurrent::Async - def self.included(base); end - - def self.validate_argc(obj, method, *args); end -end - -class Concurrent::Atom - include ::Concurrent::Concern::Observable - def compare_and_set(old_value, new_value); end - - def deref(); end - - def initialize(value, opts=T.unsafe(nil)); end - - def reset(new_value); end - - def swap(*args); end - - def value(); end -end - -class Concurrent::Atom - def self.new(*args, &block); end -end - -class Concurrent::AtomicBoolean -end - -class Concurrent::AtomicBoolean -end - -module Concurrent::AtomicDirectUpdate - def try_update(); end - - def try_update!(); end - - def update(); end -end - -module Concurrent::AtomicDirectUpdate -end - -class Concurrent::AtomicFixnum -end - -class Concurrent::AtomicFixnum -end - -class Concurrent::AtomicMarkableReference - def compare_and_set(expected_val, new_val, expected_mark, new_mark); end - - def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end - - def get(); end - - def initialize(value=T.unsafe(nil), mark=T.unsafe(nil)); end - - def mark(); end - - def marked?(); end - - def set(new_val, new_mark); end - - def try_update(); end - - def try_update!(); end - - def update(); end - - def value(); end -end - -class Concurrent::AtomicMarkableReference - def self.new(*args, &block); end -end - -module Concurrent::AtomicNumericCompareAndSetWrapper - def compare_and_set(old_value, new_value); end -end - -module Concurrent::AtomicNumericCompareAndSetWrapper -end - -class Concurrent::AtomicReference -end - -class Concurrent::AtomicReference -end - -class Concurrent::CachedThreadPool -end - -class Concurrent::CachedThreadPool -end - -class Concurrent::CancelledOperationError -end - -class Concurrent::CancelledOperationError -end - -module Concurrent::Collection -end - -class Concurrent::Collection::CopyOnNotifyObserverSet - def add_observer(observer=T.unsafe(nil), func=T.unsafe(nil), &block); end - - def count_observers(); end - - def delete_observer(observer); end - - def delete_observers(); end - - def initialize(); end - - def notify_and_delete_observers(*args, &block); end - - def notify_observers(*args, &block); end - - def ns_initialize(); end -end - -class Concurrent::Collection::CopyOnNotifyObserverSet -end - -class Concurrent::Collection::CopyOnWriteObserverSet - def add_observer(observer=T.unsafe(nil), func=T.unsafe(nil), &block); end - - def count_observers(); end - - def delete_observer(observer); end - - def delete_observers(); end - - def initialize(); end - - def notify_and_delete_observers(*args, &block); end - - def notify_observers(*args, &block); end - - def ns_initialize(); end -end - -class Concurrent::Collection::CopyOnWriteObserverSet -end - -Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend - -class Concurrent::Collection::MriMapBackend -end - -class Concurrent::Collection::MriMapBackend -end - -class Concurrent::Collection::NonConcurrentMapBackend - def [](key); end - - def []=(key, value); end - - def clear(); end - - def compute(key); end - - def compute_if_absent(key); end - - def compute_if_present(key); end - - def delete(key); end - - def delete_pair(key, value); end - - def each_pair(); end - - def get_and_set(key, value); end - - def get_or_default(key, default_value); end - - def initialize(options=T.unsafe(nil)); end - - def key?(key); end - - def merge_pair(key, value); end - - def replace_if_exists(key, new_value); end - - def replace_pair(key, old_value, new_value); end - - def size(); end -end - -class Concurrent::Collection::NonConcurrentMapBackend -end - -class Concurrent::Collection::NonConcurrentPriorityQueue -end - -class Concurrent::Collection::NonConcurrentPriorityQueue -end - -class Concurrent::Collection::RubyNonConcurrentPriorityQueue - def <<(item); end - - def clear(); end - - def delete(item); end - - def deq(); end - - def empty?(); end - - def enq(item); end - - def has_priority?(item); end - - def include?(item); end - - def initialize(opts=T.unsafe(nil)); end - - def length(); end - - def peek(); end - - def pop(); end - - def push(item); end - - def shift(); end - - def size(); end -end - -class Concurrent::Collection::RubyNonConcurrentPriorityQueue - def self.from_list(list, opts=T.unsafe(nil)); end -end - -module Concurrent::Collection -end - -module Concurrent::Concern -end - -module Concurrent::Concern::Deprecation - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def deprecated(message, strip=T.unsafe(nil)); end - - def deprecated_method(old_name, new_name); end -end - -module Concurrent::Concern::Deprecation - extend ::Concurrent::Concern::Deprecation - extend ::Concurrent::Concern::Logging - extend ::Logger::Severity -end - -module Concurrent::Concern::Dereferenceable - def apply_deref_options(value); end - - def deref(); end - - def ns_set_deref_options(opts); end - - def set_deref_options(opts=T.unsafe(nil)); end - - def value(); end - - def value=(value); end -end - -module Concurrent::Concern::Dereferenceable -end - -module Concurrent::Concern::Logging - include ::Logger::Severity - def log(level, progname, message=T.unsafe(nil), &block); end -end - -module Concurrent::Concern::Logging -end - -module Concurrent::Concern::Obligation - include ::Concurrent::Concern::Dereferenceable - def compare_and_set_state(next_state, *expected_current); end - - def complete?(); end - - def event(); end - - def exception(*args); end - - def fulfilled?(); end - - def get_arguments_from(opts=T.unsafe(nil)); end - - def if_state(*expected_states); end - - def incomplete?(); end - - def init_obligation(); end - - def no_error!(timeout=T.unsafe(nil)); end - - def ns_check_state?(expected); end - - def ns_set_state(value); end - - def pending?(); end - - def realized?(); end - - def reason(); end - - def rejected?(); end - - def set_state(success, value, reason); end - - def state(); end - - def state=(value); end - - def unscheduled?(); end - - def value(timeout=T.unsafe(nil)); end - - def value!(timeout=T.unsafe(nil)); end - - def wait(timeout=T.unsafe(nil)); end - - def wait!(timeout=T.unsafe(nil)); end -end - -module Concurrent::Concern::Obligation -end - -module Concurrent::Concern::Observable - def add_observer(observer=T.unsafe(nil), func=T.unsafe(nil), &block); end - - def count_observers(); end - - def delete_observer(observer); end - - def delete_observers(); end - - def observers(); end - - def observers=(observers); end - - def with_observer(observer=T.unsafe(nil), func=T.unsafe(nil), &block); end -end - -module Concurrent::Concern::Observable -end - -module Concurrent::Concern -end - -class Concurrent::ConcurrentUpdateError - CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped) -end - -class Concurrent::ConcurrentUpdateError -end - -class Concurrent::ConfigurationError -end - -class Concurrent::ConfigurationError -end - -class Concurrent::CountDownLatch -end - -class Concurrent::CountDownLatch -end - -class Concurrent::CyclicBarrier - def broken?(); end - - def initialize(parties, &block); end - - def ns_generation_done(generation, status, continue=T.unsafe(nil)); end - - def ns_initialize(parties, &block); end - - def ns_next_generation(); end - - def number_waiting(); end - - def parties(); end - - def reset(); end - - def wait(timeout=T.unsafe(nil)); end -end - -class Concurrent::CyclicBarrier -end - -class Concurrent::Delay - include ::Concurrent::Concern::Obligation - include ::Concurrent::Concern::Dereferenceable - def initialize(opts=T.unsafe(nil), &block); end - - def ns_initialize(opts, &block); end - - def reconfigure(&block); end -end - -class Concurrent::Delay -end - -class Concurrent::DependencyCounter - def initialize(count, &block); end - - def update(time, value, reason); end -end - -class Concurrent::DependencyCounter -end - -class Concurrent::Error -end - -class Concurrent::Error -end - -class Concurrent::Event - def initialize(); end - - def ns_initialize(); end - - def ns_set(); end - - def reset(); end - - def set(); end - - def set?(); end - - def try?(); end - - def wait(timeout=T.unsafe(nil)); end -end - -class Concurrent::Event -end - -class Concurrent::Exchanger -end - -class Concurrent::Exchanger -end - -module Concurrent::ExecutorService - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def <<(task); end - - def can_overflow?(); end - - def post(*args, &task); end - - def serialized?(); end -end - -module Concurrent::ExecutorService -end - -class Concurrent::FixedThreadPool - def initialize(num_threads, opts=T.unsafe(nil)); end -end - -class Concurrent::FixedThreadPool -end - -class Concurrent::Future - def cancel(); end - - def cancelled?(); end - - def execute(); end - - def initialize(opts=T.unsafe(nil), &block); end - - def set(value=T.unsafe(nil), &block); end - - def wait_or_cancel(timeout); end -end - -class Concurrent::Future - def self.execute(opts=T.unsafe(nil), &block); end -end - -class Concurrent::Hash -end - -class Concurrent::Hash -end - -class Concurrent::IVar - include ::Concurrent::Concern::Obligation - include ::Concurrent::Concern::Dereferenceable - include ::Concurrent::Concern::Observable - def check_for_block_or_value!(block_given, value); end - - def complete(success, value, reason); end - - def complete_without_notification(success, value, reason); end - - def fail(reason=T.unsafe(nil)); end - - def initialize(value=T.unsafe(nil), opts=T.unsafe(nil), &block); end - - def notify_observers(value, reason); end - - def ns_complete_without_notification(success, value, reason); end - - def ns_initialize(value, opts); end - - def safe_execute(task, args=T.unsafe(nil)); end - - def set(value=T.unsafe(nil)); end - - def try_set(value=T.unsafe(nil), &block); end -end - -class Concurrent::IVar -end - -class Concurrent::IllegalOperationError -end - -class Concurrent::IllegalOperationError -end - -class Concurrent::ImmediateExecutor - include ::Concurrent::SerialExecutorService - def initialize(); end -end - -class Concurrent::ImmediateExecutor -end - -class Concurrent::ImmutabilityError -end - -class Concurrent::ImmutabilityError -end - -module Concurrent::ImmutableStruct - include ::Concurrent::Synchronization::AbstractStruct - def ==(other); end - - def [](member); end - - def each(&block); end - - def each_pair(&block); end - - def inspect(); end - - def merge(other, &block); end - - def select(&block); end - - def to_a(); end - - def to_h(); end - - def to_s(); end - - def values(); end - - def values_at(*indexes); end -end - -module Concurrent::ImmutableStruct - def self.included(base); end - - def self.new(*args, &block); end -end - -class Concurrent::IndirectImmediateExecutor -end - -class Concurrent::IndirectImmediateExecutor -end - -class Concurrent::InitializationError -end - -class Concurrent::InitializationError -end - -class Concurrent::LifecycleError -end - -class Concurrent::LifecycleError -end - -class Concurrent::LockFreeStack - include ::Enumerable - def clear(); end - - def clear_each(&block); end - - def clear_if(head); end - - def compare_and_clear(head); end - - def compare_and_pop(head); end - - def compare_and_push(head, value); end - - def each(head=T.unsafe(nil), &blk); end - - def empty?(head=T.unsafe(nil)); end - - def initialize(head=T.unsafe(nil)); end - - def peek(); end - - def pop(); end - - def push(value); end - - def replace_if(head, new_head); end - EMPTY = ::T.let(nil, ::T.untyped) -end - -class Concurrent::LockFreeStack::Node - def initialize(value, next_node); end - - def next_node(); end - - def value(); end - - def value=(value); end -end - -class Concurrent::LockFreeStack::Node - def self.[](*_); end -end - -class Concurrent::LockFreeStack - def self.new(*args, &block); end - - def self.of1(value); end - - def self.of2(value1, value2); end -end - -class Concurrent::MVar - include ::Concurrent::Concern::Dereferenceable - def borrow(timeout=T.unsafe(nil)); end - - def empty?(); end - - def full?(); end - - def initialize(value=T.unsafe(nil), opts=T.unsafe(nil)); end - - def modify(timeout=T.unsafe(nil)); end - - def modify!(); end - - def put(value, timeout=T.unsafe(nil)); end - - def set!(value); end - - def synchronize(&block); end - - def take(timeout=T.unsafe(nil)); end - - def try_put!(value); end - - def try_take!(); end - EMPTY = ::T.let(nil, ::T.untyped) - TIMEOUT = ::T.let(nil, ::T.untyped) -end - -class Concurrent::MVar - def self.new(*args, &block); end -end - -class Concurrent::Map - def each(&blk); end - - def each_key(); end - - def each_value(); end - - def empty?(); end - - def fetch(key, default_value=T.unsafe(nil)); end - - def fetch_or_store(key, default_value=T.unsafe(nil)); end - - def get(key); end - - def initialize(options=T.unsafe(nil), &block); end - - def key(value); end - - def keys(); end - - def marshal_dump(); end - - def marshal_load(hash); end - - def put(key, value); end - - def put_if_absent(key, value); end - - def value?(value); end - - def values(); end -end - -class Concurrent::Map -end - -class Concurrent::MaxRestartFrequencyError -end - -class Concurrent::MaxRestartFrequencyError -end - -class Concurrent::Maybe - include ::Comparable - def fulfilled?(); end - - def initialize(just, nothing); end - - def just(); end - - def just?(); end - - def nothing(); end - - def nothing?(); end - - def or(other); end - - def reason(); end - - def rejected?(); end - - def value(); end - NONE = ::T.let(nil, ::T.untyped) -end - -class Concurrent::Maybe - def self.from(*args); end - - def self.just(value); end - - def self.nothing(error=T.unsafe(nil)); end -end - -class Concurrent::MultipleAssignmentError - def initialize(message=T.unsafe(nil), inspection_data=T.unsafe(nil)); end - - def inspection_data(); end -end - -class Concurrent::MultipleAssignmentError -end - -class Concurrent::MultipleErrors - def errors(); end - - def initialize(errors, message=T.unsafe(nil)); end -end - -class Concurrent::MultipleErrors -end - -module Concurrent::MutableStruct - include ::Concurrent::Synchronization::AbstractStruct - def ==(other); end - - def [](member); end - - def []=(member, value); end - - def each(&block); end - - def each_pair(&block); end - - def inspect(); end - - def merge(other, &block); end - - def select(&block); end - - def to_a(); end - - def to_h(); end - - def to_s(); end - - def values(); end - - def values_at(*indexes); end -end - -module Concurrent::MutableStruct - def self.new(*args, &block); end -end - -class Concurrent::MutexAtomicBoolean - def false?(); end - - def initialize(initial=T.unsafe(nil)); end - - def make_false(); end - - def make_true(); end - - def ns_initialize(initial); end - - def true?(); end - - def value(); end - - def value=(value); end -end - -class Concurrent::MutexAtomicBoolean -end - -class Concurrent::MutexAtomicFixnum - def compare_and_set(expect, update); end - - def decrement(delta=T.unsafe(nil)); end - - def down(delta=T.unsafe(nil)); end - - def increment(delta=T.unsafe(nil)); end - - def initialize(initial=T.unsafe(nil)); end - - def ns_initialize(initial); end - - def up(delta=T.unsafe(nil)); end - - def update(); end - - def value(); end - - def value=(value); end -end - -class Concurrent::MutexAtomicFixnum -end - -class Concurrent::MutexAtomicReference - include ::Concurrent::AtomicDirectUpdate - include ::Concurrent::AtomicNumericCompareAndSetWrapper - def _compare_and_set(old_value, new_value); end - - def compare_and_swap(old_value, new_value); end - - def get(); end - - def get_and_set(new_value); end - - def initialize(value=T.unsafe(nil)); end - - def ns_initialize(value); end - - def set(new_value); end - - def swap(new_value); end - - def value(); end - - def value=(new_value); end -end - -class Concurrent::MutexAtomicReference -end - -class Concurrent::MutexCountDownLatch - def count(); end - - def count_down(); end - - def initialize(count=T.unsafe(nil)); end - - def ns_initialize(count); end - - def wait(timeout=T.unsafe(nil)); end -end - -class Concurrent::MutexCountDownLatch -end - -class Concurrent::MutexSemaphore - def acquire(permits=T.unsafe(nil)); end - - def available_permits(); end - - def drain_permits(); end - - def initialize(count); end - - def ns_initialize(count); end - - def reduce_permits(reduction); end - - def release(permits=T.unsafe(nil)); end - - def try_acquire(permits=T.unsafe(nil), timeout=T.unsafe(nil)); end -end - -class Concurrent::MutexSemaphore -end - -module Concurrent::Options -end - -module Concurrent::Options - def self.executor(executor_identifier); end - - def self.executor_from_options(opts=T.unsafe(nil)); end -end - -class Concurrent::Promise - def catch(&block); end - - def execute(); end - - def flat_map(&block); end - - def initialize(opts=T.unsafe(nil), &block); end - - def notify_child(child); end - - def on_error(&block); end - - def on_fulfill(result); end - - def on_reject(reason); end - - def on_success(&block); end - - def realize(task); end - - def rescue(&block); end - - def root?(); end - - def set(value=T.unsafe(nil), &block); end - - def set_pending(); end - - def set_state!(success, value, reason); end - - def synchronized_set_state!(success, value, reason); end - - def then(*args, &block); end - - def zip(*others); end -end - -class Concurrent::Promise - def self.aggregate(method, *promises); end - - def self.all?(*promises); end - - def self.any?(*promises); end - - def self.execute(opts=T.unsafe(nil), &block); end - - def self.fulfill(value, opts=T.unsafe(nil)); end - - def self.reject(reason, opts=T.unsafe(nil)); end - - def self.zip(*promises); end -end - -class Concurrent::PromiseExecutionError -end - -class Concurrent::PromiseExecutionError -end - -module Concurrent::Promises -end - class Concurrent::Promises::AbstractEventFuture include ::Concurrent::Promises::InternalStates - def add_callback_clear_delayed_node(node); end - - def add_callback_notify_blocked(promise, index); end - - def blocks(); end - - def callbacks(); end - - def chain(*args, &task); end - - def chain_on(executor, *args, &task); end - - def chain_resolvable(resolvable); end - - def default_executor(); end - - def initialize(promise, default_executor); end - - def internal_state(); end - - def on_resolution(*args, &callback); end - - def on_resolution!(*args, &callback); end - - def on_resolution_using(executor, *args, &callback); end - - def pending?(); end - - def promise(); end - - def resolve_with(state, raise_on_reassign=T.unsafe(nil), reserved=T.unsafe(nil)); end - - def resolved?(); end - - def state(); end - - def tangle(resolvable); end - - def touch(); end - - def touched?(); end - - def wait(timeout=T.unsafe(nil)); end - - def waiting_threads(); end - - def with_default_executor(executor); end - - def with_hidden_resolvable(); end -end - -class Concurrent::Promises::AbstractEventFuture - def self.new(*args, &block); end -end - -class Concurrent::Promises::Event - def &(other); end - - def any(event_or_future); end - - def delay(); end - - def schedule(intended_time); end - - def then(*args, &task); end - - def to_event(); end - - def to_future(); end - - def zip(other); end - - def |(event_or_future); end -end - -class Concurrent::Promises::Event -end - -module Concurrent::Promises::FactoryMethods - include ::Concurrent::Promises::FactoryMethods::Configuration - def any(*futures_and_or_events); end - - def any_event(*futures_and_or_events); end - - def any_event_on(default_executor, *futures_and_or_events); end - - def any_fulfilled_future(*futures_and_or_events); end - - def any_fulfilled_future_on(default_executor, *futures_and_or_events); end - - def any_resolved_future(*futures_and_or_events); end - - def any_resolved_future_on(default_executor, *futures_and_or_events); end - - def delay(*args, &task); end - - def delay_on(default_executor, *args, &task); end - - def fulfilled_future(value, default_executor=T.unsafe(nil)); end - - def future(*args, &task); end - - def future_on(default_executor, *args, &task); end - - def make_future(argument=T.unsafe(nil), default_executor=T.unsafe(nil)); end - - def rejected_future(reason, default_executor=T.unsafe(nil)); end - - def resolvable_event(); end - - def resolvable_event_on(default_executor=T.unsafe(nil)); end - - def resolvable_future(); end - - def resolvable_future_on(default_executor=T.unsafe(nil)); end - - def resolved_event(default_executor=T.unsafe(nil)); end - - def resolved_future(fulfilled, value, reason, default_executor=T.unsafe(nil)); end - - def schedule(intended_time, *args, &task); end - - def schedule_on(default_executor, intended_time, *args, &task); end - - def zip(*futures_and_or_events); end - - def zip_events(*futures_and_or_events); end - - def zip_events_on(default_executor, *futures_and_or_events); end - - def zip_futures(*futures_and_or_events); end - - def zip_futures_on(default_executor, *futures_and_or_events); end -end - -module Concurrent::Promises::FactoryMethods::Configuration - def default_executor(); end -end - -module Concurrent::Promises::FactoryMethods::Configuration -end - -module Concurrent::Promises::FactoryMethods - extend ::Concurrent::ReInclude - extend ::Concurrent::Promises::FactoryMethods - extend ::Concurrent::Promises::FactoryMethods::Configuration -end - -class Concurrent::Promises::Future - def &(other); end - - def any(event_or_future); end - - def apply(args, block); end - - def delay(); end - - def exception(*args); end - - def flat(level=T.unsafe(nil)); end - - def flat_event(); end - - def flat_future(level=T.unsafe(nil)); end - - def fulfilled?(); end - - def on_fulfillment(*args, &callback); end - - def on_fulfillment!(*args, &callback); end - - def on_fulfillment_using(executor, *args, &callback); end - - def on_rejection(*args, &callback); end - - def on_rejection!(*args, &callback); end - - def on_rejection_using(executor, *args, &callback); end - - def reason(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil)); end - - def rejected?(); end - - def rescue(*args, &task); end - - def rescue_on(executor, *args, &task); end - - def result(timeout=T.unsafe(nil)); end - - def run(run_test=T.unsafe(nil)); end - - def schedule(intended_time); end - - def then(*args, &task); end - - def then_on(executor, *args, &task); end - - def to_event(); end - - def to_future(); end - - def value(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil)); end - - def value!(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil)); end - - def wait!(timeout=T.unsafe(nil)); end - - def zip(other); end - - def |(event_or_future); end -end - -class Concurrent::Promises::Future -end - -module Concurrent::Promises::InternalStates - PENDING = ::T.let(nil, ::T.untyped) - RESERVED = ::T.let(nil, ::T.untyped) - RESOLVED = ::T.let(nil, ::T.untyped) -end - -module Concurrent::Promises::InternalStates end module Concurrent::Promises::Resolvable include ::Concurrent::Promises::InternalStates end -module Concurrent::Promises::Resolvable -end - -class Concurrent::Promises::ResolvableEvent - include ::Concurrent::Promises::Resolvable - def resolve(raise_on_reassign=T.unsafe(nil), reserved=T.unsafe(nil)); end - - def wait(timeout=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end -end - -class Concurrent::Promises::ResolvableEvent -end - -class Concurrent::Promises::ResolvableFuture - include ::Concurrent::Promises::Resolvable - def evaluate_to(*args, &block); end - - def evaluate_to!(*args, &block); end - - def fulfill(value, raise_on_reassign=T.unsafe(nil), reserved=T.unsafe(nil)); end - - def reason(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end - - def reject(reason, raise_on_reassign=T.unsafe(nil), reserved=T.unsafe(nil)); end - - def resolve(fulfilled=T.unsafe(nil), value=T.unsafe(nil), reason=T.unsafe(nil), raise_on_reassign=T.unsafe(nil), reserved=T.unsafe(nil)); end - - def result(timeout=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end - - def value(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end - - def value!(timeout=T.unsafe(nil), timeout_value=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end - - def wait(timeout=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end - - def wait!(timeout=T.unsafe(nil), resolve_on_timeout=T.unsafe(nil)); end -end - -class Concurrent::Promises::ResolvableFuture -end - -module Concurrent::Promises - extend ::Concurrent::Promises::FactoryMethods - extend ::Concurrent::Promises::FactoryMethods::Configuration -end - -module Concurrent::ReInclude - def extended(base); end - - def include(*modules); end - - def included(base); end -end - -module Concurrent::ReInclude -end - -class Concurrent::ReadWriteLock - def acquire_read_lock(); end - - def acquire_write_lock(); end - - def has_waiters?(); end - - def release_read_lock(); end - - def release_write_lock(); end - - def with_read_lock(); end - - def with_write_lock(); end - - def write_locked?(); end - MAX_READERS = ::T.let(nil, ::T.untyped) - MAX_WRITERS = ::T.let(nil, ::T.untyped) - RUNNING_WRITER = ::T.let(nil, ::T.untyped) - WAITING_WRITER = ::T.let(nil, ::T.untyped) -end - -class Concurrent::ReadWriteLock - def self.new(*args, &block); end -end - -class Concurrent::ReentrantReadWriteLock - def acquire_read_lock(); end - - def acquire_write_lock(); end - - def release_read_lock(); end - - def release_write_lock(); end - - def try_read_lock(); end - - def try_write_lock(); end - - def with_read_lock(); end - - def with_write_lock(); end - MAX_READERS = ::T.let(nil, ::T.untyped) - MAX_WRITERS = ::T.let(nil, ::T.untyped) - READER_BITS = ::T.let(nil, ::T.untyped) - READ_LOCK_MASK = ::T.let(nil, ::T.untyped) - RUNNING_WRITER = ::T.let(nil, ::T.untyped) - WAITING_WRITER = ::T.let(nil, ::T.untyped) - WRITER_BITS = ::T.let(nil, ::T.untyped) - WRITE_LOCK_HELD = ::T.let(nil, ::T.untyped) - WRITE_LOCK_MASK = ::T.let(nil, ::T.untyped) -end - -class Concurrent::ReentrantReadWriteLock - def self.new(*args, &block); end -end - -class Concurrent::RejectedExecutionError -end - -class Concurrent::RejectedExecutionError -end - -class Concurrent::ResourceLimitError -end - -class Concurrent::ResourceLimitError -end - -class Concurrent::RubyExchanger - def compare_and_set_slot(expected, value); end - - def slot(); end - - def slot=(value); end - - def swap_slot(value); end - - def update_slot(&block); end -end - -class Concurrent::RubyExchanger - def self.new(*args, &block); end -end - -class Concurrent::RubyExecutorService - def initialize(*args, &block); end -end - -class Concurrent::RubyExecutorService -end - -class Concurrent::RubySingleThreadExecutor -end - -class Concurrent::RubySingleThreadExecutor -end - -class Concurrent::RubyThreadLocalVar -end - -class Concurrent::RubyThreadLocalVar - def self.thread_finalizer(id); end - - def self.thread_local_finalizer(index); end -end - -class Concurrent::RubyThreadPoolExecutor - def completed_task_count(); end - - def idletime(); end - - def initialize(opts=T.unsafe(nil)); end - - def largest_length(); end - - def length(); end - - def max_length(); end - - def max_queue(); end - - def min_length(); end - - def queue_length(); end - - def ready_worker(worker); end - - def remaining_capacity(); end - - def remove_busy_worker(worker); end - - def scheduled_task_count(); end - - def worker_died(worker); end - - def worker_not_old_enough(worker); end - - def worker_task_completed(); end - DEFAULT_MAX_POOL_SIZE = ::T.let(nil, ::T.untyped) - DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped) - DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped) - DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped) -end - -class Concurrent::RubyThreadPoolExecutor -end - -class Concurrent::SafeTaskExecutor - def execute(*args); end - - def initialize(task, opts=T.unsafe(nil)); end -end - -class Concurrent::SafeTaskExecutor -end - -class Concurrent::ScheduledTask - include ::Comparable - def cancel(); end - - def cancelled?(); end - - def execute(); end - - def executor(); end - - def initial_delay(); end - - def initialize(delay, opts=T.unsafe(nil), &task); end - - def ns_reschedule(delay); end - - def ns_schedule(delay); end - - def process_task(); end - - def processing?(); end - - def reschedule(delay); end - - def reset(); end - - def schedule_time(); end -end - -class Concurrent::ScheduledTask - def self.execute(delay, opts=T.unsafe(nil), &task); end -end - -class Concurrent::Semaphore -end - -class Concurrent::Semaphore -end - -module Concurrent::SerialExecutorService - include ::Concurrent::ExecutorService - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def serialized?(); end -end - -module Concurrent::SerialExecutorService -end - -class Concurrent::SerializedExecution - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def initialize(); end - - def post(executor, *args, &task); end - - def posts(posts); end -end - -class Concurrent::SerializedExecution::Job - def args(); end - - def args=(_); end - - def block(); end - - def block=(_); end - - def call(); end - - def executor(); end - - def executor=(_); end -end - -class Concurrent::SerializedExecution::Job - def self.[](*_); end - - def self.members(); end -end - -class Concurrent::SerializedExecution -end - -class Concurrent::SerializedExecutionDelegator - include ::Concurrent::SerialExecutorService - include ::Concurrent::ExecutorService - include ::Concurrent::Concern::Logging - include ::Logger::Severity - def initialize(executor); end -end - -class Concurrent::SerializedExecutionDelegator -end - -class Concurrent::Set -end - -class Concurrent::Set -end - -module Concurrent::SettableStruct - include ::Concurrent::Synchronization::AbstractStruct - def ==(other); end - - def [](member); end - - def []=(member, value); end - - def each(&block); end - - def each_pair(&block); end - - def inspect(); end - - def merge(other, &block); end - - def select(&block); end - - def to_a(); end - - def to_h(); end - - def to_s(); end - - def values(); end - - def values_at(*indexes); end -end - -module Concurrent::SettableStruct - def self.new(*args, &block); end -end - -class Concurrent::SimpleExecutorService -end - -class Concurrent::SimpleExecutorService - def self.<<(task); end - - def self.post(*args); end -end - -class Concurrent::SingleThreadExecutor -end - -class Concurrent::SingleThreadExecutor -end - -module Concurrent::Synchronization -end - -class Concurrent::Synchronization::AbstractLockableObject - def ns_broadcast(); end - - def ns_signal(); end - - def ns_wait(timeout=T.unsafe(nil)); end - - def ns_wait_until(timeout=T.unsafe(nil), &condition); end - - def synchronize(); end -end - -class Concurrent::Synchronization::AbstractLockableObject -end - -class Concurrent::Synchronization::AbstractObject - def full_memory_barrier(); end -end - -class Concurrent::Synchronization::AbstractObject - def self.attr_volatile(*names); end -end - -module Concurrent::Synchronization::AbstractStruct - def initialize(*values); end - - def length(); end - - def members(); end - - def ns_each(); end - - def ns_each_pair(); end - - def ns_equality(other); end - - def ns_get(member); end - - def ns_initialize_copy(); end - - def ns_inspect(); end - - def ns_merge(other, &block); end - - def ns_select(); end - - def ns_to_h(); end - - def ns_values(); end - - def ns_values_at(indexes); end - - def pr_underscore(clazz); end - - def size(); end -end - -module Concurrent::Synchronization::AbstractStruct - def self.define_struct_class(parent, base, name, members, &block); end -end - -class Concurrent::Synchronization::Condition - def broadcast(); end - - def initialize(lock); end - - def signal(); end - - def wait(timeout=T.unsafe(nil)); end - - def wait_until(timeout=T.unsafe(nil), &condition); end -end - -class Concurrent::Synchronization::Condition - def self.private_new(*args, &block); end -end - -module Concurrent::Synchronization::ConditionSignalling - def ns_broadcast(); end - - def ns_signal(); end -end - -module Concurrent::Synchronization::ConditionSignalling -end - -class Concurrent::Synchronization::Lock - def broadcast(); end - - def signal(); end - - def wait(timeout=T.unsafe(nil)); end - - def wait_until(timeout=T.unsafe(nil), &condition); end -end - -class Concurrent::Synchronization::Lock -end - -class Concurrent::Synchronization::LockableObject - def new_condition(); end -end - -class Concurrent::Synchronization::LockableObject -end - -class Concurrent::Synchronization::MonitorLockableObject - include ::Concurrent::Synchronization::ConditionSignalling - def initialize(*defaults); end -end - -class Concurrent::Synchronization::MonitorLockableObject - def self.new(*args, &block); end -end - -module Concurrent::Synchronization::MriAttrVolatile - def full_memory_barrier(); end -end - -module Concurrent::Synchronization::MriAttrVolatile - def self.included(base); end -end - -class Concurrent::Synchronization::MriObject - include ::Concurrent::Synchronization::MriAttrVolatile -end - -class Concurrent::Synchronization::MriObject -end - -class Concurrent::Synchronization::MutexLockableObject - include ::Concurrent::Synchronization::ConditionSignalling - def initialize(*defaults); end -end - -class Concurrent::Synchronization::MutexLockableObject - def self.new(*args, &block); end -end - -class Concurrent::Synchronization::Object -end - -class Concurrent::Synchronization::Object - def self.atomic_attribute?(name); end - - def self.atomic_attributes(inherited=T.unsafe(nil)); end - - def self.attr_atomic(*names); end - - def self.ensure_safe_initialization_when_final_fields_are_present(); end - - def self.safe_initialization!(); end - - def self.safe_initialization?(); end -end - -module Concurrent::Synchronization::RbxAttrVolatile - def full_memory_barrier(); end -end - -module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods - def attr_volatile(*names); end -end - -module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods -end - -module Concurrent::Synchronization::RbxAttrVolatile - def self.included(base); end -end - -class Concurrent::Synchronization::RbxLockableObject - def initialize(*defaults); end - - def synchronize(&block); end -end - -class Concurrent::Synchronization::RbxLockableObject - def self.new(*args, &block); end -end - -class Concurrent::Synchronization::RbxObject - include ::Concurrent::Synchronization::RbxAttrVolatile -end - -class Concurrent::Synchronization::RbxObject - extend ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods -end - -module Concurrent::Synchronization::TruffleRubyAttrVolatile - def full_memory_barrier(); end -end - -module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods - def attr_volatile(*names); end -end - -module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods -end - -module Concurrent::Synchronization::TruffleRubyAttrVolatile - def self.included(base); end -end - -class Concurrent::Synchronization::TruffleRubyObject - include ::Concurrent::Synchronization::TruffleRubyAttrVolatile -end - -class Concurrent::Synchronization::TruffleRubyObject - extend ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods -end - -Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile - -module Concurrent::Synchronization -end - -class Concurrent::SynchronizedDelegator - def method_missing(method, *args, &block); end - - def setup(); end - - def teardown(); end -end - -class Concurrent::SynchronizedDelegator -end - -class Concurrent::TVar - def initialize(value); end - - def unsafe_increment_version(); end - - def unsafe_lock(); end - - def unsafe_value(); end - - def unsafe_value=(value); end - - def unsafe_version(); end - - def value(); end - - def value=(value); end -end - -class Concurrent::TVar - def self.new(*args, &block); end -end - -class Concurrent::ThreadLocalVar -end - -class Concurrent::ThreadLocalVar -end - -class Concurrent::ThreadPoolExecutor -end - -class Concurrent::ThreadPoolExecutor -end - -module Concurrent::ThreadSafe -end - -module Concurrent::ThreadSafe::Util - CPU_COUNT = ::T.let(nil, ::T.untyped) - FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped) - MAX_INT = ::T.let(nil, ::T.untyped) -end - -module Concurrent::ThreadSafe::Util -end - -module Concurrent::ThreadSafe -end - -class Concurrent::TimeoutError -end - -class Concurrent::TimeoutError -end - -class Concurrent::TimerSet - def initialize(opts=T.unsafe(nil)); end - - def post(delay, *args, &task); end -end - -class Concurrent::TimerSet -end - -class Concurrent::TimerTask - include ::Concurrent::Concern::Dereferenceable - include ::Concurrent::Concern::Observable - def execute(); end - - def execution_interval(); end - - def execution_interval=(value); end - - def initialize(opts=T.unsafe(nil), &task); end - - def timeout_interval(); end - - def timeout_interval=(value); end - EXECUTION_INTERVAL = ::T.let(nil, ::T.untyped) - TIMEOUT_INTERVAL = ::T.let(nil, ::T.untyped) -end - -class Concurrent::TimerTask - def self.execute(opts=T.unsafe(nil), &task); end -end - -class Concurrent::Transaction - def abort(); end - - def commit(); end - - def read(tvar); end - - def unlock(); end - - def valid?(); end - - def write(tvar, value); end - ABORTED = ::T.let(nil, ::T.untyped) -end - -class Concurrent::Transaction::AbortError -end - -class Concurrent::Transaction::AbortError -end - -class Concurrent::Transaction::LeaveError -end - -class Concurrent::Transaction::LeaveError -end - -class Concurrent::Transaction::ReadLogEntry - def tvar(); end - - def tvar=(_); end - - def version(); end - - def version=(_); end -end - -class Concurrent::Transaction::ReadLogEntry - def self.[](*_); end - - def self.members(); end -end - -class Concurrent::Transaction - def self.current(); end - - def self.current=(transaction); end -end - -class Concurrent::Tuple - include ::Enumerable - def cas(i, old_value, new_value); end - - def compare_and_set(i, old_value, new_value); end - - def each(&blk); end - - def get(i); end - - def initialize(size); end - - def set(i, value); end - - def size(); end - - def volatile_get(i); end - - def volatile_set(i, value); end -end - -class Concurrent::Tuple -end - -module Concurrent::Utility -end - -module Concurrent::Utility::EngineDetector - def on_cruby?(); end - - def on_jruby?(); end - - def on_jruby_9000?(); end - - def on_linux?(); end - - def on_osx?(); end - - def on_rbx?(); end - - def on_truffleruby?(); end - - def on_windows?(); end - - def ruby_engine(); end - - def ruby_version(version=T.unsafe(nil), comparison, major, minor, patch); end -end - -module Concurrent::Utility::EngineDetector -end - -module Concurrent::Utility::NativeExtensionLoader - def allow_c_extensions?(); end - - def c_extensions_loaded?(); end - - def java_extensions_loaded?(); end - - def load_native_extensions(); end -end - -module Concurrent::Utility::NativeExtensionLoader -end - -module Concurrent::Utility::NativeInteger - def ensure_integer(value); end - - def ensure_integer_and_bounds(value); end - - def ensure_lower_bound(value); end - - def ensure_positive(value); end - - def ensure_positive_and_no_zero(value); end - - def ensure_upper_bound(value); end - MAX_VALUE = ::T.let(nil, ::T.untyped) - MIN_VALUE = ::T.let(nil, ::T.untyped) -end - -module Concurrent::Utility::NativeInteger - extend ::Concurrent::Utility::NativeInteger -end - -class Concurrent::Utility::ProcessorCounter - def physical_processor_count(); end - - def processor_count(); end -end - -class Concurrent::Utility::ProcessorCounter -end - -module Concurrent::Utility -end - -module Concurrent - extend ::Concurrent::Utility::EngineDetector - extend ::Concurrent::Utility::NativeExtensionLoader - extend ::Concurrent::Concern::Deprecation - extend ::Concurrent::Concern::Logging - extend ::Logger::Severity - def self.abort_transaction(); end - - def self.atomically(); end - - def self.call_dataflow(method, executor, *inputs, &block); end - - def self.create_simple_logger(level=T.unsafe(nil), output=T.unsafe(nil)); end - - def self.create_stdlib_logger(level=T.unsafe(nil), output=T.unsafe(nil)); end - - def self.dataflow(*inputs, &block); end - - def self.dataflow!(*inputs, &block); end - - def self.dataflow_with(executor, *inputs, &block); end - - def self.dataflow_with!(executor, *inputs, &block); end - - def self.disable_at_exit_handlers!(); end - - def self.executor(executor_identifier); end - - def self.global_fast_executor(); end - - def self.global_immediate_executor(); end - - def self.global_io_executor(); end - - def self.global_logger(); end - - def self.global_logger=(value); end - - def self.global_timer_set(); end - - def self.leave_transaction(); end - - def self.monotonic_time(); end - - def self.new_fast_executor(opts=T.unsafe(nil)); end - - def self.new_io_executor(opts=T.unsafe(nil)); end - - def self.physical_processor_count(); end - - def self.processor_count(); end - - def self.processor_counter(); end - - def self.use_simple_logger(level=T.unsafe(nil), output=T.unsafe(nil)); end - - def self.use_stdlib_logger(level=T.unsafe(nil), output=T.unsafe(nil)); end -end - -class ConnectionPool - def available(); end - - def checkin(); end - - def checkout(options=T.unsafe(nil)); end - - def initialize(options=T.unsafe(nil), &block); end - - def shutdown(&block); end - - def size(); end - - def with(options=T.unsafe(nil)); end - DEFAULTS = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class ConnectionPool::Error -end - -class ConnectionPool::Error -end - -class ConnectionPool::PoolShuttingDownError -end - -class ConnectionPool::PoolShuttingDownError -end - -class ConnectionPool::TimedStack - def <<(obj, options=T.unsafe(nil)); end - - def empty?(); end - - def initialize(size=T.unsafe(nil), &block); end - - def length(); end - - def max(); end - - def pop(timeout=T.unsafe(nil), options=T.unsafe(nil)); end - - def push(obj, options=T.unsafe(nil)); end - - def shutdown(&block); end -end - -class ConnectionPool::TimedStack -end - -class ConnectionPool::TimeoutError -end - -class ConnectionPool::TimeoutError -end - -class ConnectionPool::Wrapper - def initialize(options=T.unsafe(nil), &block); end - - def method_missing(name, *args, &block); end - - def pool_available(); end - - def pool_shutdown(&block); end - - def pool_size(); end - - def respond_to?(id, *args); end - - def with(&block); end - - def wrapped_pool(); end - METHODS = ::T.let(nil, ::T.untyped) -end - -class ConnectionPool::Wrapper -end - -class ConnectionPool - def self.wrap(options, &block); end -end - module CopHelper def _investigate(cop, processed_source); end @@ -9363,101 +6949,6 @@ module Docile def self.dsl_eval_with_block_return(dsl, *args, &block); end end -class DomainName - def <(other); end - - def <=(other); end - - def ==(other); end - - def >(other); end - - def >=(other); end - - def canonical?(); end - - def canonical_tld?(); end - - def cookie_domain?(domain, host_only=T.unsafe(nil)); end - - def domain(); end - - def domain_idn(); end - - def hostname(); end - - def hostname_idn(); end - - def idn(); end - - def initialize(hostname); end - - def ipaddr(); end - - def ipaddr?(); end - - def superdomain(); end - - def tld(); end - - def tld_idn(); end - - def to_str(); end - - def uri_host(); end - DOT = ::T.let(nil, ::T.untyped) - ETLD_DATA = ::T.let(nil, ::T.untyped) - ETLD_DATA_DATE = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module DomainName::Punycode - BASE = ::T.let(nil, ::T.untyped) - CUTOFF = ::T.let(nil, ::T.untyped) - DAMP = ::T.let(nil, ::T.untyped) - DECODE_DIGIT = ::T.let(nil, ::T.untyped) - DELIMITER = ::T.let(nil, ::T.untyped) - DOT = ::T.let(nil, ::T.untyped) - ENCODE_DIGIT = ::T.let(nil, ::T.untyped) - INITIAL_BIAS = ::T.let(nil, ::T.untyped) - INITIAL_N = ::T.let(nil, ::T.untyped) - LOBASE = ::T.let(nil, ::T.untyped) - MAXINT = ::T.let(nil, ::T.untyped) - PREFIX = ::T.let(nil, ::T.untyped) - RE_NONBASIC = ::T.let(nil, ::T.untyped) - SKEW = ::T.let(nil, ::T.untyped) - TMAX = ::T.let(nil, ::T.untyped) - TMIN = ::T.let(nil, ::T.untyped) -end - -class DomainName::Punycode::ArgumentError -end - -class DomainName::Punycode::ArgumentError -end - -class DomainName::Punycode::BufferOverflowError -end - -class DomainName::Punycode::BufferOverflowError -end - -module DomainName::Punycode - def self.decode(string); end - - def self.decode_hostname(hostname); end - - def self.encode(string); end - - def self.encode_hostname(hostname); end -end - -class DomainName - def self.etld_data(); end - - def self.normalize(domain); end -end - class ERB def def_method(mod, methodname, fname=T.unsafe(nil)); end @@ -9901,10 +7392,6 @@ module FileUtils extend ::FileUtils::StreamUtils_ end -class Float - include ::JSON::Ext::Generator::GeneratorMethods::Float -end - class Formula include ::Formula::Compat end @@ -10543,206 +8030,8 @@ end module GetText end -module HTTP -end - class HTTP::Cookie - include ::Comparable - include ::Mechanize::CookieIMethods - include ::Mechanize::CookieDeprecated - def acceptable?(); end - - def acceptable_from_uri?(uri); end - - def accessed_at(); end - - def accessed_at=(accessed_at); end - - def cookie_value(); end - - def created_at(); end - - def created_at=(created_at); end - - def domain(); end - - def domain=(domain); end - - def domain_name(); end - - def dot_domain(); end - - def encode_with(coder); end - - def expire!(); end - - def expired?(time=T.unsafe(nil)); end - - def expires(); end - - def expires=(t); end - - def expires_at(); end - - def expires_at=(t); end - - def for_domain(); end - - def for_domain=(for_domain); end - - def for_domain?(); end - - def httponly(); end - - def httponly=(httponly); end - - def httponly?(); end - - def init_with(coder); end - - def initialize(*args); end - - def max_age(); end - - def max_age=(sec); end - - def name(); end - - def name=(name); end - - def origin(); end - - def origin=(origin); end - - def path(); end - - def path=(path); end - - def secure(); end - - def secure=(secure); end - - def secure?(); end - - def session(); end - - def session?(); end - - def set_cookie_value(); end - - def to_yaml_properties(); end - - def valid_for_uri?(uri); end - - def value(); end - - def value=(value); end - - def yaml_initialize(tag, map); end - MAX_COOKIES_PER_DOMAIN = ::T.let(nil, ::T.untyped) - MAX_COOKIES_TOTAL = ::T.let(nil, ::T.untyped) - MAX_LENGTH = ::T.let(nil, ::T.untyped) - PERSISTENT_PROPERTIES = ::T.let(nil, ::T.untyped) - UNIX_EPOCH = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class HTTP::Cookie::Scanner - def initialize(string, logger=T.unsafe(nil)); end - - def parse_cookie_date(s); end - - def scan_cookie(); end - - def scan_dquoted(); end - - def scan_name(); end - - def scan_name_value(comma_as_separator=T.unsafe(nil)); end - - def scan_set_cookie(); end - - def scan_value(comma_as_separator=T.unsafe(nil)); end - - def skip_wsp(); end - RE_BAD_CHAR = ::T.let(nil, ::T.untyped) - RE_COOKIE_COMMA = ::T.let(nil, ::T.untyped) - RE_NAME = ::T.let(nil, ::T.untyped) - RE_WSP = ::T.let(nil, ::T.untyped) -end - -class HTTP::Cookie::Scanner - def self.quote(s); end -end - -class HTTP::Cookie - extend ::Mechanize::CookieCMethods - extend ::Mechanize::CookieDeprecated - def self.cookie_value(cookies); end - - def self.cookie_value_to_hash(cookie_value); end - def self.parse(set_cookie, origin, options=T.unsafe(nil), &block); end - - def self.path_match?(base_path, target_path); end -end - -class HTTP::CookieJar - include ::Enumerable - include ::Mechanize::CookieJarIMethods - include ::Mechanize::CookieDeprecated - def <<(cookie); end - - def cleanup(session=T.unsafe(nil)); end - - def clear(); end - - def cookies(url=T.unsafe(nil)); end - - def delete(cookie); end - - def each(uri=T.unsafe(nil), &block); end - - def empty?(url=T.unsafe(nil)); end - - def initialize(options=T.unsafe(nil)); end - - def load(readable, *options); end - - def parse(set_cookie, origin, options=T.unsafe(nil)); end - - def save(writable, *options); end - - def store(); end -end - -class HTTP::CookieJar::AbstractSaver - def initialize(options=T.unsafe(nil)); end - - def load(io, jar); end - - def save(io, jar); end -end - -class HTTP::CookieJar::AbstractSaver - def self.class_to_symbol(klass); end - - def self.implementation(symbol); end - - def self.inherited(subclass); end -end - -class HTTP::CookieJar::YAMLSaver -end - -class HTTP::CookieJar::YAMLSaver -end - -class HTTP::CookieJar - def self.const_missing(name); end -end - -module HTTP end class Hardware::CPU @@ -13011,9 +10300,7 @@ module IRB end class Integer - include ::JSON::Ext::Generator::GeneratorMethods::Integer def to_bn(); end - GMP_VERSION = ::T.let(nil, ::T.untyped) end class JSON::Ext::Generator::State @@ -13024,12 +10311,6 @@ class JSON::Ext::Parser def initialize(*_); end end -JSON::Parser = JSON::Ext::Parser - -JSON::State = JSON::Ext::Generator::State - -JSON::UnparserError = JSON::GeneratorError - class JavaRequirement::CaskSuggestion def self.[](*_); end @@ -13049,20 +10330,14 @@ class Keg::Relocation end module Kernel - def byebug(); end - def class_eval(*args, &block); end - def debugger(); end - def itself(); end def object_id(); end def pretty_inspect(); end - def remote_byebug(host=T.unsafe(nil), port=T.unsafe(nil)); end - def then(); end def yield_self(); end @@ -13109,341 +10384,6 @@ module LoggerSilence extend ::ActiveSupport::Concern end -module MIME -end - -class MIME::Type - include ::Comparable - def add_extensions(*extensions); end - - def ascii?(); end - - def binary?(); end - - def complete?(); end - - def content_type(); end - - def default_encoding(); end - - def docs(); end - - def docs=(docs); end - - def encode_with(coder); end - - def encoding(); end - - def encoding=(enc); end - - def eql?(other); end - - def extensions(); end - - def extensions=(value); end - - def friendly(lang=T.unsafe(nil)); end - - def i18n_key(); end - - def init_with(coder); end - - def initialize(content_type); end - - def like?(other); end - - def media_type(); end - - def obsolete(); end - - def obsolete=(obsolete); end - - def obsolete?(); end - - def preferred_extension(); end - - def preferred_extension=(value); end - - def priority_compare(other); end - - def raw_media_type(); end - - def raw_sub_type(); end - - def registered(); end - - def registered=(registered); end - - def registered?(); end - - def signature(); end - - def signature=(signature); end - - def signature?(); end - - def simplified(); end - - def sub_type(); end - - def to_h(); end - - def to_json(*args); end - - def to_str(); end - - def use_instead(); end - - def use_instead=(use_instead); end - - def xref_urls(); end - - def xrefs(); end - - def xrefs=(xrefs); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class MIME::Type::Columnar - def docs(*args); end - - def docs=(*args); end - - def encoding(*args); end - - def encoding=(*args); end - - def friendly(*args); end - - def initialize(container, content_type, extensions); end - - def obsolete(*args); end - - def obsolete=(*args); end - - def obsolete?(*args); end - - def preferred_extension(*args); end - - def preferred_extension=(*args); end - - def registered(*args); end - - def registered=(*args); end - - def registered?(*args); end - - def signature(*args); end - - def signature=(*args); end - - def signature?(*args); end - - def use_instead(*args); end - - def use_instead=(*args); end - - def xref_urls(*args); end - - def xrefs(*args); end - - def xrefs=(*args); end -end - -class MIME::Type::Columnar -end - -class MIME::Type::InvalidContentType - def initialize(type_string); end -end - -class MIME::Type::InvalidContentType -end - -class MIME::Type::InvalidEncoding - def initialize(encoding); end -end - -class MIME::Type::InvalidEncoding -end - -class MIME::Type - def self.i18n_key(content_type); end - - def self.match(content_type); end - - def self.simplified(content_type, remove_x_prefix: T.unsafe(nil)); end -end - -class MIME::Types - include ::Enumerable - def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end - - def add(*types); end - - def add_type(type, quiet=T.unsafe(nil)); end - - def count(); end - - def each(&blk); end - - def of(filename); end - - def type_for(filename); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class MIME::Types::Cache - def data(); end - - def data=(_); end - - def version(); end - - def version=(_); end -end - -class MIME::Types::Cache - def self.[](*_); end - - def self.load(cache_file=T.unsafe(nil)); end - - def self.members(); end - - def self.save(types=T.unsafe(nil), cache_file=T.unsafe(nil)); end -end - -module MIME::Types::Columnar - def load_base_data(path); end - LOAD_MUTEX = ::T.let(nil, ::T.untyped) -end - -module MIME::Types::Columnar - def self.extended(obj); end -end - -class MIME::Types::Container - def ==(*args, &block); end - - def [](key); end - - def []=(key, value); end - - def add(key, value); end - - def container(); end - - def container=(container); end - - def count(*args, &block); end - - def each(*args, &block); end - - def each_value(*args, &block); end - - def empty?(*args, &block); end - - def encode_with(coder); end - - def flat_map(*args, &block); end - - def init_with(coder); end - - def initialize(hash=T.unsafe(nil)); end - - def keys(*args, &block); end - - def marshal_dump(); end - - def marshal_load(hash); end - - def merge(other); end - - def merge!(other); end - - def normalize(); end - - def select(*args, &block); end - - def to_hash(); end - - def values(*args, &block); end -end - -class MIME::Types::Container - extend ::Forwardable -end - -module MIME::Types::Data - PATH = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module MIME::Types::Data -end - -class MIME::Types::Loader - def container(); end - - def initialize(path=T.unsafe(nil), container=T.unsafe(nil)); end - - def load(options=T.unsafe(nil)); end - - def load_columnar(); end - - def load_json(); end - - def load_yaml(); end - - def path(); end -end - -class MIME::Types::Loader - def self.load(options=T.unsafe(nil)); end - - def self.load_from_json(filename); end - - def self.load_from_yaml(filename); end -end - -class MIME::Types::WarnLogger - def initialize(_one, _two=T.unsafe(nil), _three=T.unsafe(nil)); end -end - -class MIME::Types::WarnLogger::WarnLogDevice - def initialize(*_); end - - def write(m); end -end - -class MIME::Types::WarnLogger::WarnLogDevice -end - -class MIME::Types::WarnLogger -end - -class MIME::Types - extend ::Enumerable - def self.[](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end - - def self.add(*types); end - - def self.count(); end - - def self.each(&blk); end - - def self.logger(); end - - def self.logger=(logger); end - - def self.of(filename); end - - def self.type_for(filename); end -end - -module MIME -end - module MachO VERSION = ::T.let(nil, ::T.untyped) end @@ -14775,1777 +11715,6 @@ module Marshal extend ::ActiveSupport::MarshalWithAutoloading end -class Mechanize - def add_auth(uri, user, password, realm=T.unsafe(nil), domain=T.unsafe(nil)); end - - def agent(); end - - def auth(user, password, domain=T.unsafe(nil)); end - - def back(); end - - def basic_auth(user, password, domain=T.unsafe(nil)); end - - def ca_file(); end - - def ca_file=(ca_file); end - - def cert(); end - - def cert=(cert); end - - def cert_store(); end - - def cert_store=(cert_store); end - - def certificate(); end - - def click(link); end - - def conditional_requests(); end - - def conditional_requests=(enabled); end - - def content_encoding_hooks(); end - - def cookie_jar(); end - - def cookie_jar=(cookie_jar); end - - def cookies(); end - - def current_page(); end - - def default_encoding(); end - - def default_encoding=(default_encoding); end - - def delete(uri, query_params=T.unsafe(nil), headers=T.unsafe(nil)); end - - def download(uri, io_or_filename, parameters=T.unsafe(nil), referer=T.unsafe(nil), headers=T.unsafe(nil)); end - - def follow_meta_refresh(); end - - def follow_meta_refresh=(follow); end - - def follow_meta_refresh_self(); end - - def follow_meta_refresh_self=(follow); end - - def follow_redirect=(follow); end - - def follow_redirect?(); end - - def force_default_encoding(); end - - def force_default_encoding=(force_default_encoding); end - - def get(uri, parameters=T.unsafe(nil), referer=T.unsafe(nil), headers=T.unsafe(nil)); end - - def get_file(url); end - - def gzip_enabled(); end - - def gzip_enabled=(enabled); end - - def head(uri, query_params=T.unsafe(nil), headers=T.unsafe(nil)); end - - def history(); end - - def history_added(); end - - def history_added=(history_added); end - - def html_parser(); end - - def html_parser=(html_parser); end - - def idle_timeout(); end - - def idle_timeout=(idle_timeout); end - - def ignore_bad_chunking(); end - - def ignore_bad_chunking=(ignore_bad_chunking); end - - def initialize(connection_name=T.unsafe(nil)); end - - def keep_alive(); end - - def keep_alive=(enable); end - - def keep_alive_time(); end - - def keep_alive_time=(keep_alive_time); end - - def key(); end - - def key=(key); end - - def log(); end - - def log=(logger); end - - def max_file_buffer(); end - - def max_file_buffer=(bytes); end - - def max_history(); end - - def max_history=(length); end - - def open_timeout(); end - - def open_timeout=(open_timeout); end - - def page(); end - - def parse(uri, response, body); end - - def pass(); end - - def pass=(pass); end - - def pluggable_parser(); end - - def post(uri, query=T.unsafe(nil), headers=T.unsafe(nil)); end - - def post_connect_hooks(); end - - def pre_connect_hooks(); end - - def proxy_addr(); end - - def proxy_pass(); end - - def proxy_port(); end - - def proxy_user(); end - - def put(uri, entity, headers=T.unsafe(nil)); end - - def read_timeout(); end - - def read_timeout=(read_timeout); end - - def redirect_ok(); end - - def redirect_ok=(follow); end - - def redirection_limit(); end - - def redirection_limit=(limit); end - - def request_headers(); end - - def request_headers=(request_headers); end - - def request_with_entity(verb, uri, entity, headers=T.unsafe(nil)); end - - def reset(); end - - def resolve(link); end - - def retry_change_requests(); end - - def retry_change_requests=(retry_change_requests); end - - def robots(); end - - def robots=(enabled); end - - def scheme_handlers(); end - - def scheme_handlers=(scheme_handlers); end - - def set_proxy(address, port, user=T.unsafe(nil), password=T.unsafe(nil)); end - - def shutdown(); end - - def ssl_version(); end - - def ssl_version=(ssl_version); end - - def submit(form, button=T.unsafe(nil), headers=T.unsafe(nil)); end - - def transact(); end - - def user_agent(); end - - def user_agent=(user_agent); end - - def user_agent_alias=(name); end - - def verify_callback(); end - - def verify_callback=(verify_callback); end - - def verify_mode(); end - - def verify_mode=(verify_mode); end - - def visited?(url); end - - def visited_page(url); end - - def watch_for_set(); end - - def watch_for_set=(watch_for_set); end - AGENT_ALIASES = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Mechanize::ChunkedTerminationError -end - -class Mechanize::ChunkedTerminationError -end - -class Mechanize::ContentTypeError - def content_type(); end - - def initialize(content_type); end -end - -class Mechanize::ContentTypeError -end - -Mechanize::Cookie = HTTP::Cookie - -module Mechanize::CookieCMethods - include ::Mechanize::CookieDeprecated - def parse(arg1, arg2, arg3=T.unsafe(nil), &block); end -end - -module Mechanize::CookieCMethods -end - -module Mechanize::CookieDeprecated -end - -module Mechanize::CookieDeprecated -end - -module Mechanize::CookieIMethods - include ::Mechanize::CookieDeprecated - def set_domain(domain); end -end - -module Mechanize::CookieIMethods -end - -class Mechanize::CookieJar - def load(input, *options); end - - def save(output, *options); end -end - -class Mechanize::CookieJar -end - -module Mechanize::CookieJarIMethods - include ::Mechanize::CookieDeprecated - def add(arg1, arg2=T.unsafe(nil)); end - - def add!(cookie); end - - def clear!(); end - - def dump_cookiestxt(io); end - - def jar(); end - - def load_cookiestxt(io); end - - def save_as(filename, *options); end -end - -module Mechanize::CookieJarIMethods -end - -class Mechanize::DirectorySaver -end - -class Mechanize::DirectorySaver - def self.decode_filename?(); end - - def self.directory(); end - - def self.overwrite?(); end - - def self.save_to(directory, options=T.unsafe(nil)); end -end - -class Mechanize::Download - include ::Mechanize::Parser - def body(); end - - def body_io(); end - - def content(); end - - def filename(); end - - def filename=(filename); end - - def initialize(uri=T.unsafe(nil), response=T.unsafe(nil), body_io=T.unsafe(nil), code=T.unsafe(nil)); end - - def save(filename=T.unsafe(nil)); end - - def save!(filename=T.unsafe(nil)); end - - def save_as(filename=T.unsafe(nil)); end -end - -class Mechanize::Download -end - -module Mechanize::ElementMatcher - def elements_with(singular, plural=T.unsafe(nil)); end -end - -module Mechanize::ElementMatcher -end - -class Mechanize::ElementNotFoundError - def conditions(); end - - def element(); end - - def initialize(source, element, conditions); end - - def source(); end -end - -class Mechanize::ElementNotFoundError -end - -class Mechanize::Error -end - -class Mechanize::Error -end - -class Mechanize::File - include ::Mechanize::Parser - def body(); end - - def body=(body); end - - def content(); end - - def filename(); end - - def filename=(filename); end - - def initialize(uri=T.unsafe(nil), response=T.unsafe(nil), body=T.unsafe(nil), code=T.unsafe(nil)); end - - def save(filename=T.unsafe(nil)); end - - def save!(filename=T.unsafe(nil)); end - - def save_as(filename=T.unsafe(nil)); end -end - -class Mechanize::File -end - -class Mechanize::FileConnection - def request(uri, request); end -end - -class Mechanize::FileConnection - def self.new(*a); end -end - -class Mechanize::FileRequest - def []=(*a); end - - def add_field(*a); end - - def each_header(); end - - def initialize(uri); end - - def path(); end - - def response_body_permitted?(); end - - def uri(); end - - def uri=(uri); end -end - -class Mechanize::FileRequest -end - -class Mechanize::FileResponse - def [](key); end - - def code(); end - - def content_length(); end - - def each(&blk); end - - def each_header(); end - - def get_fields(key); end - - def http_version(); end - - def initialize(file_path); end - - def message(); end - - def read_body(); end - - def uri(); end -end - -class Mechanize::FileResponse -end - -class Mechanize::FileSaver -end - -class Mechanize::FileSaver -end - -class Mechanize::Form - def [](field_name); end - - def []=(field_name, value); end - - def action(); end - - def action=(action); end - - def add_button_to_query(button); end - - def add_field!(field_name, value=T.unsafe(nil)); end - - def at(*args, &block); end - - def at_css(*args, &block); end - - def at_xpath(*args, &block); end - - def build_query(buttons=T.unsafe(nil)); end - - def button(criteria=T.unsafe(nil)); end - - def button_with(criteria=T.unsafe(nil)); end - - def button_with!(criteria=T.unsafe(nil)); end - - def buttons(); end - - def buttons_with(criteria=T.unsafe(nil)); end - - def checkbox(criteria=T.unsafe(nil)); end - - def checkbox_with(criteria=T.unsafe(nil)); end - - def checkbox_with!(criteria=T.unsafe(nil)); end - - def checkboxes(); end - - def checkboxes_with(criteria=T.unsafe(nil)); end - - def click_button(button=T.unsafe(nil)); end - - def css(*args, &block); end - - def delete_field!(field_name); end - - def dom_class(); end - - def dom_id(); end - - def elements(); end - - def encoding(); end - - def encoding=(encoding); end - - def enctype(); end - - def enctype=(enctype); end - - def field(criteria=T.unsafe(nil)); end - - def field_with(criteria=T.unsafe(nil)); end - - def field_with!(criteria=T.unsafe(nil)); end - - def fields(); end - - def fields_with(criteria=T.unsafe(nil)); end - - def file_upload(criteria=T.unsafe(nil)); end - - def file_upload_with(criteria=T.unsafe(nil)); end - - def file_upload_with!(criteria=T.unsafe(nil)); end - - def file_uploads(); end - - def file_uploads_with(criteria=T.unsafe(nil)); end - - def form_node(); end - - def has_field?(field_name); end - - def has_key?(field_name); end - - def has_value?(value); end - - def hidden_field?(field_name); end - - def hiddens(); end - - def ignore_encoding_error(); end - - def ignore_encoding_error=(ignore_encoding_error); end - - def initialize(node, mech=T.unsafe(nil), page=T.unsafe(nil)); end - - def keygens(); end - - def keys(); end - - def method(); end - - def method=(method); end - - def method_missing(meth, *args); end - - def name(); end - - def name=(name); end - - def node(); end - - def page(); end - - def radiobutton(criteria=T.unsafe(nil)); end - - def radiobutton_with(criteria=T.unsafe(nil)); end - - def radiobutton_with!(criteria=T.unsafe(nil)); end - - def radiobuttons(); end - - def radiobuttons_with(criteria=T.unsafe(nil)); end - - def request_data(); end - - def reset(); end - - def reset_button?(button_name); end - - def resets(); end - - def save_hash_field_order(); end - - def search(*args, &block); end - - def select_buttons(selector, method=T.unsafe(nil)); end - - def select_checkboxes(selector, method=T.unsafe(nil)); end - - def select_fields(selector, method=T.unsafe(nil)); end - - def select_file_uploads(selector, method=T.unsafe(nil)); end - - def select_radiobuttons(selector, method=T.unsafe(nil)); end - - def set_fields(fields=T.unsafe(nil)); end - - def submit(button=T.unsafe(nil), headers=T.unsafe(nil)); end - - def submit_button?(button_name); end - - def submits(); end - - def text_field?(field_name); end - - def textarea_field?(field_name); end - - def textareas(); end - - def texts(); end - - def values(); end - - def xpath(*args, &block); end - CRLF = ::T.let(nil, ::T.untyped) -end - -class Mechanize::Form::Button -end - -class Mechanize::Form::Button -end - -class Mechanize::Form::CheckBox -end - -class Mechanize::Form::CheckBox -end - -class Mechanize::Form::Field - def at(*args, &block); end - - def at_css(*args, &block); end - - def at_xpath(*args, &block); end - - def css(*args, &block); end - - def dom_class(); end - - def dom_id(); end - - def index(); end - - def index=(index); end - - def initialize(node, value=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def node(); end - - def node=(node); end - - def query_value(); end - - def raw_value(); end - - def search(*args, &block); end - - def type(); end - - def type=(type); end - - def value(); end - - def value=(value); end - - def xpath(*args, &block); end -end - -class Mechanize::Form::Field - extend ::Forwardable -end - -class Mechanize::Form::FileUpload - def file_data(); end - - def file_data=(file_data); end - - def file_name(); end - - def file_name=(file_name); end - - def initialize(node, file_name); end - - def mime_type(); end - - def mime_type=(mime_type); end -end - -class Mechanize::Form::FileUpload -end - -class Mechanize::Form::Hidden -end - -class Mechanize::Form::Hidden -end - -class Mechanize::Form::ImageButton - def initialize(*args); end - - def x(); end - - def x=(x); end - - def y(); end - - def y=(y); end -end - -class Mechanize::Form::ImageButton -end - -class Mechanize::Form::Keygen - def challenge(); end - - def generate_key(key_size=T.unsafe(nil)); end - - def key(); end -end - -class Mechanize::Form::Keygen -end - -class Mechanize::Form::MultiSelectList - def initialize(node); end - - def option(criteria=T.unsafe(nil)); end - - def option_with(criteria=T.unsafe(nil)); end - - def option_with!(criteria=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def options_with(criteria=T.unsafe(nil)); end - - def select_all(); end - - def select_none(); end - - def select_options(selector, method=T.unsafe(nil)); end - - def selected_options(); end - - def value=(values); end -end - -class Mechanize::Form::MultiSelectList - extend ::Mechanize::ElementMatcher -end - -class Mechanize::Form::Option - def click(); end - - def initialize(node, select_list); end - - def node(); end - - def select(); end - - def select_list(); end - - def selected(); end - - def selected?(); end - - def text(); end - - def tick(); end - - def unselect(); end - - def untick(); end - - def value(); end -end - -class Mechanize::Form::Option -end - -class Mechanize::Form::RadioButton - def ==(other); end - - def [](key); end - - def check(); end - - def checked(); end - - def checked=(checked); end - - def checked?(); end - - def click(); end - - def eql?(other); end - - def form(); end - - def initialize(node, form); end - - def label(); end - - def text(); end - - def uncheck(); end -end - -class Mechanize::Form::RadioButton -end - -class Mechanize::Form::Reset -end - -class Mechanize::Form::Reset -end - -class Mechanize::Form::SelectList - def value=(new_value); end -end - -class Mechanize::Form::SelectList -end - -class Mechanize::Form::Submit -end - -class Mechanize::Form::Submit -end - -class Mechanize::Form::Text -end - -class Mechanize::Form::Text -end - -class Mechanize::Form::Textarea -end - -class Mechanize::Form::Textarea -end - -class Mechanize::Form - extend ::Forwardable - extend ::Mechanize::ElementMatcher -end - -class Mechanize::HTTP -end - -class Mechanize::HTTP::Agent - def add_auth(uri, user, password, realm=T.unsafe(nil), domain=T.unsafe(nil)); end - - def add_default_auth(user, password, domain=T.unsafe(nil)); end - - def allowed_error_codes(); end - - def allowed_error_codes=(allowed_error_codes); end - - def auth_store(); end - - def authenticate_methods(); end - - def auto_io(name, read_size, input_io); end - - def back(); end - - def ca_file(); end - - def ca_file=(ca_file); end - - def cert_store(); end - - def cert_store=(cert_store); end - - def certificate(); end - - def certificate=(certificate); end - - def conditional_requests(); end - - def conditional_requests=(conditional_requests); end - - def connection_for(uri); end - - def content_encoding_gunzip(body_io); end - - def content_encoding_hooks(); end - - def content_encoding_inflate(body_io); end - - def context(); end - - def context=(context); end - - def cookie_jar(); end - - def cookie_jar=(cookie_jar); end - - def current_page(); end - - def digest_challenges(); end - - def disable_keep_alive(request); end - - def enable_gzip(request); end - - def fetch(uri, method=T.unsafe(nil), headers=T.unsafe(nil), params=T.unsafe(nil), referer=T.unsafe(nil), redirects=T.unsafe(nil)); end - - def follow_meta_refresh(); end - - def follow_meta_refresh=(follow_meta_refresh); end - - def follow_meta_refresh_self(); end - - def follow_meta_refresh_self=(follow_meta_refresh_self); end - - def get_meta_refresh(response, uri, page); end - - def get_robots(uri); end - - def gzip_enabled(); end - - def gzip_enabled=(gzip_enabled); end - - def history(); end - - def history=(history); end - - def hook_content_encoding(response, uri, response_body_io); end - - def http(); end - - def http_request(uri, method, params=T.unsafe(nil)); end - - def idle_timeout(); end - - def idle_timeout=(timeout); end - - def ignore_bad_chunking(); end - - def ignore_bad_chunking=(ignore_bad_chunking); end - - def inflate(compressed, window_bits=T.unsafe(nil)); end - - def initialize(connection_name=T.unsafe(nil)); end - - def keep_alive(); end - - def keep_alive=(keep_alive); end - - def log(); end - - def make_tempfile(name); end - - def max_file_buffer(); end - - def max_file_buffer=(max_file_buffer); end - - def max_history(); end - - def max_history=(length); end - - def open_timeout(); end - - def open_timeout=(open_timeout); end - - def pass(); end - - def pass=(pass); end - - def post_connect(uri, response, body_io); end - - def post_connect_hooks(); end - - def pre_connect(request); end - - def pre_connect_hooks(); end - - def private_key(); end - - def private_key=(private_key); end - - def proxy_uri(); end - - def read_timeout(); end - - def read_timeout=(read_timeout); end - - def redirect_ok(); end - - def redirect_ok=(redirect_ok); end - - def redirection_limit(); end - - def redirection_limit=(redirection_limit); end - - def request_add_headers(request, headers=T.unsafe(nil)); end - - def request_auth(request, uri); end - - def request_auth_digest(request, uri, realm, base_uri, iis); end - - def request_cookies(request, uri); end - - def request_headers(); end - - def request_headers=(request_headers); end - - def request_host(request, uri); end - - def request_language_charset(request); end - - def request_log(request); end - - def request_referer(request, uri, referer); end - - def request_user_agent(request); end - - def reset(); end - - def resolve(uri, referer=T.unsafe(nil)); end - - def resolve_parameters(uri, method, parameters); end - - def response_authenticate(response, page, uri, request, headers, params, referer); end - - def response_content_encoding(response, body_io); end - - def response_cookies(response, uri, page); end - - def response_follow_meta_refresh(response, uri, page, redirects); end - - def response_log(response); end - - def response_parse(response, body_io, uri); end - - def response_read(response, request, uri); end - - def response_redirect(response, method, page, redirects, headers, referer=T.unsafe(nil)); end - - def retry_change_requests(); end - - def retry_change_requests=(retri); end - - def robots(); end - - def robots=(value); end - - def robots_allowed?(uri); end - - def robots_disallowed?(url); end - - def robots_error(url); end - - def robots_error!(url); end - - def robots_mutex(); end - - def robots_reset(url); end - - def save_cookies(uri, set_cookie); end - - def scheme_handlers(); end - - def scheme_handlers=(scheme_handlers); end - - def secure_resolve!(uri, referer=T.unsafe(nil)); end - - def set_proxy(addr, port=T.unsafe(nil), user=T.unsafe(nil), pass=T.unsafe(nil)); end - - def shutdown(); end - - def ssl_version(); end - - def ssl_version=(ssl_version); end - - def use_tempfile?(size); end - - def user_agent(); end - - def user_agent=(user_agent); end - - def verify_callback(); end - - def verify_callback=(verify_callback); end - - def verify_mode(); end - - def verify_mode=(verify_mode); end - - def visited_page(url); end - - def webrobots(); end - RobotsKey = ::T.let(nil, ::T.untyped) -end - -class Mechanize::HTTP::Agent -end - -class Mechanize::HTTP::AuthChallenge - def [](param); end - - def params(); end - - def params=(_); end - - def raw(); end - - def raw=(_); end - - def realm(uri); end - - def realm_name(); end - - def scheme(); end - - def scheme=(_); end -end - -class Mechanize::HTTP::AuthChallenge - def self.[](*_); end - - def self.members(); end -end - -class Mechanize::HTTP::AuthRealm - def ==(other); end - - def eql?(other); end - - def initialize(scheme, uri, realm); end - - def realm(); end - - def scheme(); end - - def uri(); end -end - -class Mechanize::HTTP::AuthRealm -end - -class Mechanize::HTTP::AuthStore - def add_auth(uri, user, pass, realm=T.unsafe(nil), domain=T.unsafe(nil)); end - - def add_default_auth(user, pass, domain=T.unsafe(nil)); end - - def auth_accounts(); end - - def credentials?(uri, challenges); end - - def credentials_for(uri, realm); end - - def default_auth(); end - - def remove_auth(uri, realm=T.unsafe(nil)); end -end - -class Mechanize::HTTP::AuthStore -end - -class Mechanize::HTTP::ContentDisposition - def creation_date(); end - - def creation_date=(_); end - - def filename(); end - - def filename=(_); end - - def modification_date(); end - - def modification_date=(_); end - - def parameters(); end - - def parameters=(_); end - - def read_date(); end - - def read_date=(_); end - - def size=(_); end - - def type(); end - - def type=(_); end -end - -class Mechanize::HTTP::ContentDisposition - def self.[](*_); end - - def self.members(); end -end - -class Mechanize::HTTP::ContentDispositionParser - def parse(content_disposition, header=T.unsafe(nil)); end - - def parse_parameters(); end - - def rfc_2045_quoted_string(); end - - def rfc_2045_token(); end - - def rfc_2045_value(); end - - def scanner(); end - - def scanner=(scanner); end - - def spaces(); end -end - -class Mechanize::HTTP::ContentDispositionParser - def self.parse(content_disposition); end -end - -class Mechanize::HTTP::WWWAuthenticateParser - def auth_param(); end - - def auth_scheme(); end - - def parse(www_authenticate); end - - def quoted_string(); end - - def scan_comma_spaces(); end - - def scanner(); end - - def scanner=(scanner); end - - def spaces(); end - - def token(); end -end - -class Mechanize::HTTP::WWWAuthenticateParser -end - -class Mechanize::HTTP -end - -class Mechanize::Headers - def [](key); end - - def []=(key, value); end - - def canonical_each(); end - - def key?(key); end -end - -class Mechanize::Headers -end - -class Mechanize::History - def <<(page, uri=T.unsafe(nil)); end - - def initialize(max_size=T.unsafe(nil)); end - - def max_size(); end - - def max_size=(max_size); end - - def pop(); end - - def push(page, uri=T.unsafe(nil)); end - - def shift(); end - - def visited?(uri); end - - def visited_page(uri); end -end - -class Mechanize::History -end - -class Mechanize::Image -end - -class Mechanize::Image -end - -class Mechanize::Page - def %(*args, &block); end - - def /(*args, &block); end - - def at(*args, &block); end - - def at_css(*args, &block); end - - def at_xpath(*args, &block); end - - def base(criteria=T.unsafe(nil)); end - - def base_with(criteria=T.unsafe(nil)); end - - def base_with!(criteria=T.unsafe(nil)); end - - def bases(); end - - def bases_with(criteria=T.unsafe(nil)); end - - def canonical_uri(); end - - def content_type(); end - - def css(*args, &block); end - - def detected_encoding(); end - - def encoding(); end - - def encoding=(encoding); end - - def encoding_error?(parser=T.unsafe(nil)); end - - def encodings(); end - - def form(criteria=T.unsafe(nil)); end - - def form_with(criteria=T.unsafe(nil)); end - - def form_with!(criteria=T.unsafe(nil)); end - - def forms(); end - - def forms_with(criteria=T.unsafe(nil)); end - - def frame(criteria=T.unsafe(nil)); end - - def frame_with(criteria=T.unsafe(nil)); end - - def frame_with!(criteria=T.unsafe(nil)); end - - def frames(); end - - def frames_with(criteria=T.unsafe(nil)); end - - def iframe(criteria=T.unsafe(nil)); end - - def iframe_with(criteria=T.unsafe(nil)); end - - def iframe_with!(criteria=T.unsafe(nil)); end - - def iframes(); end - - def iframes_with(criteria=T.unsafe(nil)); end - - def image(criteria=T.unsafe(nil)); end - - def image_urls(); end - - def image_with(criteria=T.unsafe(nil)); end - - def image_with!(criteria=T.unsafe(nil)); end - - def images(); end - - def images_with(criteria=T.unsafe(nil)); end - - def initialize(uri=T.unsafe(nil), response=T.unsafe(nil), body=T.unsafe(nil), code=T.unsafe(nil), mech=T.unsafe(nil)); end - - def labels(); end - - def labels_hash(); end - - def link(criteria=T.unsafe(nil)); end - - def link_with(criteria=T.unsafe(nil)); end - - def link_with!(criteria=T.unsafe(nil)); end - - def links(); end - - def links_with(criteria=T.unsafe(nil)); end - - def mech(); end - - def mech=(mech); end - - def meta_charset(); end - - def meta_refresh(); end - - def parser(); end - - def reset(); end - - def response_header_charset(); end - - def root(); end - - def search(*args, &block); end - - def select_bases(selector, method=T.unsafe(nil)); end - - def select_forms(selector, method=T.unsafe(nil)); end - - def select_frames(selector, method=T.unsafe(nil)); end - - def select_iframes(selector, method=T.unsafe(nil)); end - - def select_images(selector, method=T.unsafe(nil)); end - - def select_links(selector, method=T.unsafe(nil)); end - - def title(); end - - def xpath(*args, &block); end - DEFAULT_RESPONSE = ::T.let(nil, ::T.untyped) -end - -class Mechanize::Page::Base -end - -class Mechanize::Page::Base -end - -class Mechanize::Page::Frame - def content(); end - - def initialize(node, mech, referer); end - - def name(); end - - def src(); end -end - -class Mechanize::Page::Frame -end - -class Mechanize::Page::Image - def alt(); end - - def caption(); end - - def dom_class(); end - - def dom_id(); end - - def extname(); end - - def fetch(parameters=T.unsafe(nil), referer=T.unsafe(nil), headers=T.unsafe(nil)); end - - def height(); end - - def image_referer(); end - - def initialize(node, page); end - - def mech(); end - - def mech=(mech); end - - def mime_type(); end - - def node(); end - - def page(); end - - def page=(page); end - - def relative?(); end - - def src(); end - - def text(); end - - def title(); end - - def uri(); end - - def url(); end - - def width(); end -end - -class Mechanize::Page::Image -end - -class Mechanize::Page::Label - def for(); end - - def initialize(node, page); end - - def node(); end - - def page(); end - - def text(); end -end - -class Mechanize::Page::Label -end - -class Mechanize::Page::Link - def attributes(); end - - def click(); end - - def dom_class(); end - - def dom_id(); end - - def href(); end - - def initialize(node, mech, page); end - - def node(); end - - def noreferrer?(); end - - def page(); end - - def referer(); end - - def rel(); end - - def rel?(kind); end - - def resolved_uri(); end - - def text(); end - - def uri(); end -end - -class Mechanize::Page::Link -end - -class Mechanize::Page::MetaRefresh - def delay(); end - - def initialize(node, page, delay, href, link_self=T.unsafe(nil)); end - - def link_self(); end - CONTENT_REGEXP = ::T.let(nil, ::T.untyped) - UNSAFE = ::T.let(nil, ::T.untyped) -end - -class Mechanize::Page::MetaRefresh - def self.from_node(node, page, uri=T.unsafe(nil)); end - - def self.parse(content, base_uri=T.unsafe(nil)); end -end - -class Mechanize::Page - extend ::Forwardable - extend ::Mechanize::ElementMatcher - def self.charset(content_type); end - - def self.charset_from_content_type(content_type); end - - def self.meta_charset(body); end - - def self.meta_content_type(body); end - - def self.response_header_charset(response); end -end - -module Mechanize::Parser - def [](*args, &block); end - - def []=(*args, &block); end - - def canonical_each(*args, &block); end - - def code(); end - - def code=(code); end - - def each(*args, &block); end - - def extract_filename(full_path=T.unsafe(nil)); end - - def fill_header(response); end - - def find_free_name(filename); end - - def header(); end - - def key?(*args, &block); end - - def response(); end - - def response=(response); end - - def uri(); end - - def uri=(uri); end - SPECIAL_FILENAMES = ::T.let(nil, ::T.untyped) -end - -module Mechanize::Parser - extend ::Forwardable -end - -class Mechanize::PluggableParser - def [](content_type); end - - def []=(content_type, klass); end - - def csv=(klass); end - - def default(); end - - def default=(default); end - - def html=(klass); end - - def parser(content_type); end - - def pdf=(klass); end - - def register_parser(content_type, klass); end - - def xhtml=(klass); end - - def xml=(klass); end - CONTENT_TYPES = ::T.let(nil, ::T.untyped) -end - -Mechanize::PluggableParser::InvalidContentTypeError = MIME::Type::InvalidContentType - -class Mechanize::PluggableParser -end - -class Mechanize::RedirectLimitReachedError - def initialize(page, redirects); end - - def page(); end - - def redirects(); end - - def response_code(); end -end - -class Mechanize::RedirectLimitReachedError -end - -class Mechanize::RedirectNotGetOrHeadError - def initialize(page, verb); end - - def page(); end - - def response_code(); end - - def uri(); end - - def verb(); end -end - -class Mechanize::RedirectNotGetOrHeadError -end - -class Mechanize::ResponseCodeError - def initialize(page, message=T.unsafe(nil)); end - - def page(); end - - def response_code(); end -end - -class Mechanize::ResponseCodeError -end - -class Mechanize::ResponseReadError - def body_io(); end - - def error(); end - - def force_parse(); end - - def initialize(error, response, body_io, uri, mechanize); end - - def mechanize(); end - - def response(); end - - def uri(); end -end - -class Mechanize::ResponseReadError -end - -class Mechanize::RobotsDisallowedError - def initialize(url); end - - def uri(); end - - def url(); end -end - -class Mechanize::RobotsDisallowedError -end - -class Mechanize::UnauthorizedError - def challenges(); end - - def initialize(page, challenges, message); end -end - -class Mechanize::UnauthorizedError -end - -class Mechanize::UnsupportedSchemeError - def initialize(scheme, uri); end - - def scheme(); end - - def scheme=(scheme); end - - def uri(); end - - def uri=(uri); end -end - -class Mechanize::UnsupportedSchemeError -end - -class Mechanize::Util - DefaultMimeTypes = ::T.let(nil, ::T.untyped) -end - -class Mechanize::Util - def self.build_query_string(parameters, enc=T.unsafe(nil)); end - - def self.detect_charset(src); end - - def self.each_parameter(parameters, &block); end - - def self.from_native_charset(s, code, ignore_encoding_error=T.unsafe(nil), log=T.unsafe(nil)); end - - def self.guess_encoding(src); end - - def self.html_unescape(s); end - - def self.uri_escape(str, unsafe=T.unsafe(nil)); end - - def self.uri_unescape(str); end -end - -class Mechanize::XmlFile - def at(*args, &block); end - - def search(*args, &block); end - - def xml(); end -end - -class Mechanize::XmlFile - extend ::Forwardable -end - -class Mechanize - def self.html_parser(); end - - def self.html_parser=(html_parser); end - - def self.inherited(child); end - - def self.log(); end - - def self.log=(log); end - - def self.start(); end -end - class Method include ::MethodSource::SourceLocation::MethodExtensions include ::MethodSource::MethodExtensions @@ -18071,68 +13240,6 @@ end class Net::HTTPVariantAlsoNegotiates end -class Net::NTLM::Blob - def self.inherited(subclass); end -end - -class Net::NTLM::FieldSet - def self.define(&block); end -end - -class Net::NTLM::Message::Type0 - def self.inherited(subclass); end -end - -class Net::NTLM::Message::Type1 - def padding(); end - - def padding=(val); end - - def parse(str); end -end - -class Net::NTLM::Message::Type1 - def self.inherited(subclass); end -end - -class Net::NTLM::Message::Type2 - def padding(); end - - def padding=(val); end - - def parse(str); end -end - -class Net::NTLM::Message::Type2 - def self.inherited(subclass); end -end - -class Net::NTLM::Message::Type3 - def self.inherited(subclass); end -end - -class Net::NTLM::SecurityBuffer - def self.inherited(subclass); end -end - -module Net::NTLM::VERSION - MAJOR = ::T.let(nil, ::T.untyped) - MINOR = ::T.let(nil, ::T.untyped) - STRING = ::T.let(nil, ::T.untyped) - TINY = ::T.let(nil, ::T.untyped) -end - -module Net::NTLM::VERSION -end - -module Net::NTLM - def self.decode_utf16le(str); end - - def self.encode_utf16le(str); end - - def self.swap16(str); end -end - Net::NetPrivate::HTTPRequest = Net::HTTPRequest Net::NetPrivate::Socket = Net::InternetMessageIO @@ -18161,1832 +13268,8 @@ class NilClass def try!(method_name=T.unsafe(nil), *args); end end -class NoSeedProgressFormatter -end - -module Nokogiri - LIBXML_ICONV_ENABLED = ::T.let(nil, ::T.untyped) - LIBXML_PARSER_VERSION = ::T.let(nil, ::T.untyped) - LIBXML_VERSION = ::T.let(nil, ::T.untyped) - NOKOGIRI_LIBXML2_PATCHES = ::T.let(nil, ::T.untyped) - NOKOGIRI_LIBXML2_PATH = ::T.let(nil, ::T.untyped) - NOKOGIRI_LIBXSLT_PATCHES = ::T.let(nil, ::T.untyped) - NOKOGIRI_LIBXSLT_PATH = ::T.let(nil, ::T.untyped) - NOKOGIRI_USE_PACKAGED_LIBRARIES = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - VERSION_INFO = ::T.let(nil, ::T.untyped) -end - -module Nokogiri::CSS -end - -class Nokogiri::CSS::Node - def accept(visitor); end - - def find_by_type(types); end - - def initialize(type, value); end - - def to_a(); end - - def to_type(); end - - def to_xpath(prefix=T.unsafe(nil), visitor=T.unsafe(nil)); end - - def type(); end - - def type=(type); end - - def value(); end - - def value=(value); end - ALLOW_COMBINATOR_ON_SELF = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::CSS::Node -end - class Nokogiri::CSS::Parser - def _reduce_1(val, _values, result); end - - def _reduce_11(val, _values, result); end - - def _reduce_12(val, _values, result); end - - def _reduce_13(val, _values, result); end - - def _reduce_14(val, _values, result); end - - def _reduce_15(val, _values, result); end - - def _reduce_16(val, _values, result); end - - def _reduce_18(val, _values, result); end - - def _reduce_2(val, _values, result); end - - def _reduce_20(val, _values, result); end - - def _reduce_21(val, _values, result); end - - def _reduce_22(val, _values, result); end - - def _reduce_23(val, _values, result); end - - def _reduce_25(val, _values, result); end - - def _reduce_26(val, _values, result); end - - def _reduce_27(val, _values, result); end - - def _reduce_28(val, _values, result); end - - def _reduce_29(val, _values, result); end - - def _reduce_3(val, _values, result); end - - def _reduce_30(val, _values, result); end - - def _reduce_31(val, _values, result); end - - def _reduce_32(val, _values, result); end - - def _reduce_33(val, _values, result); end - - def _reduce_34(val, _values, result); end - - def _reduce_35(val, _values, result); end - - def _reduce_36(val, _values, result); end - - def _reduce_37(val, _values, result); end - - def _reduce_4(val, _values, result); end - - def _reduce_40(val, _values, result); end - - def _reduce_41(val, _values, result); end - - def _reduce_42(val, _values, result); end - - def _reduce_43(val, _values, result); end - - def _reduce_44(val, _values, result); end - - def _reduce_45(val, _values, result); end - - def _reduce_48(val, _values, result); end - - def _reduce_49(val, _values, result); end - - def _reduce_5(val, _values, result); end - - def _reduce_50(val, _values, result); end - - def _reduce_51(val, _values, result); end - - def _reduce_52(val, _values, result); end - - def _reduce_58(val, _values, result); end - - def _reduce_59(val, _values, result); end - - def _reduce_6(val, _values, result); end - - def _reduce_60(val, _values, result); end - - def _reduce_61(val, _values, result); end - - def _reduce_63(val, _values, result); end - - def _reduce_64(val, _values, result); end - - def _reduce_65(val, _values, result); end - - def _reduce_66(val, _values, result); end - - def _reduce_67(val, _values, result); end - - def _reduce_68(val, _values, result); end - - def _reduce_69(val, _values, result); end - - def _reduce_7(val, _values, result); end - - def _reduce_70(val, _values, result); end - - def _reduce_8(val, _values, result); end - - def _reduce_9(val, _values, result); end - - def _reduce_none(val, _values, result); end - - def initialize(namespaces=T.unsafe(nil)); end - - def on_error(error_token_id, error_value, value_stack); end - - def parse(string); end - - def unescape_css_identifier(identifier); end - - def unescape_css_string(str); end - - def xpath_for(string, options=T.unsafe(nil)); end - Racc_arg = ::T.let(nil, ::T.untyped) Racc_debug_parser = ::T.let(nil, ::T.untyped) - Racc_token_to_s_table = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::CSS::Parser - def self.[](string); end - - def self.[]=(string, value); end - - def self.cache_on(); end - - def self.cache_on=(cache_on); end - - def self.cache_on?(); end - - def self.clear_cache(); end - - def self.parse(selector); end - - def self.set_cache(_); end - - def self.without_cache(&block); end -end - -class Nokogiri::CSS::SyntaxError -end - -class Nokogiri::CSS::SyntaxError -end - -class Nokogiri::CSS::Tokenizer - def _next_token(); end - - def action(); end - - def filename(); end - - def lineno(); end - - def load_file(filename); end - - def next_token(); end - - def scan(str); end - - def scan_file(filename); end - - def scan_setup(str); end - - def scan_str(str); end - - def state(); end - - def state=(state); end -end - -class Nokogiri::CSS::Tokenizer::ScanError -end - -class Nokogiri::CSS::Tokenizer::ScanError -end - -class Nokogiri::CSS::Tokenizer -end - -class Nokogiri::CSS::XPathVisitor - def accept(node); end - - def visit_attribute_condition(node); end - - def visit_child_selector(node); end - - def visit_class_condition(node); end - - def visit_combinator(node); end - - def visit_conditional_selector(node); end - - def visit_descendant_selector(node); end - - def visit_direct_adjacent_selector(node); end - - def visit_element_name(node); end - - def visit_following_selector(node); end - - def visit_function(node); end - - def visit_id(node); end - - def visit_not(node); end - - def visit_pseudo_class(node); end -end - -class Nokogiri::CSS::XPathVisitor -end - -module Nokogiri::CSS - def self.parse(selector); end - - def self.xpath_for(selector, options=T.unsafe(nil)); end -end - -module Nokogiri::Decorators -end - -module Nokogiri::Decorators::Slop - def method_missing(name, *args, &block); end - XPATH_PREFIX = ::T.let(nil, ::T.untyped) -end - -module Nokogiri::Decorators::Slop -end - -module Nokogiri::Decorators -end - -class Nokogiri::EncodingHandler - def name(); end -end - -class Nokogiri::EncodingHandler - def self.[](_); end - - def self.alias(_, _1); end - - def self.clear_aliases!(); end - - def self.delete(_); end -end - -module Nokogiri::HTML - NamedCharacters = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::HTML::Builder - def to_html(); end -end - -class Nokogiri::HTML::Builder -end - -class Nokogiri::HTML::Document - def meta_encoding(); end - - def meta_encoding=(encoding); end - - def meta_robots(custom_name=T.unsafe(nil)); end - - def nofollow?(custom_name=T.unsafe(nil)); end - - def noindex?(custom_name=T.unsafe(nil)); end - - def serialize(options=T.unsafe(nil)); end - - def title(); end - - def title=(text); end -end - -class Nokogiri::HTML::Document::EncodingFound - def found_encoding(); end - - def initialize(encoding); end -end - -class Nokogiri::HTML::Document::EncodingFound -end - -class Nokogiri::HTML::Document::EncodingReader - def encoding_found(); end - - def initialize(io); end - - def read(len); end -end - -class Nokogiri::HTML::Document::EncodingReader::JumpSAXHandler - def initialize(jumptag); end -end - -class Nokogiri::HTML::Document::EncodingReader::JumpSAXHandler -end - -class Nokogiri::HTML::Document::EncodingReader::SAXHandler - def encoding(); end -end - -class Nokogiri::HTML::Document::EncodingReader::SAXHandler -end - -class Nokogiri::HTML::Document::EncodingReader - def self.detect_encoding(chunk); end - - def self.detect_encoding_for_jruby_without_fix(chunk); end - - def self.is_jruby_without_fix?(); end -end - -class Nokogiri::HTML::Document -end - -class Nokogiri::HTML::DocumentFragment -end - -class Nokogiri::HTML::DocumentFragment - def self.parse(tags, encoding=T.unsafe(nil)); end -end - -class Nokogiri::HTML::ElementDescription - def block?(); end - - def default_sub_element(); end - - def deprecated?(); end - - def deprecated_attributes(); end - - def description(); end - - def empty?(); end - - def implied_end_tag?(); end - - def implied_start_tag?(); end - - def inline?(); end - - def name(); end - - def optional_attributes(); end - - def required_attributes(); end - - def save_end_tag?(); end - - def sub_elements(); end - ACTION_ATTR = ::T.let(nil, ::T.untyped) - ALIGN_ATTR = ::T.let(nil, ::T.untyped) - ALT_ATTR = ::T.let(nil, ::T.untyped) - APPLET_ATTRS = ::T.let(nil, ::T.untyped) - AREA_ATTRS = ::T.let(nil, ::T.untyped) - ATTRS = ::T.let(nil, ::T.untyped) - A_ATTRS = ::T.let(nil, ::T.untyped) - BASEFONT_ATTRS = ::T.let(nil, ::T.untyped) - BGCOLOR_ATTR = ::T.let(nil, ::T.untyped) - BLOCK = ::T.let(nil, ::T.untyped) - BLOCKLI_ELT = ::T.let(nil, ::T.untyped) - BODY_ATTRS = ::T.let(nil, ::T.untyped) - BODY_CONTENTS = ::T.let(nil, ::T.untyped) - BODY_DEPR = ::T.let(nil, ::T.untyped) - BUTTON_ATTRS = ::T.let(nil, ::T.untyped) - CELLHALIGN = ::T.let(nil, ::T.untyped) - CELLVALIGN = ::T.let(nil, ::T.untyped) - CLEAR_ATTRS = ::T.let(nil, ::T.untyped) - COL_ATTRS = ::T.let(nil, ::T.untyped) - COL_ELT = ::T.let(nil, ::T.untyped) - COMPACT_ATTR = ::T.let(nil, ::T.untyped) - COMPACT_ATTRS = ::T.let(nil, ::T.untyped) - CONTENT_ATTR = ::T.let(nil, ::T.untyped) - COREATTRS = ::T.let(nil, ::T.untyped) - CORE_ATTRS = ::T.let(nil, ::T.untyped) - CORE_I18N_ATTRS = ::T.let(nil, ::T.untyped) - DIR_ATTR = ::T.let(nil, ::T.untyped) - DL_CONTENTS = ::T.let(nil, ::T.untyped) - DefaultDescriptions = ::T.let(nil, ::T.untyped) - EDIT_ATTRS = ::T.let(nil, ::T.untyped) - EMBED_ATTRS = ::T.let(nil, ::T.untyped) - EMPTY = ::T.let(nil, ::T.untyped) - EVENTS = ::T.let(nil, ::T.untyped) - FIELDSET_CONTENTS = ::T.let(nil, ::T.untyped) - FLOW = ::T.let(nil, ::T.untyped) - FLOW_PARAM = ::T.let(nil, ::T.untyped) - FONTSTYLE = ::T.let(nil, ::T.untyped) - FONT_ATTRS = ::T.let(nil, ::T.untyped) - FORMCTRL = ::T.let(nil, ::T.untyped) - FORM_ATTRS = ::T.let(nil, ::T.untyped) - FORM_CONTENTS = ::T.let(nil, ::T.untyped) - FRAMESET_ATTRS = ::T.let(nil, ::T.untyped) - FRAMESET_CONTENTS = ::T.let(nil, ::T.untyped) - FRAME_ATTRS = ::T.let(nil, ::T.untyped) - HEADING = ::T.let(nil, ::T.untyped) - HEAD_ATTRS = ::T.let(nil, ::T.untyped) - HEAD_CONTENTS = ::T.let(nil, ::T.untyped) - HREF_ATTRS = ::T.let(nil, ::T.untyped) - HR_DEPR = ::T.let(nil, ::T.untyped) - HTML_ATTRS = ::T.let(nil, ::T.untyped) - HTML_CDATA = ::T.let(nil, ::T.untyped) - HTML_CONTENT = ::T.let(nil, ::T.untyped) - HTML_FLOW = ::T.let(nil, ::T.untyped) - HTML_INLINE = ::T.let(nil, ::T.untyped) - HTML_PCDATA = ::T.let(nil, ::T.untyped) - I18N = ::T.let(nil, ::T.untyped) - I18N_ATTRS = ::T.let(nil, ::T.untyped) - IFRAME_ATTRS = ::T.let(nil, ::T.untyped) - IMG_ATTRS = ::T.let(nil, ::T.untyped) - INLINE = ::T.let(nil, ::T.untyped) - INLINE_P = ::T.let(nil, ::T.untyped) - INPUT_ATTRS = ::T.let(nil, ::T.untyped) - LABEL_ATTR = ::T.let(nil, ::T.untyped) - LABEL_ATTRS = ::T.let(nil, ::T.untyped) - LANGUAGE_ATTR = ::T.let(nil, ::T.untyped) - LEGEND_ATTRS = ::T.let(nil, ::T.untyped) - LINK_ATTRS = ::T.let(nil, ::T.untyped) - LIST = ::T.let(nil, ::T.untyped) - LI_ELT = ::T.let(nil, ::T.untyped) - MAP_CONTENTS = ::T.let(nil, ::T.untyped) - META_ATTRS = ::T.let(nil, ::T.untyped) - MODIFIER = ::T.let(nil, ::T.untyped) - NAME_ATTR = ::T.let(nil, ::T.untyped) - NOFRAMES_CONTENT = ::T.let(nil, ::T.untyped) - OBJECT_ATTRS = ::T.let(nil, ::T.untyped) - OBJECT_CONTENTS = ::T.let(nil, ::T.untyped) - OBJECT_DEPR = ::T.let(nil, ::T.untyped) - OL_ATTRS = ::T.let(nil, ::T.untyped) - OPTGROUP_ATTRS = ::T.let(nil, ::T.untyped) - OPTION_ATTRS = ::T.let(nil, ::T.untyped) - OPTION_ELT = ::T.let(nil, ::T.untyped) - PARAM_ATTRS = ::T.let(nil, ::T.untyped) - PCDATA = ::T.let(nil, ::T.untyped) - PHRASE = ::T.let(nil, ::T.untyped) - PRE_CONTENT = ::T.let(nil, ::T.untyped) - PROMPT_ATTRS = ::T.let(nil, ::T.untyped) - QUOTE_ATTRS = ::T.let(nil, ::T.untyped) - ROWS_COLS_ATTR = ::T.let(nil, ::T.untyped) - SCRIPT_ATTRS = ::T.let(nil, ::T.untyped) - SELECT_ATTRS = ::T.let(nil, ::T.untyped) - SELECT_CONTENT = ::T.let(nil, ::T.untyped) - SPECIAL = ::T.let(nil, ::T.untyped) - SRC_ALT_ATTRS = ::T.let(nil, ::T.untyped) - STYLE_ATTRS = ::T.let(nil, ::T.untyped) - TABLE_ATTRS = ::T.let(nil, ::T.untyped) - TABLE_CONTENTS = ::T.let(nil, ::T.untyped) - TABLE_DEPR = ::T.let(nil, ::T.untyped) - TALIGN_ATTRS = ::T.let(nil, ::T.untyped) - TARGET_ATTR = ::T.let(nil, ::T.untyped) - TEXTAREA_ATTRS = ::T.let(nil, ::T.untyped) - TH_TD_ATTR = ::T.let(nil, ::T.untyped) - TH_TD_DEPR = ::T.let(nil, ::T.untyped) - TR_CONTENTS = ::T.let(nil, ::T.untyped) - TR_ELT = ::T.let(nil, ::T.untyped) - TYPE_ATTR = ::T.let(nil, ::T.untyped) - UL_DEPR = ::T.let(nil, ::T.untyped) - VERSION_ATTR = ::T.let(nil, ::T.untyped) - WIDTH_ATTR = ::T.let(nil, ::T.untyped) -end - -Nokogiri::HTML::ElementDescription::Desc = Struct::HTMLElementDescription - -class Nokogiri::HTML::ElementDescription - def self.[](_); end -end - -class Nokogiri::HTML::EntityDescription -end - -class Nokogiri::HTML::EntityDescription -end - -class Nokogiri::HTML::EntityLookup - def [](name); end - - def get(_); end -end - -class Nokogiri::HTML::EntityLookup -end - -module Nokogiri::HTML::SAX -end - -class Nokogiri::HTML::SAX::Parser - def parse_file(filename, encoding=T.unsafe(nil)); end - - def parse_memory(data, encoding=T.unsafe(nil)); end -end - -class Nokogiri::HTML::SAX::Parser -end - -class Nokogiri::HTML::SAX::ParserContext -end - -class Nokogiri::HTML::SAX::ParserContext - def self.file(_, _1); end - - def self.memory(_, _1); end -end - -class Nokogiri::HTML::SAX::PushParser -end - -class Nokogiri::HTML::SAX::PushParser -end - -module Nokogiri::HTML::SAX -end - -module Nokogiri::HTML - def self.fragment(string, encoding=T.unsafe(nil)); end - - def self.parse(thing, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil), &block); end -end - -class Nokogiri::SyntaxError -end - -class Nokogiri::SyntaxError -end - -class Nokogiri::VersionInfo - def compiled_parser_version(); end - - def engine(); end - - def jruby?(); end - - def libxml2?(); end - - def libxml2_using_packaged?(); end - - def libxml2_using_system?(); end - - def loaded_parser_version(); end - - def to_hash(); end - - def to_markdown(); end - - def warnings(); end -end - -class Nokogiri::VersionInfo - def self.instance(); end -end - -module Nokogiri::XML - XML_C14N_1_0 = ::T.let(nil, ::T.untyped) - XML_C14N_1_1 = ::T.let(nil, ::T.untyped) - XML_C14N_EXCLUSIVE_1_0 = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::Attr - def content=(content); end - - def value(); end - - def value=(value); end -end - -class Nokogiri::XML::Attr -end - -class Nokogiri::XML::AttributeDecl - def attribute_type(); end - - def default(); end - - def enumeration(); end -end - -class Nokogiri::XML::AttributeDecl -end - -class Nokogiri::XML::Builder - def <<(string); end - - def [](ns); end - - def arity(); end - - def arity=(arity); end - - def cdata(string); end - - def comment(string); end - - def context(); end - - def context=(context); end - - def doc(); end - - def doc=(doc); end - - def initialize(options=T.unsafe(nil), root=T.unsafe(nil), &block); end - - def method_missing(method, *args, &block); end - - def parent(); end - - def parent=(parent); end - - def text(string); end - - def to_xml(*args); end -end - -class Nokogiri::XML::Builder - def self.with(root, &block); end -end - -class Nokogiri::XML::CDATA -end - -class Nokogiri::XML::CDATA -end - -class Nokogiri::XML::CharacterData - include ::Nokogiri::XML::PP::CharacterData -end - -class Nokogiri::XML::CharacterData -end - -class Nokogiri::XML::Comment -end - -class Nokogiri::XML::Comment -end - -class Nokogiri::XML::DTD - def entities(); end - - def external_id(); end - - def html5_dtd?(); end - - def html_dtd?(); end - - def notations(); end - - def system_id(); end - - def validate(_); end -end - -class Nokogiri::XML::DTD -end - -class Nokogiri::XML::Document - def canonicalize(*_); end - - def collect_namespaces(); end - - def create_cdata(string, &block); end - - def create_comment(string, &block); end - - def create_element(name, *args, &block); end - - def create_entity(*_); end - - def create_text_node(string, &block); end - - def decorate(node); end - - def decorators(key); end - - def encoding(); end - - def encoding=(encoding); end - - def errors(); end - - def errors=(errors); end - - def fragment(tags=T.unsafe(nil)); end - - def initialize(*args); end - - def remove_namespaces!(); end - - def root(); end - - def root=(root); end - - def slop!(); end - - def to_java(); end - - def to_xml(*args, &block); end - - def url(); end - - def validate(); end - - def version(); end - IMPLIED_XPATH_CONTEXTS = ::T.let(nil, ::T.untyped) - NCNAME_CHAR = ::T.let(nil, ::T.untyped) - NCNAME_RE = ::T.let(nil, ::T.untyped) - NCNAME_START_CHAR = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::Document - def self.empty_doc?(string_or_io); end - - def self.parse(string_or_io, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.read_io(_, _1, _2, _3); end - - def self.read_memory(_, _1, _2, _3); end - - def self.wrap(document); end -end - -class Nokogiri::XML::DocumentFragment - def dup(); end - - def errors(); end - - def errors=(things); end - - def initialize(document, tags=T.unsafe(nil), ctx=T.unsafe(nil)); end - - def search(*rules); end - - def serialize(); end - - def to_html(*args); end - - def to_xhtml(*args); end - - def to_xml(*args); end -end - -class Nokogiri::XML::DocumentFragment - def self.parse(tags); end -end - -class Nokogiri::XML::Element -end - -class Nokogiri::XML::Element -end - -class Nokogiri::XML::ElementContent - def children(); end - - def document(); end - - def name(); end - - def occur(); end - - def prefix(); end - - def type(); end - ELEMENT = ::T.let(nil, ::T.untyped) - MULT = ::T.let(nil, ::T.untyped) - ONCE = ::T.let(nil, ::T.untyped) - OPT = ::T.let(nil, ::T.untyped) - OR = ::T.let(nil, ::T.untyped) - PCDATA = ::T.let(nil, ::T.untyped) - PLUS = ::T.let(nil, ::T.untyped) - SEQ = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::ElementContent -end - -class Nokogiri::XML::ElementDecl - def element_type(); end - - def prefix(); end -end - -class Nokogiri::XML::ElementDecl -end - -class Nokogiri::XML::EntityDecl - def entity_type(); end - - def external_id(); end - - def original_content(); end - - def system_id(); end - EXTERNAL_GENERAL_PARSED = ::T.let(nil, ::T.untyped) - EXTERNAL_GENERAL_UNPARSED = ::T.let(nil, ::T.untyped) - EXTERNAL_PARAMETER = ::T.let(nil, ::T.untyped) - INTERNAL_GENERAL = ::T.let(nil, ::T.untyped) - INTERNAL_PARAMETER = ::T.let(nil, ::T.untyped) - INTERNAL_PREDEFINED = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::EntityDecl - def self.new(name, doc, *args); end -end - -class Nokogiri::XML::EntityReference -end - -class Nokogiri::XML::EntityReference -end - -class Nokogiri::XML::Namespace - include ::Nokogiri::XML::PP::Node - def document(); end - - def href(); end - - def prefix(); end -end - -class Nokogiri::XML::Namespace -end - -class Nokogiri::XML::Node - include ::Nokogiri::XML::PP::Node - include ::Nokogiri::XML::Searchable - include ::Enumerable - def <<(node_or_tags); end - - def ==(other); end - - def >(selector); end - - def [](name); end - - def []=(name, value); end - - def accept(visitor); end - - def add_child(node_or_tags); end - - def add_class(name); end - - def add_namespace(_, _1); end - - def add_namespace_definition(_, _1); end - - def add_next_sibling(node_or_tags); end - - def add_previous_sibling(node_or_tags); end - - def after(node_or_tags); end - - def ancestors(selector=T.unsafe(nil)); end - - def append_class(name); end - - def attr(name); end - - def attribute(_); end - - def attribute_nodes(); end - - def attribute_with_ns(_, _1); end - - def attributes(); end - - def before(node_or_tags); end - - def canonicalize(mode=T.unsafe(nil), inclusive_namespaces=T.unsafe(nil), with_comments=T.unsafe(nil)); end - - def cdata?(); end - - def child(); end - - def children(); end - - def children=(node_or_tags); end - - def classes(); end - - def comment?(); end - - def content(); end - - def content=(string); end - - def create_external_subset(_, _1, _2); end - - def create_internal_subset(_, _1, _2); end - - def css_path(); end - - def decorate!(); end - - def default_namespace=(url); end - - def delete(name); end - - def description(); end - - def do_xinclude(options=T.unsafe(nil)); end - - def document(); end - - def document?(); end - - def dup(*_); end - - def each(&blk); end - - def elem?(); end - - def element?(); end - - def element_children(); end - - def elements(); end - - def encode_special_chars(_); end - - def external_subset(); end - - def first_element_child(); end - - def fragment(tags); end - - def fragment?(); end - - def get_attribute(name); end - - def has_attribute?(_); end - - def html?(); end - - def initialize(name, document); end - - def inner_html(*args); end - - def inner_html=(node_or_tags); end - - def inner_text(); end - - def internal_subset(); end - - def key?(_); end - - def keys(); end - - def lang(); end - - def lang=(lang); end - - def last_element_child(); end - - def line(); end - - def matches?(selector); end - - def name(); end - - def name=(name); end - - def namespace(); end - - def namespace=(ns); end - - def namespace_definitions(); end - - def namespace_scopes(); end - - def namespaced_key?(_, _1); end - - def namespaces(); end - - def native_content=(native_content); end - - def next(); end - - def next=(node_or_tags); end - - def next_element(); end - - def next_sibling(); end - - def node_name(); end - - def node_name=(node_name); end - - def node_type(); end - - def parent(); end - - def parent=(parent_node); end - - def parse(string_or_io, options=T.unsafe(nil)); end - - def path(); end - - def pointer_id(); end - - def prepend_child(node_or_tags); end - - def previous(); end - - def previous=(node_or_tags); end - - def previous_element(); end - - def previous_sibling(); end - - def processing_instruction?(); end - - def read_only?(); end - - def remove(); end - - def remove_attribute(name); end - - def remove_class(name=T.unsafe(nil)); end - - def replace(node_or_tags); end - - def serialize(*args, &block); end - - def set_attribute(name, value); end - - def swap(node_or_tags); end - - def text(); end - - def text?(); end - - def to_html(options=T.unsafe(nil)); end - - def to_str(); end - - def to_xhtml(options=T.unsafe(nil)); end - - def to_xml(options=T.unsafe(nil)); end - - def traverse(&block); end - - def type(); end - - def unlink(); end - - def values(); end - - def wrap(html); end - - def write_html_to(io, options=T.unsafe(nil)); end - - def write_to(io, *options); end - - def write_xhtml_to(io, options=T.unsafe(nil)); end - - def write_xml_to(io, options=T.unsafe(nil)); end - - def xml?(); end - ATTRIBUTE_DECL = ::T.let(nil, ::T.untyped) - ATTRIBUTE_NODE = ::T.let(nil, ::T.untyped) - CDATA_SECTION_NODE = ::T.let(nil, ::T.untyped) - COMMENT_NODE = ::T.let(nil, ::T.untyped) - DOCB_DOCUMENT_NODE = ::T.let(nil, ::T.untyped) - DOCUMENT_FRAG_NODE = ::T.let(nil, ::T.untyped) - DOCUMENT_NODE = ::T.let(nil, ::T.untyped) - DOCUMENT_TYPE_NODE = ::T.let(nil, ::T.untyped) - DTD_NODE = ::T.let(nil, ::T.untyped) - ELEMENT_DECL = ::T.let(nil, ::T.untyped) - ELEMENT_NODE = ::T.let(nil, ::T.untyped) - ENTITY_DECL = ::T.let(nil, ::T.untyped) - ENTITY_NODE = ::T.let(nil, ::T.untyped) - ENTITY_REF_NODE = ::T.let(nil, ::T.untyped) - HTML_DOCUMENT_NODE = ::T.let(nil, ::T.untyped) - IMPLIED_XPATH_CONTEXTS = ::T.let(nil, ::T.untyped) - NAMESPACE_DECL = ::T.let(nil, ::T.untyped) - NOTATION_NODE = ::T.let(nil, ::T.untyped) - PI_NODE = ::T.let(nil, ::T.untyped) - TEXT_NODE = ::T.let(nil, ::T.untyped) - XINCLUDE_END = ::T.let(nil, ::T.untyped) - XINCLUDE_START = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::Node -end - -class Nokogiri::XML::NodeSet - include ::Nokogiri::XML::Searchable - include ::Enumerable - def &(_); end - - def +(_); end - - def -(_); end - - def <<(_); end - - def ==(other); end - - def >(selector); end - - def [](*_); end - - def add_class(name); end - - def after(datum); end - - def append_class(name); end - - def attr(key, value=T.unsafe(nil), &block); end - - def attribute(key, value=T.unsafe(nil), &block); end - - def before(datum); end - - def children(); end - - def clone(); end - - def delete(_); end - - def document(); end - - def document=(document); end - - def each(&blk); end - - def empty?(); end - - def filter(expr); end - - def first(n=T.unsafe(nil)); end - - def index(node=T.unsafe(nil)); end - - def initialize(document, list=T.unsafe(nil)); end - - def inner_html(*args); end - - def inner_text(); end - - def last(); end - - def length(); end - - def pop(); end - - def push(_); end - - def remove(); end - - def remove_attr(name); end - - def remove_attribute(name); end - - def remove_class(name=T.unsafe(nil)); end - - def reverse(); end - - def set(key, value=T.unsafe(nil), &block); end - - def shift(); end - - def size(); end - - def slice(*_); end - - def text(); end - - def to_a(); end - - def to_ary(); end - - def to_html(*args); end - - def to_xhtml(*args); end - - def to_xml(*args); end - - def unlink(); end - - def wrap(html); end - - def |(_); end - IMPLIED_XPATH_CONTEXTS = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::NodeSet -end - -class Nokogiri::XML::Notation -end - -class Nokogiri::XML::Notation -end - -module Nokogiri::XML::PP -end - -module Nokogiri::XML::PP::CharacterData - def inspect(); end - - def pretty_print(pp); end -end - -module Nokogiri::XML::PP::CharacterData -end - -module Nokogiri::XML::PP::Node - def inspect(); end - - def pretty_print(pp); end -end - -module Nokogiri::XML::PP::Node -end - -module Nokogiri::XML::PP -end - -class Nokogiri::XML::ParseOptions - def compact(); end - - def compact?(); end - - def default_html(); end - - def default_html?(); end - - def default_xml(); end - - def default_xml?(); end - - def dtdattr(); end - - def dtdattr?(); end - - def dtdload(); end - - def dtdload?(); end - - def dtdvalid(); end - - def dtdvalid?(); end - - def huge(); end - - def huge?(); end - - def initialize(options=T.unsafe(nil)); end - - def nobasefix(); end - - def nobasefix?(); end - - def noblanks(); end - - def noblanks?(); end - - def nocdata(); end - - def nocdata?(); end - - def nocompact(); end - - def nodefault_html(); end - - def nodefault_xml(); end - - def nodict(); end - - def nodict?(); end - - def nodtdattr(); end - - def nodtdload(); end - - def nodtdvalid(); end - - def noent(); end - - def noent?(); end - - def noerror(); end - - def noerror?(); end - - def nohuge(); end - - def nonet(); end - - def nonet?(); end - - def nonobasefix(); end - - def nonoblanks(); end - - def nonocdata(); end - - def nonodict(); end - - def nonoent(); end - - def nonoerror(); end - - def nononet(); end - - def nonowarning(); end - - def nonoxincnode(); end - - def nonsclean(); end - - def noold10(); end - - def nopedantic(); end - - def norecover(); end - - def nosax1(); end - - def nowarning(); end - - def nowarning?(); end - - def noxinclude(); end - - def noxincnode(); end - - def noxincnode?(); end - - def nsclean(); end - - def nsclean?(); end - - def old10(); end - - def old10?(); end - - def options(); end - - def options=(options); end - - def pedantic(); end - - def pedantic?(); end - - def recover(); end - - def recover?(); end - - def sax1(); end - - def sax1?(); end - - def strict(); end - - def strict?(); end - - def to_i(); end - - def xinclude(); end - - def xinclude?(); end - COMPACT = ::T.let(nil, ::T.untyped) - DEFAULT_HTML = ::T.let(nil, ::T.untyped) - DEFAULT_XML = ::T.let(nil, ::T.untyped) - DTDATTR = ::T.let(nil, ::T.untyped) - DTDLOAD = ::T.let(nil, ::T.untyped) - DTDVALID = ::T.let(nil, ::T.untyped) - HUGE = ::T.let(nil, ::T.untyped) - NOBASEFIX = ::T.let(nil, ::T.untyped) - NOBLANKS = ::T.let(nil, ::T.untyped) - NOCDATA = ::T.let(nil, ::T.untyped) - NODICT = ::T.let(nil, ::T.untyped) - NOENT = ::T.let(nil, ::T.untyped) - NOERROR = ::T.let(nil, ::T.untyped) - NONET = ::T.let(nil, ::T.untyped) - NOWARNING = ::T.let(nil, ::T.untyped) - NOXINCNODE = ::T.let(nil, ::T.untyped) - NSCLEAN = ::T.let(nil, ::T.untyped) - OLD10 = ::T.let(nil, ::T.untyped) - PEDANTIC = ::T.let(nil, ::T.untyped) - RECOVER = ::T.let(nil, ::T.untyped) - SAX1 = ::T.let(nil, ::T.untyped) - STRICT = ::T.let(nil, ::T.untyped) - XINCLUDE = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::ParseOptions -end - -class Nokogiri::XML::ProcessingInstruction - def initialize(document, name, content); end -end - -class Nokogiri::XML::ProcessingInstruction -end - -class Nokogiri::XML::Reader - include ::Enumerable - def attribute(_); end - - def attribute_at(_); end - - def attribute_count(); end - - def attribute_nodes(); end - - def attributes(); end - - def attributes?(); end - - def base_uri(); end - - def default?(); end - - def depth(); end - - def each(&blk); end - - def empty_element?(); end - - def encoding(); end - - def errors(); end - - def errors=(errors); end - - def initialize(source, url=T.unsafe(nil), encoding=T.unsafe(nil)); end - - def inner_xml(); end - - def lang(); end - - def local_name(); end - - def name(); end - - def namespace_uri(); end - - def namespaces(); end - - def node_type(); end - - def outer_xml(); end - - def prefix(); end - - def read(); end - - def self_closing?(); end - - def source(); end - - def state(); end - - def value(); end - - def value?(); end - - def xml_version(); end - TYPE_ATTRIBUTE = ::T.let(nil, ::T.untyped) - TYPE_CDATA = ::T.let(nil, ::T.untyped) - TYPE_COMMENT = ::T.let(nil, ::T.untyped) - TYPE_DOCUMENT = ::T.let(nil, ::T.untyped) - TYPE_DOCUMENT_FRAGMENT = ::T.let(nil, ::T.untyped) - TYPE_DOCUMENT_TYPE = ::T.let(nil, ::T.untyped) - TYPE_ELEMENT = ::T.let(nil, ::T.untyped) - TYPE_END_ELEMENT = ::T.let(nil, ::T.untyped) - TYPE_END_ENTITY = ::T.let(nil, ::T.untyped) - TYPE_ENTITY = ::T.let(nil, ::T.untyped) - TYPE_ENTITY_REFERENCE = ::T.let(nil, ::T.untyped) - TYPE_NONE = ::T.let(nil, ::T.untyped) - TYPE_NOTATION = ::T.let(nil, ::T.untyped) - TYPE_PROCESSING_INSTRUCTION = ::T.let(nil, ::T.untyped) - TYPE_SIGNIFICANT_WHITESPACE = ::T.let(nil, ::T.untyped) - TYPE_TEXT = ::T.let(nil, ::T.untyped) - TYPE_WHITESPACE = ::T.let(nil, ::T.untyped) - TYPE_XML_DECLARATION = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::Reader - def self.from_io(*_); end - - def self.from_memory(*_); end -end - -class Nokogiri::XML::RelaxNG -end - -class Nokogiri::XML::RelaxNG -end - -module Nokogiri::XML::SAX -end - -class Nokogiri::XML::SAX::Document - def cdata_block(string); end - - def characters(string); end - - def comment(string); end - - def end_document(); end - - def end_element(name); end - - def end_element_namespace(name, prefix=T.unsafe(nil), uri=T.unsafe(nil)); end - - def error(string); end - - def processing_instruction(name, content); end - - def start_document(); end - - def start_element(name, attrs=T.unsafe(nil)); end - - def start_element_namespace(name, attrs=T.unsafe(nil), prefix=T.unsafe(nil), uri=T.unsafe(nil), ns=T.unsafe(nil)); end - - def warning(string); end - - def xmldecl(version, encoding, standalone); end -end - -class Nokogiri::XML::SAX::Document -end - -class Nokogiri::XML::SAX::Parser - def document(); end - - def document=(document); end - - def encoding(); end - - def encoding=(encoding); end - - def initialize(doc=T.unsafe(nil), encoding=T.unsafe(nil)); end - - def parse(thing, &block); end - - def parse_file(filename); end - - def parse_io(io, encoding=T.unsafe(nil)); end - - def parse_memory(data); end - ENCODINGS = ::T.let(nil, ::T.untyped) -end - -class Nokogiri::XML::SAX::Parser -end - -class Nokogiri::XML::SAX::ParserContext - def column(); end - - def line(); end - - def parse_with(_); end - - def recovery(); end - - def recovery=(recovery); end - - def replace_entities(); end - - def replace_entities=(replace_entities); end -end - -class Nokogiri::XML::SAX::ParserContext - def self.file(_); end - - def self.io(_, _1); end - - def self.memory(_); end - - def self.new(thing, encoding=T.unsafe(nil)); end -end - -class Nokogiri::XML::SAX::PushParser - def <<(chunk, last_chunk=T.unsafe(nil)); end - - def document(); end - - def document=(document); end - - def finish(); end - - def initialize(doc=T.unsafe(nil), file_name=T.unsafe(nil), encoding=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def replace_entities(); end - - def replace_entities=(replace_entities); end - - def write(chunk, last_chunk=T.unsafe(nil)); end -end - -class Nokogiri::XML::SAX::PushParser -end - -module Nokogiri::XML::SAX -end - -class Nokogiri::XML::Schema - def errors(); end - - def errors=(errors); end - - def valid?(thing); end - - def validate(thing); end -end - -class Nokogiri::XML::Schema - def self.from_document(_); end - - def self.new(string_or_io); end - - def self.read_memory(_); end -end - -module Nokogiri::XML::Searchable - def %(*args); end - - def /(*args); end - - def at(*args); end - - def at_css(*args); end - - def at_xpath(*args); end - - def css(*args); end - - def search(*args); end - - def xpath(*args); end - LOOKS_LIKE_XPATH = ::T.let(nil, ::T.untyped) -end - -module Nokogiri::XML::Searchable -end - -class Nokogiri::XML::SyntaxError - def code(); end - - def column(); end - - def domain(); end - - def error?(); end - - def fatal?(); end - - def file(); end - - def int1(); end - - def level(); end - - def line(); end - - def none?(); end - - def str1(); end - - def str2(); end - - def str3(); end - - def warning?(); end -end - -class Nokogiri::XML::SyntaxError -end - -class Nokogiri::XML::Text -end - -class Nokogiri::XML::Text -end - -class Nokogiri::XML::XPath - def document(); end - - def document=(document); end -end - -class Nokogiri::XML::XPath::SyntaxError -end - -class Nokogiri::XML::XPath::SyntaxError -end - -class Nokogiri::XML::XPath -end - -class Nokogiri::XML::XPathContext - def evaluate(*_); end - - def register_namespaces(namespaces); end - - def register_ns(_, _1); end - - def register_variable(_, _1); end -end - -class Nokogiri::XML::XPathContext - def self.new(_); end -end - -module Nokogiri::XML - def self.Reader(string_or_io, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.RelaxNG(string_or_io); end - - def self.Schema(string_or_io); end - - def self.fragment(string); end - - def self.parse(thing, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil), &block); end -end - -module Nokogiri::XSLT -end - -class Nokogiri::XSLT::Stylesheet - def apply_to(document, params=T.unsafe(nil)); end - - def serialize(_); end - - def transform(*_); end -end - -class Nokogiri::XSLT::Stylesheet - def self.parse_stylesheet_doc(_); end -end - -module Nokogiri::XSLT - def self.parse(string, modules=T.unsafe(nil)); end - - def self.quote_params(params); end - - def self.register(_, _1); end -end - -module Nokogiri - def self.HTML(thing, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil), &block); end - - def self.Slop(*args, &block); end - - def self.XML(thing, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil), &block); end - - def self.XSLT(stylesheet, modules=T.unsafe(nil)); end - - def self.install_default_aliases(); end - - def self.jruby?(); end - - def self.make(input=T.unsafe(nil), opts=T.unsafe(nil), &blk); end - - def self.parse(string, url=T.unsafe(nil), encoding=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.uses_libxml?(); end end class Numeric @@ -20052,10 +13335,8 @@ class Numeric end class Object - include ::JSON::Ext::Generator::GeneratorMethods::Object include ::ActiveSupport::Dependencies::Loadable include ::ActiveSupport::Tryable - include ::PP::ObjectMixin include ::Minitest::Expectations include ::Tins::Full include ::ActiveSupport::ToJsonWithActiveSupportEncoder @@ -20065,8 +13346,6 @@ class Object def blank?(); end - def dclone(); end - def duplicable?(); end def html_safe?(); end @@ -20264,1272 +13543,14 @@ class PATH def each(*args, &block); end end -module Parallel - Stop = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Parallel::Break -end - -class Parallel::Break -end - -class Parallel::DeadWorker -end - -class Parallel::DeadWorker -end - -class Parallel::ExceptionWrapper - def exception(); end - - def initialize(exception); end -end - -class Parallel::ExceptionWrapper -end - -class Parallel::JobFactory - def initialize(source, mutex); end - - def next(); end - - def pack(item, index); end - - def size(); end - - def unpack(data); end -end - -class Parallel::JobFactory -end - -class Parallel::Kill -end - -class Parallel::Kill -end - -module Parallel::ProcessorCount - def physical_processor_count(); end - - def processor_count(); end -end - -module Parallel::ProcessorCount -end - -class Parallel::UndumpableException - def initialize(original); end -end - -class Parallel::UndumpableException -end - -class Parallel::UserInterruptHandler - INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped) -end - -class Parallel::UserInterruptHandler - def self.kill(thing); end - - def self.kill_on_ctrl_c(pids, options); end -end - -class Parallel::Worker - def close_pipes(); end - - def initialize(read, write, pid); end - - def pid(); end - - def read(); end - - def stop(); end - - def thread(); end - - def thread=(thread); end - - def work(data); end - - def write(); end -end - -class Parallel::Worker -end - -module Parallel - extend ::Parallel::ProcessorCount - def self.all?(*args, &block); end - - def self.any?(*args, &block); end - - def self.each(array, options=T.unsafe(nil), &block); end - - def self.each_with_index(array, options=T.unsafe(nil), &block); end - - def self.flat_map(*args, &block); end - - def self.in_processes(options=T.unsafe(nil), &block); end - - def self.in_threads(options=T.unsafe(nil)); end - - def self.map(source, options=T.unsafe(nil), &block); end - - def self.map_with_index(array, options=T.unsafe(nil), &block); end - - def self.worker_number(); end - - def self.worker_number=(worker_num); end -end - module ParallelTests - RUBY_BINARY = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) WINDOWS = ::T.let(nil, ::T.untyped) end -class ParallelTests::CLI - def run(argv); end -end - -class ParallelTests::CLI -end - -class ParallelTests::Grouper -end - -class ParallelTests::Grouper - def self.by_scenarios(tests, num_groups, options=T.unsafe(nil)); end - - def self.by_steps(tests, num_groups, options); end - - def self.in_even_groups_by_size(items, num_groups, options=T.unsafe(nil)); end -end - -class ParallelTests::Pids - def add(pid); end - - def all(); end - - def count(); end - - def delete(pid); end - - def file_path(); end - - def initialize(file_path); end - - def mutex(); end -end - -class ParallelTests::Pids -end - -module ParallelTests - def self.bundler_enabled?(); end - - def self.delta(); end - - def self.determine_number_of_processes(count); end - - def self.first_process?(); end - - def self.last_process?(); end - - def self.now(); end - - def self.number_of_running_processes(); end - - def self.pid_file_path(); end - - def self.pids(); end - - def self.stop_all_processes(); end - - def self.wait_for_other_processes_to_finish(); end - - def self.with_pid_file(); end - - def self.with_ruby_binary(command); end -end - ParseError = Racc::ParseError -module Parser - MESSAGES = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module Parser::AST -end - -class Parser::AST::Node - def loc(); end - - def location(); end -end - -class Parser::AST::Node -end - -class Parser::AST::Processor - def on_alias(node); end - - def on_and(node); end - - def on_and_asgn(node); end - - def on_arg(node); end - - def on_arg_expr(node); end - - def on_args(node); end - - def on_argument(node); end - - def on_array(node); end - - def on_array_pattern(node); end - - def on_array_pattern_with_tail(node); end - - def on_back_ref(node); end - - def on_begin(node); end - - def on_block(node); end - - def on_block_pass(node); end - - def on_blockarg(node); end - - def on_blockarg_expr(node); end - - def on_break(node); end - - def on_case(node); end - - def on_case_match(node); end - - def on_casgn(node); end - - def on_class(node); end - - def on_const(node); end - - def on_const_pattern(node); end - - def on_csend(node); end - - def on_cvar(node); end - - def on_cvasgn(node); end - - def on_def(node); end - - def on_def_e(node); end - - def on_defined?(node); end - - def on_defs(node); end - - def on_defs_e(node); end - - def on_dstr(node); end - - def on_dsym(node); end - - def on_eflipflop(node); end - - def on_empty_else(node); end - - def on_ensure(node); end - - def on_erange(node); end - - def on_for(node); end - - def on_gvar(node); end - - def on_gvasgn(node); end - - def on_hash(node); end - - def on_hash_pattern(node); end - - def on_if(node); end - - def on_if_guard(node); end - - def on_iflipflop(node); end - - def on_in_match(node); end - - def on_in_pattern(node); end - - def on_index(node); end - - def on_indexasgn(node); end - - def on_irange(node); end - - def on_ivar(node); end - - def on_ivasgn(node); end - - def on_kwarg(node); end - - def on_kwbegin(node); end - - def on_kwoptarg(node); end - - def on_kwrestarg(node); end - - def on_kwsplat(node); end - - def on_lambda(node); end - - def on_lvar(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_match_alt(node); end - - def on_match_as(node); end - - def on_match_current_line(node); end - - def on_match_rest(node); end - - def on_match_var(node); end - - def on_match_with_lvasgn(node); end - - def on_mlhs(node); end - - def on_module(node); end - - def on_mrasgn(node); end - - def on_next(node); end - - def on_not(node); end - - def on_nth_ref(node); end - - def on_numblock(node); end - - def on_op_asgn(node); end - - def on_optarg(node); end - - def on_or(node); end - - def on_or_asgn(node); end - - def on_pair(node); end - - def on_pin(node); end - - def on_postexe(node); end - - def on_preexe(node); end - - def on_procarg0(node); end - - def on_rasgn(node); end - - def on_redo(node); end - - def on_regexp(node); end - - def on_resbody(node); end - - def on_rescue(node); end - - def on_restarg(node); end - - def on_restarg_expr(node); end - - def on_retry(node); end - - def on_return(node); end - - def on_sclass(node); end - - def on_send(node); end - - def on_shadowarg(node); end - - def on_splat(node); end - - def on_super(node); end - - def on_undef(node); end - - def on_unless_guard(node); end - - def on_until(node); end - - def on_until_post(node); end - - def on_var(node); end - - def on_vasgn(node); end - - def on_when(node); end - - def on_while(node); end - - def on_while_post(node); end - - def on_xstr(node); end - - def on_yield(node); end - - def process_argument_node(node); end - - def process_regular_node(node); end - - def process_var_asgn_node(node); end - - def process_variable_node(node); end -end - -class Parser::AST::Processor -end - -module Parser::AST -end - -class Parser::Base - def builder(); end - - def context(); end - - def current_arg_stack(); end - - def diagnostics(); end - - def initialize(builder=T.unsafe(nil)); end - - def max_numparam_stack(); end - - def parse(source_buffer); end - - def parse_with_comments(source_buffer); end - - def pattern_hash_keys(); end - - def pattern_variables(); end - - def reset(); end - - def source_buffer(); end - - def static_env(); end - - def tokenize(source_buffer, recover=T.unsafe(nil)); end -end - -class Parser::Base - def self.default_parser(); end - - def self.parse(string, file=T.unsafe(nil), line=T.unsafe(nil)); end - - def self.parse_file(filename); end - - def self.parse_file_with_comments(filename); end - - def self.parse_with_comments(string, file=T.unsafe(nil), line=T.unsafe(nil)); end -end - -module Parser::Builders -end - -class Parser::Builders::Default - def __ENCODING__(__ENCODING__t); end - - def __FILE__(__FILE__t); end - - def __LINE__(__LINE__t); end - - def accessible(node); end - - def alias(alias_t, to, from); end - - def arg(name_t); end - - def arg_expr(expr); end - - def args(begin_t, args, end_t, check_args=T.unsafe(nil)); end - - def array(begin_t, elements, end_t); end - - def array_pattern(lbrack_t, elements, rbrack_t); end - - def assign(lhs, eql_t, rhs); end - - def assignable(node); end - - def associate(begin_t, pairs, end_t); end - - def attr_asgn(receiver, dot_t, selector_t); end - - def back_ref(token); end - - def begin(begin_t, body, end_t); end - - def begin_body(compound_stmt, rescue_bodies=T.unsafe(nil), else_t=T.unsafe(nil), else_=T.unsafe(nil), ensure_t=T.unsafe(nil), ensure_=T.unsafe(nil)); end - - def begin_keyword(begin_t, body, end_t); end - - def binary_op(receiver, operator_t, arg); end - - def block(method_call, begin_t, args, body, end_t); end - - def block_pass(amper_t, arg); end - - def blockarg(amper_t, name_t); end - - def blockarg_expr(amper_t, expr); end - - def call_lambda(lambda_t); end - - def call_method(receiver, dot_t, selector_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end - - def call_type_for_dot(dot_t); end - - def case(case_t, expr, when_bodies, else_t, else_body, end_t); end - - def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end - - def character(char_t); end - - def complex(complex_t); end - - def compstmt(statements); end - - def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end - - def condition_mod(if_true, if_false, cond_t, cond); end - - def const(name_t); end - - def const_fetch(scope, t_colon2, name_t); end - - def const_global(t_colon3, name_t); end - - def const_op_assignable(node); end - - def const_pattern(const, ldelim_t, pattern, rdelim_t); end - - def cvar(token); end - - def dedent_string(node, dedent_level); end - - def def_class(class_t, name, lt_t, superclass, body, end_t); end - - def def_endless_method(def_t, name_t, args, assignment_t, body); end - - def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end - - def def_method(def_t, name_t, args, body, end_t); end - - def def_module(module_t, name, body, end_t); end - - def def_sclass(class_t, lshft_t, expr, body, end_t); end - - def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end - - def emit_file_line_as_literals(); end - - def emit_file_line_as_literals=(emit_file_line_as_literals); end - - def false(false_t); end - - def float(float_t); end - - def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end - - def forward_args(begin_t, dots_t, end_t); end - - def forwarded_args(dots_t); end - - def gvar(token); end - - def hash_pattern(lbrace_t, kwargs, rbrace_t); end - - def ident(token); end - - def if_guard(if_t, if_body); end - - def in_match(lhs, in_t, rhs); end - - def in_pattern(in_t, pattern, guard, then_t, body); end - - def index(receiver, lbrack_t, indexes, rbrack_t); end - - def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end - - def integer(integer_t); end - - def ivar(token); end - - def keyword_cmd(type, keyword_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end - - def kwarg(name_t); end - - def kwnilarg(dstar_t, nil_t); end - - def kwoptarg(name_t, value); end - - def kwrestarg(dstar_t, name_t=T.unsafe(nil)); end - - def kwsplat(dstar_t, arg); end - - def logical_op(type, lhs, op_t, rhs); end - - def loop(type, keyword_t, cond, do_t, body, end_t); end - - def loop_mod(type, body, keyword_t, cond); end - - def match_alt(left, pipe_t, right); end - - def match_as(value, assoc_t, as); end - - def match_hash_var(name_t); end - - def match_hash_var_from_str(begin_t, strings, end_t); end - - def match_label(label_type, label); end - - def match_nil_pattern(dstar_t, nil_t); end - - def match_op(receiver, match_t, arg); end - - def match_pair(label_type, label, value); end - - def match_rest(star_t, name_t=T.unsafe(nil)); end - - def match_var(name_t); end - - def match_with_trailing_comma(match, comma_t); end - - def multi_assign(lhs, eql_t, rhs); end - - def multi_lhs(begin_t, items, end_t); end - - def multi_rassign(lhs, assoc_t, rhs); end - - def nil(nil_t); end - - def not_op(not_t, begin_t=T.unsafe(nil), receiver=T.unsafe(nil), end_t=T.unsafe(nil)); end - - def nth_ref(token); end - - def numargs(max_numparam); end - - def objc_kwarg(kwname_t, assoc_t, name_t); end - - def objc_restarg(star_t, name=T.unsafe(nil)); end - - def objc_varargs(pair, rest_of_varargs); end - - def op_assign(lhs, op_t, rhs); end - - def optarg(name_t, eql_t, value); end - - def pair(key, assoc_t, value); end - - def pair_keyword(key_t, value); end - - def pair_list_18(list); end - - def pair_quoted(begin_t, parts, end_t, value); end - - def parser(); end - - def parser=(parser); end - - def pin(pin_t, var); end - - def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end - - def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end - - def procarg0(arg); end - - def range_exclusive(lhs, dot3_t, rhs); end - - def range_inclusive(lhs, dot2_t, rhs); end - - def rassign(lhs, assoc_t, rhs); end - - def rational(rational_t); end - - def regexp_compose(begin_t, parts, end_t, options); end - - def regexp_options(regopt_t); end - - def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end - - def restarg(star_t, name_t=T.unsafe(nil)); end - - def restarg_expr(star_t, expr=T.unsafe(nil)); end - - def self(token); end - - def shadowarg(name_t); end - - def splat(star_t, arg=T.unsafe(nil)); end - - def string(string_t); end - - def string_compose(begin_t, parts, end_t); end - - def string_internal(string_t); end - - def symbol(symbol_t); end - - def symbol_compose(begin_t, parts, end_t); end - - def symbol_internal(symbol_t); end - - def symbols_compose(begin_t, parts, end_t); end - - def ternary(cond, question_t, if_true, colon_t, if_false); end - - def true(true_t); end - - def unary_num(unary_t, numeric); end - - def unary_op(op_t, receiver); end - - def undef_method(undef_t, names); end - - def unless_guard(unless_t, unless_body); end - - def when(when_t, patterns, then_t, body); end - - def word(parts); end - - def words_compose(begin_t, parts, end_t); end - - def xstring_compose(begin_t, parts, end_t); end -end - -class Parser::Builders::Default - def self.emit_arg_inside_procarg0(); end - - def self.emit_arg_inside_procarg0=(emit_arg_inside_procarg0); end - - def self.emit_encoding(); end - - def self.emit_encoding=(emit_encoding); end - - def self.emit_index(); end - - def self.emit_index=(emit_index); end - - def self.emit_lambda(); end - - def self.emit_lambda=(emit_lambda); end - - def self.emit_procarg0(); end - - def self.emit_procarg0=(emit_procarg0); end - - def self.modernize(); end -end - -module Parser::Builders -end - -class Parser::ClobberingError -end - -class Parser::ClobberingError -end - -class Parser::Context - def class_definition_allowed?(); end - - def dynamic_const_definition_allowed?(); end - - def in_block?(); end - - def in_class?(); end - - def in_dynamic_block?(); end - - def in_lambda?(); end - - def indirectly_in_def?(); end - - def module_definition_allowed?(); end - - def pop(); end - - def push(state); end - - def reset(); end - - def stack(); end -end - -class Parser::Context -end - -class Parser::CurrentArgStack - def pop(); end - - def push(value); end - - def reset(); end - - def set(value); end - - def stack(); end - - def top(); end -end - -class Parser::CurrentArgStack -end - Parser::CurrentRuby = Parser::Ruby26 -module Parser::Deprecation - def warn_of_deprecation(); end - - def warned_of_deprecation=(warned_of_deprecation); end -end - -module Parser::Deprecation -end - -class Parser::Diagnostic - def arguments(); end - - def highlights(); end - - def initialize(level, reason, arguments, location, highlights=T.unsafe(nil)); end - - def level(); end - - def location(); end - - def message(); end - - def reason(); end - - def render(); end - LEVELS = ::T.let(nil, ::T.untyped) -end - -class Parser::Diagnostic::Engine - def all_errors_are_fatal(); end - - def all_errors_are_fatal=(all_errors_are_fatal); end - - def consumer(); end - - def consumer=(consumer); end - - def ignore?(diagnostic); end - - def ignore_warnings(); end - - def ignore_warnings=(ignore_warnings); end - - def initialize(consumer=T.unsafe(nil)); end - - def process(diagnostic); end - - def raise?(diagnostic); end -end - -class Parser::Diagnostic::Engine -end - -class Parser::Diagnostic -end - -class Parser::Lexer - def advance(); end - - def arg_or_cmdarg(cmd_state); end - - def cmdarg(); end - - def cmdarg=(cmdarg); end - - def command_start(); end - - def command_start=(command_start); end - - def comments(); end - - def comments=(comments); end - - def cond(); end - - def cond=(cond); end - - def context(); end - - def context=(context); end - - def dedent_level(); end - - def diagnostic(type, reason, arguments=T.unsafe(nil), location=T.unsafe(nil), highlights=T.unsafe(nil)); end - - def diagnostics(); end - - def diagnostics=(diagnostics); end - - def emit(type, value=T.unsafe(nil), s=T.unsafe(nil), e=T.unsafe(nil)); end - - def emit_comment(s=T.unsafe(nil), e=T.unsafe(nil)); end - - def emit_do(do_block=T.unsafe(nil)); end - - def emit_table(table, s=T.unsafe(nil), e=T.unsafe(nil)); end - - def encode_escape(ord); end - - def encoding(); end - - def eof_codepoint?(point); end - - def force_utf32(); end - - def force_utf32=(force_utf32); end - - def in_kwarg(); end - - def in_kwarg=(in_kwarg); end - - def initialize(version); end - - def literal(); end - - def next_state_for_literal(literal); end - - def pop_cmdarg(); end - - def pop_cond(); end - - def pop_literal(); end - - def push_cmdarg(); end - - def push_cond(); end - - def push_literal(*args); end - - def range(s=T.unsafe(nil), e=T.unsafe(nil)); end - - def reset(reset_state=T.unsafe(nil)); end - - def source_buffer(); end - - def source_buffer=(source_buffer); end - - def stack_pop(); end - - def state(); end - - def state=(state); end - - def static_env(); end - - def static_env=(static_env); end - - def tok(s=T.unsafe(nil), e=T.unsafe(nil)); end - - def tokens(); end - - def tokens=(tokens); end - - def version?(*versions); end - ESCAPES = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped) - LEX_STATES = ::T.let(nil, ::T.untyped) - PUNCTUATION = ::T.let(nil, ::T.untyped) - PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped) - REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer::Dedenter - def dedent(string); end - - def initialize(dedent_level); end - - def interrupt(); end - TAB_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer::Dedenter -end - -class Parser::Lexer::Literal - def backslash_delimited?(); end - - def clear_buffer(); end - - def coerce_encoding(string); end - - def dedent_level(); end - - def delimiter?(delimiter); end - - def emit(token, type, s, e); end - - def emit_start_tok(); end - - def end_interp_brace_and_try_closing(); end - - def extend_content(); end - - def extend_space(ts, te); end - - def extend_string(string, ts, te); end - - def flush_string(); end - - def heredoc?(); end - - def heredoc_e(); end - - def infer_indent_level(line); end - - def initialize(lexer, str_type, delimiter, str_s, heredoc_e=T.unsafe(nil), indent=T.unsafe(nil), dedent_body=T.unsafe(nil), label_allowed=T.unsafe(nil)); end - - def interpolate?(); end - - def munge_escape?(character); end - - def nest_and_try_closing(delimiter, ts, te, lookahead=T.unsafe(nil)); end - - def plain_heredoc?(); end - - def regexp?(); end - - def saved_herebody_s(); end - - def saved_herebody_s=(saved_herebody_s); end - - def squiggly_heredoc?(); end - - def start_interp_brace(); end - - def str_s(); end - - def supports_line_continuation_via_slash?(); end - - def type(); end - - def words?(); end - DELIMITERS = ::T.let(nil, ::T.untyped) - TYPES = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer::Literal -end - -class Parser::Lexer::StackState - def active?(); end - - def clear(); end - - def empty?(); end - - def initialize(name); end - - def lexpop(); end - - def pop(); end - - def push(bit); end -end - -class Parser::Lexer::StackState -end - -class Parser::Lexer - def self.lex_en_expr_arg(); end - - def self.lex_en_expr_arg=(lex_en_expr_arg); end - - def self.lex_en_expr_beg(); end - - def self.lex_en_expr_beg=(lex_en_expr_beg); end - - def self.lex_en_expr_cmdarg(); end - - def self.lex_en_expr_cmdarg=(lex_en_expr_cmdarg); end - - def self.lex_en_expr_dot(); end - - def self.lex_en_expr_dot=(lex_en_expr_dot); end - - def self.lex_en_expr_end(); end - - def self.lex_en_expr_end=(lex_en_expr_end); end - - def self.lex_en_expr_endarg(); end - - def self.lex_en_expr_endarg=(lex_en_expr_endarg); end - - def self.lex_en_expr_endfn(); end - - def self.lex_en_expr_endfn=(lex_en_expr_endfn); end - - def self.lex_en_expr_fname(); end - - def self.lex_en_expr_fname=(lex_en_expr_fname); end - - def self.lex_en_expr_labelarg(); end - - def self.lex_en_expr_labelarg=(lex_en_expr_labelarg); end - - def self.lex_en_expr_mid(); end - - def self.lex_en_expr_mid=(lex_en_expr_mid); end - - def self.lex_en_expr_value(); end - - def self.lex_en_expr_value=(lex_en_expr_value); end - - def self.lex_en_expr_variable(); end - - def self.lex_en_expr_variable=(lex_en_expr_variable); end - - def self.lex_en_interp_backslash_delimited(); end - - def self.lex_en_interp_backslash_delimited=(lex_en_interp_backslash_delimited); end - - def self.lex_en_interp_backslash_delimited_words(); end - - def self.lex_en_interp_backslash_delimited_words=(lex_en_interp_backslash_delimited_words); end - - def self.lex_en_interp_string(); end - - def self.lex_en_interp_string=(lex_en_interp_string); end - - def self.lex_en_interp_words(); end - - def self.lex_en_interp_words=(lex_en_interp_words); end - - def self.lex_en_leading_dot(); end - - def self.lex_en_leading_dot=(lex_en_leading_dot); end - - def self.lex_en_line_begin(); end - - def self.lex_en_line_begin=(lex_en_line_begin); end - - def self.lex_en_line_comment(); end - - def self.lex_en_line_comment=(lex_en_line_comment); end - - def self.lex_en_plain_backslash_delimited(); end - - def self.lex_en_plain_backslash_delimited=(lex_en_plain_backslash_delimited); end - - def self.lex_en_plain_backslash_delimited_words(); end - - def self.lex_en_plain_backslash_delimited_words=(lex_en_plain_backslash_delimited_words); end - - def self.lex_en_plain_string(); end - - def self.lex_en_plain_string=(lex_en_plain_string); end - - def self.lex_en_plain_words(); end - - def self.lex_en_plain_words=(lex_en_plain_words); end - - def self.lex_en_regexp_modifiers(); end - - def self.lex_en_regexp_modifiers=(lex_en_regexp_modifiers); end - - def self.lex_error(); end - - def self.lex_error=(lex_error); end - - def self.lex_start(); end - - def self.lex_start=(lex_start); end -end - -class Parser::MaxNumparamStack - def has_numparams?(); end - - def has_ordinary_params!(); end - - def has_ordinary_params?(); end - - def pop(); end - - def push(); end - - def register(numparam); end - - def stack(); end - - def top(); end -end - -class Parser::MaxNumparamStack -end - -module Parser::Messages -end - -module Parser::Messages - def self.compile(reason, arguments); end -end - -module Parser::Meta - NODE_TYPES = ::T.let(nil, ::T.untyped) -end - -module Parser::Meta -end - -class Parser::Rewriter - def assignment?(node); end - - def initialize(*_); end - - def insert_after(range, content); end - - def insert_before(range, content); end - - def remove(range); end - - def replace(range, content); end - - def rewrite(source_buffer, ast); end - - def wrap(range, before, after); end - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) -end - -class Parser::Rewriter - extend ::Parser::Deprecation -end - class Parser::Ruby24 def _reduce_10(val, _values, result); end @@ -23290,611 +15311,6 @@ end class Parser::Ruby26 end -module Parser::Source -end - -class Parser::Source::Buffer - def column_for_position(position); end - - def decompose_position(position); end - - def first_line(); end - - def initialize(name, first_line=T.unsafe(nil), source: T.unsafe(nil)); end - - def last_line(); end - - def line_for_position(position); end - - def line_range(lineno); end - - def name(); end - - def raw_source=(input); end - - def read(); end - - def slice(range); end - - def source(); end - - def source=(input); end - - def source_line(lineno); end - - def source_lines(); end - - def source_range(); end - ENCODING_RE = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Buffer - def self.recognize_encoding(string); end - - def self.reencode_string(input); end -end - -class Parser::Source::Comment - def ==(other); end - - def document?(); end - - def initialize(range); end - - def inline?(); end - - def loc(); end - - def location(); end - - def text(); end - - def type(); end -end - -class Parser::Source::Comment::Associator - def associate(); end - - def associate_locations(); end - - def initialize(ast, comments); end - - def skip_directives(); end - - def skip_directives=(skip_directives); end - MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped) - POSTFIX_TYPES = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Comment::Associator -end - -class Parser::Source::Comment - def self.associate(ast, comments); end - - def self.associate_locations(ast, comments); end -end - -class Parser::Source::Map - def ==(other); end - - def column(); end - - def expression(); end - - def first_line(); end - - def initialize(expression); end - - def last_column(); end - - def last_line(); end - - def line(); end - - def node(); end - - def node=(node); end - - def to_hash(); end - - def update_expression(expression_l); end - - def with(&block); end - - def with_expression(expression_l); end -end - -class Parser::Source::Map::Collection - def begin(); end - - def end(); end - - def initialize(begin_l, end_l, expression_l); end -end - -class Parser::Source::Map::Collection -end - -class Parser::Source::Map::Condition - def begin(); end - - def else(); end - - def end(); end - - def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end - - def keyword(); end -end - -class Parser::Source::Map::Condition -end - -class Parser::Source::Map::Constant - def double_colon(); end - - def initialize(double_colon, name, expression); end - - def name(); end - - def operator(); end - - def update_operator(operator_l); end - - def with_operator(operator_l); end -end - -class Parser::Source::Map::Constant -end - -class Parser::Source::Map::Definition - def end(); end - - def initialize(keyword_l, operator_l, name_l, end_l); end - - def keyword(); end - - def name(); end - - def operator(); end -end - -class Parser::Source::Map::Definition -end - -class Parser::Source::Map::EndlessDefinition - def assignment(); end - - def initialize(keyword_l, operator_l, name_l, assignment_l, body_l); end - - def keyword(); end - - def name(); end - - def operator(); end -end - -class Parser::Source::Map::EndlessDefinition -end - -class Parser::Source::Map::For - def begin(); end - - def end(); end - - def in(); end - - def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end - - def keyword(); end -end - -class Parser::Source::Map::For -end - -class Parser::Source::Map::Heredoc - def heredoc_body(); end - - def heredoc_end(); end - - def initialize(begin_l, body_l, end_l); end -end - -class Parser::Source::Map::Heredoc -end - -class Parser::Source::Map::Index - def begin(); end - - def end(); end - - def initialize(begin_l, end_l, expression_l); end - - def operator(); end - - def update_operator(operator_l); end - - def with_operator(operator_l); end -end - -class Parser::Source::Map::Index -end - -class Parser::Source::Map::Keyword - def begin(); end - - def end(); end - - def initialize(keyword_l, begin_l, end_l, expression_l); end - - def keyword(); end -end - -class Parser::Source::Map::Keyword -end - -class Parser::Source::Map::ObjcKwarg - def argument(); end - - def initialize(keyword_l, operator_l, argument_l, expression_l); end - - def keyword(); end - - def operator(); end -end - -class Parser::Source::Map::ObjcKwarg -end - -class Parser::Source::Map::Operator - def initialize(operator, expression); end - - def operator(); end -end - -class Parser::Source::Map::Operator -end - -class Parser::Source::Map::RescueBody - def assoc(); end - - def begin(); end - - def initialize(keyword_l, assoc_l, begin_l, expression_l); end - - def keyword(); end -end - -class Parser::Source::Map::RescueBody -end - -class Parser::Source::Map::Send - def begin(); end - - def dot(); end - - def end(); end - - def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end - - def operator(); end - - def selector(); end - - def update_operator(operator_l); end - - def with_operator(operator_l); end -end - -class Parser::Source::Map::Send -end - -class Parser::Source::Map::Ternary - def colon(); end - - def initialize(question_l, colon_l, expression_l); end - - def question(); end -end - -class Parser::Source::Map::Ternary -end - -class Parser::Source::Map::Variable - def initialize(name_l, expression_l=T.unsafe(nil)); end - - def name(); end - - def operator(); end - - def update_operator(operator_l); end - - def with_operator(operator_l); end -end - -class Parser::Source::Map::Variable -end - -class Parser::Source::Map -end - -class Parser::Source::Range - include ::Comparable - def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end - - def begin(); end - - def begin_pos(); end - - def column(); end - - def column_range(); end - - def contained?(other); end - - def contains?(other); end - - def crossing?(other); end - - def disjoint?(other); end - - def empty?(); end - - def end(); end - - def end_pos(); end - - def first_line(); end - - def initialize(source_buffer, begin_pos, end_pos); end - - def intersect(other); end - - def is?(*what); end - - def join(other); end - - def last_column(); end - - def last_line(); end - - def length(); end - - def line(); end - - def overlaps?(other); end - - def resize(new_size); end - - def size(); end - - def source(); end - - def source_buffer(); end - - def source_line(); end - - def to_a(); end - - def to_range(); end - - def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end -end - -class Parser::Source::Range -end - -class Parser::Source::Rewriter - def diagnostics(); end - - def initialize(source_buffer); end - - def insert_after(range, content); end - - def insert_after_multi(range, content); end - - def insert_before(range, content); end - - def insert_before_multi(range, content); end - - def process(); end - - def remove(range); end - - def replace(range, content); end - - def source_buffer(); end - - def transaction(); end - - def wrap(range, before, after); end - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Rewriter::Action - include ::Comparable - def allow_multiple_insertions(); end - - def allow_multiple_insertions?(); end - - def initialize(range, replacement=T.unsafe(nil), allow_multiple_insertions=T.unsafe(nil), order=T.unsafe(nil)); end - - def order(); end - - def range(); end - - def replacement(); end -end - -class Parser::Source::Rewriter::Action -end - -class Parser::Source::Rewriter - extend ::Parser::Deprecation -end - -class Parser::Source::TreeRewriter - def action_root(); end - - def diagnostics(); end - - def empty?(); end - - def in_transaction?(); end - - def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end - - def insert_after(range, content); end - - def insert_after_multi(range, text); end - - def insert_before(range, content); end - - def insert_before_multi(range, text); end - - def merge(with); end - - def merge!(with); end - - def process(); end - - def remove(range); end - - def replace(range, content); end - - def source_buffer(); end - - def transaction(); end - - def wrap(range, insert_before, insert_after); end - ACTIONS = ::T.let(nil, ::T.untyped) - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) - POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::TreeRewriter::Action - def analyse_hierarchy(action); end - - def bsearch_child_index(from=T.unsafe(nil)); end - - def call_enforcer_for_merge(action); end - - def check_fusible(action, *fusible); end - - def children(); end - - def combine(action); end - - def combine_children(more_children); end - - def do_combine(action); end - - def empty?(); end - - def fuse_deletions(action, fusible, other_sibblings); end - - def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end - - def insert_after(); end - - def insert_before(); end - - def insertion?(); end - - def merge(action); end - - def ordered_replacements(); end - - def place_in_hierarchy(action); end - - def range(); end - - def replacement(); end - - def swallow(children); end - - def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end -end - -class Parser::Source::TreeRewriter::Action -end - -class Parser::Source::TreeRewriter - extend ::Parser::Deprecation -end - -module Parser::Source -end - -class Parser::StaticEnvironment - def declare(name); end - - def declare_forward_args(); end - - def declared?(name); end - - def declared_forward_args?(); end - - def extend_dynamic(); end - - def extend_static(); end - - def reset(); end - - def unextend(); end - FORWARD_ARGS = ::T.let(nil, ::T.untyped) -end - -class Parser::StaticEnvironment -end - -class Parser::SyntaxError - def diagnostic(); end - - def initialize(diagnostic); end -end - -class Parser::SyntaxError -end - -class Parser::TreeRewriter - def assignment?(node); end - - def insert_after(range, content); end - - def insert_before(range, content); end - - def remove(range); end - - def replace(range, content); end - - def rewrite(source_buffer, ast, **policy); end - - def wrap(range, before, after); end -end - -class Parser::TreeRewriter -end - -class Parser::VariablesStack - def declare(name); end - - def declared?(name); end - - def pop(); end - - def push(); end - - def reset(); end -end - -class Parser::VariablesStack -end - -module Parser -end - class Pathname include ::MachOShim def fnmatch?(*_); end @@ -23904,154 +15320,6 @@ class Pathname def make_symlink(_); end end -module Plist - VERSION = ::T.let(nil, ::T.untyped) -end - -module Plist::Emit - def save_plist(filename, options=T.unsafe(nil)); end - - def to_plist(envelope=T.unsafe(nil), options=T.unsafe(nil)); end - DEFAULT_INDENT = ::T.let(nil, ::T.untyped) -end - -module Plist::Emit - def self.comment(content); end - - def self.dump(obj, envelope=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.element_type(item); end - - def self.plist_node(element, options=T.unsafe(nil)); end - - def self.save_plist(obj, filename, options=T.unsafe(nil)); end - - def self.tag(type, contents=T.unsafe(nil), options=T.unsafe(nil), &block); end - - def self.wrap(contents); end -end - -class Plist::Listener - def open(); end - - def open=(open); end - - def result(); end - - def result=(result); end - - def tag_end(name); end - - def tag_start(name, attributes); end - - def text(contents); end -end - -class Plist::Listener -end - -class Plist::PArray -end - -class Plist::PArray -end - -class Plist::PData -end - -class Plist::PData -end - -class Plist::PDate -end - -class Plist::PDate -end - -class Plist::PDict -end - -class Plist::PDict -end - -class Plist::PFalse -end - -class Plist::PFalse -end - -class Plist::PInteger -end - -class Plist::PInteger -end - -class Plist::PKey -end - -class Plist::PKey -end - -class Plist::PList -end - -class Plist::PList -end - -class Plist::PReal -end - -class Plist::PReal -end - -class Plist::PString -end - -class Plist::PString -end - -class Plist::PTag - def children(); end - - def children=(children); end - - def text(); end - - def text=(text); end - - def to_ruby(); end -end - -class Plist::PTag - def self.inherited(sub_class); end - - def self.mappings(); end -end - -class Plist::PTrue -end - -class Plist::PTrue -end - -class Plist::StreamParser - def initialize(plist_data_or_file, listener); end - - def parse(); end - COMMENT_END = ::T.let(nil, ::T.untyped) - COMMENT_START = ::T.let(nil, ::T.untyped) - DOCTYPE_PATTERN = ::T.let(nil, ::T.untyped) - TEXT = ::T.let(nil, ::T.untyped) - XMLDECL_PATTERN = ::T.let(nil, ::T.untyped) -end - -class Plist::StreamParser -end - -module Plist - def self.parse_xml(filename_or_xml); end -end - class Proc include ::MethodSource::SourceLocation::ProcExtensions include ::MethodSource::MethodExtensions @@ -24062,578 +15330,6 @@ class Proc def clone(); end end -class ProgressBar -end - -class ProgressBar::Base - def autofinish(); end - - def autofinish=(autofinish); end - - def autostart(); end - - def autostart=(autostart); end - - def bar(); end - - def bar=(bar); end - - def clear(*args, &block); end - - def decrement(); end - - def finish(); end - - def finished(); end - - def finished=(finished); end - - def finished?(); end - - def format(other); end - - def format=(other); end - - def increment(); end - - def initialize(options=T.unsafe(nil)); end - - def log(*args, &block); end - - def output(); end - - def output=(output); end - - def pause(); end - - def paused?(); end - - def percentage(); end - - def percentage=(percentage); end - - def progress(*args, &block); end - - def progress=(new_progress); end - - def progress_mark=(mark); end - - def progressable(); end - - def progressable=(progressable); end - - def rate(); end - - def rate=(rate); end - - def refresh(*args, &block); end - - def remainder_mark=(mark); end - - def reset(); end - - def resume(); end - - def start(options=T.unsafe(nil)); end - - def started?(); end - - def stop(); end - - def stopped?(); end - - def time(); end - - def time=(time); end - - def timer(); end - - def timer=(timer); end - - def title(); end - - def title=(title); end - - def title_comp(); end - - def title_comp=(title_comp); end - - def to_h(); end - - def to_s(new_format=T.unsafe(nil)); end - - def total(*args, &block); end - - def total=(new_total); end - - def update_progress(*args); end -end - -class ProgressBar::Base - extend ::Forwardable -end - -module ProgressBar::Calculators -end - -class ProgressBar::Calculators::Length - def calculate_length(); end - - def current_length(); end - - def current_length=(current_length); end - - def initialize(options=T.unsafe(nil)); end - - def length(); end - - def length_changed?(); end - - def length_override(); end - - def length_override=(other); end - - def output(); end - - def output=(output); end - - def reset_length(); end -end - -class ProgressBar::Calculators::Length -end - -class ProgressBar::Calculators::RunningAverage -end - -class ProgressBar::Calculators::RunningAverage - def self.calculate(current_average, new_value_to_average, smoothing_factor); end -end - -module ProgressBar::Calculators -end - -module ProgressBar::Components -end - -class ProgressBar::Components::Bar - def initialize(options=T.unsafe(nil)); end - - def length(); end - - def length=(length); end - - def progress(); end - - def progress=(progress); end - - def progress_mark(); end - - def progress_mark=(progress_mark); end - - def remainder_mark(); end - - def remainder_mark=(remainder_mark); end - - def to_s(options=T.unsafe(nil)); end - - def upa_steps(); end - - def upa_steps=(upa_steps); end - DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped) - DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped) - DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Components::Bar -end - -class ProgressBar::Components::Percentage - def initialize(options=T.unsafe(nil)); end - - def progress(); end - - def progress=(progress); end -end - -class ProgressBar::Components::Percentage -end - -class ProgressBar::Components::Rate - def initialize(options=T.unsafe(nil)); end - - def progress(); end - - def progress=(progress); end - - def rate_scale(); end - - def rate_scale=(rate_scale); end - - def started_at(); end - - def started_at=(started_at); end - - def stopped_at(); end - - def stopped_at=(stopped_at); end - - def timer(); end - - def timer=(timer); end -end - -class ProgressBar::Components::Rate -end - -class ProgressBar::Components::Time - def elapsed_with_label(); end - - def estimated_with_friendly_oob(); end - - def estimated_with_label(); end - - def estimated_with_no_oob(); end - - def estimated_with_unknown_oob(); end - - def initialize(options=T.unsafe(nil)); end - - def out_of_bounds_time_format(); end - - def out_of_bounds_time_format=(format); end - - def progress(); end - - def progress=(progress); end - - def timer(); end - - def timer=(timer); end - ELAPSED_LABEL = ::T.let(nil, ::T.untyped) - ESTIMATED_LABEL = ::T.let(nil, ::T.untyped) - NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped) - OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped) - OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped) - OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped) - OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped) - TIME_FORMAT = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Components::Time -end - -class ProgressBar::Components::Title - def initialize(options=T.unsafe(nil)); end - - def title(); end - - def title=(title); end - DEFAULT_TITLE = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Components::Title -end - -module ProgressBar::Components -end - -module ProgressBar::Format -end - -class ProgressBar::Format::Formatter -end - -class ProgressBar::Format::Formatter - def self.process(format_string, max_length, bar); end -end - -class ProgressBar::Format::Molecule - def bar_molecule?(); end - - def full_key(); end - - def initialize(letter); end - - def key(); end - - def key=(key); end - - def lookup_value(environment, length=T.unsafe(nil)); end - - def method_name(); end - - def method_name=(method_name); end - - def non_bar_molecule?(); end - BAR_MOLECULES = ::T.let(nil, ::T.untyped) - MOLECULES = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Format::Molecule -end - -class ProgressBar::Format::String - def bar_molecule_placeholder_length(); end - - def bar_molecules(); end - - def displayable_length(); end - - def molecules(); end - - def non_bar_molecules(); end - ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped) - MOLECULE_PATTERN = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Format::String -end - -module ProgressBar::Format -end - -class ProgressBar::InvalidProgressError -end - -class ProgressBar::InvalidProgressError -end - -class ProgressBar::Output - def bar(); end - - def bar=(bar); end - - def clear_string(); end - - def initialize(options=T.unsafe(nil)); end - - def length(); end - - def length_calculator(); end - - def length_calculator=(length_calculator); end - - def log(string); end - - def refresh(options=T.unsafe(nil)); end - - def stream(); end - - def stream=(stream); end - - def throttle(); end - - def throttle=(throttle); end - - def with_refresh(); end - DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Output - def self.detect(options=T.unsafe(nil)); end -end - -module ProgressBar::Outputs -end - -class ProgressBar::Outputs::NonTty - def bar_update_string(); end - - def clear(); end - - def default_format(); end - - def eol(); end - - def last_update_length(); end - - def last_update_length=(last_update_length); end - - def refresh_with_format_change(*_); end - - def resolve_format(*_); end - DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Outputs::NonTty -end - -class ProgressBar::Outputs::Tty - def bar_update_string(); end - - def clear(); end - - def default_format(); end - - def eol(); end - - def refresh_with_format_change(); end - - def resolve_format(other_format); end - DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Outputs::Tty -end - -module ProgressBar::Outputs -end - -class ProgressBar::Progress - def absolute(); end - - def decrement(); end - - def finish(); end - - def finished?(); end - - def increment(); end - - def initialize(options=T.unsafe(nil)); end - - def none?(); end - - def percentage_completed(); end - - def percentage_completed_with_precision(); end - - def progress(); end - - def progress=(new_progress); end - - def reset(); end - - def running_average(); end - - def running_average=(running_average); end - - def smoothing(); end - - def smoothing=(smoothing); end - - def start(options=T.unsafe(nil)); end - - def starting_position(); end - - def starting_position=(starting_position); end - - def total(); end - - def total=(new_total); end - - def total_with_unknown_indicator(); end - - def unknown?(); end - DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped) - DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped) - DEFAULT_TOTAL = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Progress -end - -module ProgressBar::Refinements -end - -module ProgressBar::Refinements::Enumerator -end - -module ProgressBar::Refinements::Enumerator -end - -module ProgressBar::Refinements -end - -class ProgressBar::Throttle - def choke(options=T.unsafe(nil)); end - - def initialize(options=T.unsafe(nil)); end - - def rate(); end - - def rate=(rate); end - - def started_at(); end - - def started_at=(started_at); end - - def stopped_at(); end - - def stopped_at=(stopped_at); end - - def timer(); end - - def timer=(timer); end -end - -class ProgressBar::Throttle -end - -class ProgressBar::Time - def initialize(time=T.unsafe(nil)); end - - def now(); end - - def time(); end - - def time=(time); end - - def unmocked_time_method(); end - TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Time -end - -class ProgressBar::Timer - def divide_seconds(seconds); end - - def elapsed_seconds(); end - - def elapsed_whole_seconds(); end - - def initialize(options=T.unsafe(nil)); end - - def pause(); end - - def reset(); end - - def reset?(); end - - def restart(); end - - def resume(); end - - def start(); end - - def started?(); end - - def started_at(); end - - def started_at=(started_at); end - - def stop(); end - - def stopped?(); end - - def stopped_at(); end - - def stopped_at=(stopped_at); end - - def time(); end - - def time=(time); end -end - -class ProgressBar::Timer -end - -class ProgressBar - def self.create(*args); end -end - class Pry def add_sticky_local(name, &block); end @@ -28009,113 +18705,6 @@ end class RDiscount end -class REXML::AttlistDecl - def initialize(source); end -end - -class REXML::Attribute - def initialize(first, second=T.unsafe(nil), parent=T.unsafe(nil)); end -end - -class REXML::Attributes - def initialize(element); end -end - -class REXML::CData - def initialize(first, whitespace=T.unsafe(nil), parent=T.unsafe(nil)); end -end - -class REXML::Child - def initialize(parent=T.unsafe(nil)); end -end - -class REXML::Comment - def initialize(first, second=T.unsafe(nil)); end -end - -class REXML::Declaration - def initialize(src); end -end - -class REXML::DocType - def initialize(first, parent=T.unsafe(nil)); end -end - -class REXML::Document - def initialize(source=T.unsafe(nil), context=T.unsafe(nil)); end -end - -class REXML::Element - def initialize(arg=T.unsafe(nil), parent=T.unsafe(nil), context=T.unsafe(nil)); end -end - -class REXML::Elements - def initialize(parent); end -end - -class REXML::Entity - def initialize(stream, value=T.unsafe(nil), parent=T.unsafe(nil), reference=T.unsafe(nil)); end -end - -class REXML::ExternalEntity - def initialize(src); end -end - -class REXML::Formatters::Default - def initialize(ie_hack=T.unsafe(nil)); end -end - -class REXML::Formatters::Pretty - def initialize(indentation=T.unsafe(nil), ie_hack=T.unsafe(nil)); end -end - -class REXML::IOSource - def initialize(arg, block_size=T.unsafe(nil), encoding=T.unsafe(nil)); end -end - -class REXML::Instruction - def initialize(target, content=T.unsafe(nil)); end -end - -class REXML::NotationDecl - def initialize(name, middle, pub, sys); end -end - -class REXML::Output - def initialize(real_IO, encd=T.unsafe(nil)); end -end - -class REXML::ParseException - def initialize(message, source=T.unsafe(nil), parser=T.unsafe(nil), exception=T.unsafe(nil)); end -end - -class REXML::Parsers::BaseParser - def initialize(source); end - QNAME = ::T.let(nil, ::T.untyped) - QNAME_STR = ::T.let(nil, ::T.untyped) -end - -class REXML::Parsers::StreamParser - def initialize(source, listener); end -end - -class REXML::Parsers::TreeParser - def initialize(source, build_context=T.unsafe(nil)); end -end - -class REXML::Parsers::XPathParser - LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped) - PREFIX_WILDCARD = ::T.let(nil, ::T.untyped) -end - -class REXML::Source - def initialize(arg, encoding=T.unsafe(nil)); end -end - -class REXML::Text - def initialize(arg, respect_whitespace=T.unsafe(nil), parent=T.unsafe(nil), raw=T.unsafe(nil), entity_filter=T.unsafe(nil), illegal=T.unsafe(nil)); end -end - class REXML::UndefinedNamespaceException def initialize(prefix, source, parser); end end @@ -28124,560 +18713,33 @@ class REXML::Validation::ValidationException def initialize(msg); end end -class REXML::XMLDecl - def initialize(version=T.unsafe(nil), encoding=T.unsafe(nil), standalone=T.unsafe(nil)); end -end - class REXML::XPath def self.match(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end end -class REXML::XPathNode - def context(); end - - def initialize(node, context=T.unsafe(nil)); end - - def position(); end - - def raw_node(); end -end - -class REXML::XPathNode -end - class REXML::XPathParser - def initialize(strict: T.unsafe(nil)); end DEBUG = ::T.let(nil, ::T.untyped) end -module RSpec - MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped) -end - -class RSpec::CallerFilter - ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped) - IGNORE_REGEX = ::T.let(nil, ::T.untyped) - LIB_REGEX = ::T.let(nil, ::T.untyped) - RSPEC_LIBS = ::T.let(nil, ::T.untyped) -end - -class RSpec::CallerFilter - def self.first_non_rspec_line(skip_frames=T.unsafe(nil), increment=T.unsafe(nil)); end -end - -module RSpec::Core -end - -class RSpec::Core::AnonymousExampleGroup -end - -class RSpec::Core::AnonymousExampleGroup -end - -class RSpec::Core::BacktraceFormatter - def backtrace_line(line); end - - def exclude?(line); end - - def exclusion_patterns(); end - - def exclusion_patterns=(exclusion_patterns); end - - def filter_gem(gem_name); end - - def format_backtrace(backtrace, options=T.unsafe(nil)); end - - def full_backtrace=(full_backtrace); end - - def full_backtrace?(); end - - def inclusion_patterns(); end - - def inclusion_patterns=(inclusion_patterns); end -end - -class RSpec::Core::BacktraceFormatter -end - -module RSpec::Core::Bisect -end - -class RSpec::Core::Bisect::BisectFailedError -end - -class RSpec::Core::Bisect::BisectFailedError - def self.for_failed_spec_run(spec_output); end -end - -class RSpec::Core::Bisect::Channel - def close(); end - - def receive(); end - - def send(message); end -end - -class RSpec::Core::Bisect::Channel -end - -class RSpec::Core::Bisect::ExampleSetDescriptor - def all_example_ids(); end - - def all_example_ids=(_); end - - def failed_example_ids(); end - - def failed_example_ids=(_); end -end - -class RSpec::Core::Bisect::ExampleSetDescriptor - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Bisect::Notifier - def initialize(formatter); end - - def publish(event, *args); end -end - -class RSpec::Core::Bisect::Notifier -end - -module RSpec::Core::Bisect -end - -class RSpec::Core::Configuration - include ::RSpec::Core::Hooks - include ::RSpec::Core::Configuration::Readers - def add_formatter(formatter, output=T.unsafe(nil)); end - - def add_setting(name, opts=T.unsafe(nil)); end - - def after(scope=T.unsafe(nil), *meta, &block); end - - def alias_example_group_to(new_name, *args); end - - def alias_example_to(name, *args); end - - def alias_it_behaves_like_to(new_name, report_label=T.unsafe(nil)); end - - def alias_it_should_behave_like_to(new_name, report_label=T.unsafe(nil)); end - - def append_after(scope=T.unsafe(nil), *meta, &block); end - - def append_before(scope=T.unsafe(nil), *meta, &block); end - - def apply_derived_metadata_to(metadata); end - - def around(scope=T.unsafe(nil), *meta, &block); end - - def backtrace_exclusion_patterns(); end - - def backtrace_exclusion_patterns=(patterns); end - - def backtrace_formatter(); end - - def backtrace_inclusion_patterns(); end - - def backtrace_inclusion_patterns=(patterns); end - - def before(scope=T.unsafe(nil), *meta, &block); end - - def bisect_runner(); end - - def bisect_runner=(value); end - - def bisect_runner_class(); end - - def color(); end - - def color=(color); end - - def color_enabled?(output=T.unsafe(nil)); end - - def color_mode(); end - - def color_mode=(color_mode); end - - def configure_example(example, example_hooks); end - - def configure_expectation_framework(); end - - def configure_group(group); end - - def configure_mock_framework(); end - - def default_color=(default_color); end - - def default_color?(); end - - def default_formatter(); end - - def default_formatter=(value); end - - def default_path=(path); end - - def default_path?(); end - - def define_derived_metadata(*filters, &block); end - - def deprecation_stream=(value); end - - def detail_color=(detail_color); end - - def detail_color?(); end - - def disable_monkey_patching(); end - - def disable_monkey_patching!(); end - - def disable_monkey_patching=(disable_monkey_patching); end - - def drb=(drb); end - - def drb?(); end - - def drb_port=(drb_port); end - - def drb_port?(); end - - def dry_run=(dry_run); end - - def dry_run?(); end - - def error_stream=(error_stream); end - - def error_stream?(); end - - def example_status_persistence_file_path=(value); end - - def exclude_pattern=(value); end - - def exclusion_filter(); end - - def exclusion_filter=(filter); end - - def expect_with(*frameworks); end - - def expectation_framework=(framework); end - - def expectation_frameworks(); end - - def expose_current_running_example_as(method_name); end - - def expose_dsl_globally=(value); end - - def expose_dsl_globally?(); end - - def extend(mod, *filters); end - - def fail_fast=(value); end - - def fail_if_no_examples=(fail_if_no_examples); end - - def fail_if_no_examples?(); end - - def failure_color=(failure_color); end - - def failure_color?(); end - - def failure_exit_code=(failure_exit_code); end - - def failure_exit_code?(); end - - def files_or_directories_to_run=(*files); end - - def files_to_run(); end - - def files_to_run=(files_to_run); end - - def filter(); end - - def filter=(filter); end - - def filter_gems_from_backtrace(*gem_names); end - - def filter_manager(); end - - def filter_manager=(filter_manager); end - - def filter_run(*args); end - - def filter_run_excluding(*args); end - - def filter_run_including(*args); end - - def filter_run_when_matching(*args); end - - def fixed_color=(fixed_color); end - - def fixed_color?(); end - - def force(hash); end - - def format_docstrings(&block); end - - def format_docstrings_block(); end - - def formatter=(formatter, output=T.unsafe(nil)); end - - def formatter_loader(); end - - def formatters(); end - - def full_backtrace=(true_or_false); end - - def full_backtrace?(); end - - def full_description(); end - - def full_description=(description); end - - def in_project_source_dir_regex(); end - - def include(mod, *filters); end - - def include_context(shared_group_name, *filters); end - - def inclusion_filter(); end - - def inclusion_filter=(filter); end - - def last_run_statuses(); end - - def libs=(libs); end - - def load_spec_files(); end - - def loaded_spec_files(); end - - def max_displayed_failure_line_count=(max_displayed_failure_line_count); end - - def max_displayed_failure_line_count?(); end - - def mock_framework(); end - - def mock_framework=(framework); end - - def mock_with(framework); end - - def on_example_group_definition(&block); end - - def on_example_group_definition_callbacks(); end - - def only_failures?(); end - - def only_failures_but_not_configured?(); end - - def order=(*args, &block); end - - def ordering_manager(); end - - def ordering_registry(*args, &block); end - - def output_stream=(value); end - - def pattern=(value); end - - def pending_color=(pending_color); end - - def pending_color?(); end - - def prepend(mod, *filters); end - - def prepend_after(scope=T.unsafe(nil), *meta, &block); end - - def prepend_before(scope=T.unsafe(nil), *meta, &block); end - - def profile_examples=(profile_examples); end - - def profile_examples?(); end - - def project_source_dirs=(project_source_dirs); end - - def project_source_dirs?(); end - - def raise_errors_for_deprecations!(); end - - def raise_on_warning=(value); end - - def register_ordering(*args, &block); end - - def reporter(); end - - def requires=(paths); end - - def reset(); end - - def reset_filters(); end - - def reset_reporter(); end - - def run_all_when_everything_filtered=(run_all_when_everything_filtered); end - - def run_all_when_everything_filtered?(); end - - def seed(*args, &block); end - - def seed=(*args, &block); end - - def seed_used?(*args, &block); end - - def shared_context_metadata_behavior=(value); end - - def silence_filter_announcements=(silence_filter_announcements); end - - def silence_filter_announcements?(); end - - def spec_files_with_failures(); end - - def start_time=(start_time); end - - def start_time?(); end - - def static_config_filter_manager(); end - - def static_config_filter_manager=(static_config_filter_manager); end - - def success_color=(success_color); end - - def success_color?(); end - - def threadsafe=(threadsafe); end - - def threadsafe?(); end - - def treat_symbols_as_metadata_keys_with_true_values=(_value); end - - def tty=(tty); end - - def tty?(); end - - def warnings=(value); end - - def warnings?(); end - - def when_first_matching_example_defined(*filters); end - - def with_suite_hooks(); end - - def world(); end - - def world=(world); end - DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped) - FAILED_STATUS = ::T.let(nil, ::T.untyped) - MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped) - PASSED_STATUS = ::T.let(nil, ::T.untyped) - PENDING_STATUS = ::T.let(nil, ::T.untyped) - RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) - UNKNOWN_STATUS = ::T.let(nil, ::T.untyped) - VALID_STATUSES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Configuration::DeprecationReporterBuffer - def deprecation(*args); end - - def play_onto(reporter); end -end - -class RSpec::Core::Configuration::DeprecationReporterBuffer -end - -module RSpec::Core::Configuration::ExposeCurrentExample -end - -module RSpec::Core::Configuration::ExposeCurrentExample -end - -class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError -end - -class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError -end - module RSpec::Core::Configuration::Readers def clear_lets_on_failure(); end - def default_color(); end - - def default_path(); end - def default_retry_count(); end def default_sleep_interval(); end - def deprecation_stream(); end - - def detail_color(); end - def display_try_failure_messages(); end - def drb(); end - - def drb_port(); end - - def dry_run(); end - - def error_stream(); end - - def example_status_persistence_file_path(); end - def exceptions_to_hard_fail(); end def exceptions_to_retry(); end - def exclude_pattern(); end - def exponential_backoff(); end - def fail_fast(); end - - def fail_if_no_examples(); end - - def failure_color(); end - - def failure_exit_code(); end - - def fixed_color(); end - - def libs(); end - - def max_displayed_failure_line_count(); end - - def only_failures(); end - - def output_stream(); end - - def pattern(); end - - def pending_color(); end - - def profile_examples(); end - - def project_source_dirs(); end - - def requires(); end - def retry_callback(); end def retry_count_condition(); end - def run_all_when_everything_filtered(); end - - def shared_context_metadata_behavior(); end - - def silence_filter_announcements(); end - - def start_time(); end - - def success_color(); end - - def threadsafe(); end - - def tty(); end - def verbose_retry(); end def wait_delay(); end @@ -28685,304 +18747,21 @@ module RSpec::Core::Configuration::Readers def wait_timeout(); end end -module RSpec::Core::Configuration::Readers -end - -class RSpec::Core::Configuration - def self.add_read_only_setting(name, opts=T.unsafe(nil)); end - - def self.add_setting(name, opts=T.unsafe(nil)); end - - def self.define_aliases(name, alias_name); end - - def self.define_predicate_for(*names); end - - def self.define_reader(name); end - - def self.delegate_to_ordering_manager(*methods); end -end - -class RSpec::Core::ConfigurationOptions - def args(); end - - def configure(config); end - - def configure_filter_manager(filter_manager); end - - def initialize(args); end - - def options(); end - OPTIONS_ORDER = ::T.let(nil, ::T.untyped) - UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped) - UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::ConfigurationOptions -end - -module RSpec::Core::DSL -end - -module RSpec::Core::DSL - def self.change_global_dsl(&changes); end - - def self.example_group_aliases(); end - - def self.expose_example_group_alias(name); end - - def self.expose_example_group_alias_globally(method_name); end - - def self.expose_globally!(); end - - def self.exposed_globally?(); end - - def self.remove_globally!(); end - - def self.top_level(); end - - def self.top_level=(top_level); end -end - -class RSpec::Core::DeprecationError -end - -class RSpec::Core::DeprecationError -end - -class RSpec::Core::DidYouMean - def call(); end - - def initialize(relative_file_name); end - - def relative_file_name(); end -end - -class RSpec::Core::DidYouMean -end - class RSpec::Core::Example def attempts(); end def attempts=(attempts); end def clear_exception(); end - - def clock(); end - - def clock=(clock); end - - def description(); end - - def display_exception(); end - - def display_exception=(ex); end - - def duplicate_with(metadata_overrides=T.unsafe(nil)); end - - def example_group(); end - - def example_group_instance(); end - - def exception(); end - - def execution_result(); end - - def fail_with_exception(reporter, exception); end - - def file_path(); end - - def full_description(); end - - def id(); end - - def initialize(example_group_class, description, user_metadata, example_block=T.unsafe(nil)); end - - def inspect_output(); end - - def instance_exec(*args, &block); end - - def location(); end - - def location_rerun_argument(); end - - def metadata(); end - - def pending(); end - - def pending?(); end - - def reporter(); end - - def rerun_argument(); end - - def run(example_group_instance, reporter); end - - def set_aggregate_failures_exception(exception); end - - def set_exception(exception); end - - def skip(); end - - def skip_with_exception(reporter, exception); end - - def skipped?(); end - - def update_inherited_metadata(updates); end -end - -RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - -class RSpec::Core::Example::ExecutionResult - include ::RSpec::Core::HashImitatable - def ensure_timing_set(clock); end - - def example_skipped?(); end - - def exception(); end - - def exception=(exception); end - - def finished_at(); end - - def finished_at=(finished_at); end - - def pending_exception(); end - - def pending_exception=(pending_exception); end - - def pending_fixed(); end - - def pending_fixed=(pending_fixed); end - - def pending_fixed?(); end - - def pending_message(); end - - def pending_message=(pending_message); end - - def record_finished(status, finished_at); end - - def run_time(); end - - def run_time=(run_time); end - - def started_at(); end - - def started_at=(started_at); end - - def status(); end - - def status=(status); end -end - -class RSpec::Core::Example::ExecutionResult - extend ::RSpec::Core::HashImitatable::ClassMethods end class RSpec::Core::Example::Procsy - def <<(*a, &b); end - - def ===(*a, &b); end - - def >>(*a, &b); end - - def [](*a, &b); end - - def arity(*a, &b); end - def attempts(); end - def binding(*a, &b); end - - def call(*args, &block); end - - def clock(*a, &b); end - - def clock=(*a, &b); end - - def clone(*a, &b); end - - def curry(*a, &b); end - - def description(*a, &b); end - - def dup(*a, &b); end - - def duplicate_with(*a, &b); end - - def example(); end - - def example_group(*a, &b); end - - def example_group_instance(*a, &b); end - - def exception(*a, &b); end - - def executed?(); end - - def execution_result(*a, &b); end - - def file_path(*a, &b); end - - def full_description(*a, &b); end - - def hash(*a, &b); end - - def id(*a, &b); end - - def initialize(example, &block); end - - def inspect_output(*a, &b); end - - def lambda?(*a, &b); end - - def location(*a, &b); end - - def location_rerun_argument(*a, &b); end - - def metadata(*a, &b); end - - def parameters(*a, &b); end - - def pending(*a, &b); end - - def pending?(*a, &b); end - - def reporter(*a, &b); end - - def rerun_argument(*a, &b); end - - def run(*args, &block); end - def run_with_retry(opts=T.unsafe(nil)); end - - def skip(*a, &b); end - - def skipped?(*a, &b); end - - def source_location(*a, &b); end - - def to_proc(); end - - def update_inherited_metadata(*a, &b); end - - def wrap(&block); end - - def yield(*a, &b); end -end - -class RSpec::Core::Example::Procsy -end - -class RSpec::Core::Example - def self.delegate_to_metadata(key); end - - def self.parse_id(id); end end class RSpec::Core::ExampleGroup - include ::RSpec::Core::MemoizedHelpers - include ::RSpec::Core::Pending include ::RSpec::Core::MockingAdapters::RSpec include ::RSpec::Mocks::ExampleMethods include ::RSpec::Mocks::ArgumentMatchers @@ -28991,839 +18770,11 @@ class RSpec::Core::ExampleGroup def clear_lets(); end def clear_memoized(); end - - def described_class(); end - - def initialize(inspect_output=T.unsafe(nil)); end - INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::ExampleGroup::WrongScopeError -end - -class RSpec::Core::ExampleGroup::WrongScopeError -end - -class RSpec::Core::ExampleGroup - extend ::RSpec::Core::Hooks - extend ::RSpec::Core::MemoizedHelpers::ClassMethods - extend ::RSpec::Core::SharedExampleGroup - def self.add_example(example); end - - def self.before_context_ivars(); end - - def self.children(); end - - def self.context(*args, &example_group_block); end - - def self.currently_executing_a_context_hook?(); end - - def self.declaration_locations(); end - - def self.define_example_group_method(name, metadata=T.unsafe(nil)); end - - def self.define_example_method(name, extra_options=T.unsafe(nil)); end - - def self.define_nested_shared_group_method(new_name, report_label=T.unsafe(nil)); end - - def self.delegate_to_metadata(*names); end - - def self.descendant_filtered_examples(); end - - def self.descendants(); end - - def self.describe(*args, &example_group_block); end - - def self.described_class(); end - - def self.description(); end - - def self.each_instance_variable_for_example(group); end - - def self.ensure_example_groups_are_configured(); end - - def self.example(*all_args, &block); end - - def self.example_group(*args, &example_group_block); end - - def self.examples(); end - - def self.fcontext(*args, &example_group_block); end - - def self.fdescribe(*args, &example_group_block); end - - def self.fexample(*all_args, &block); end - - def self.file_path(); end - - def self.filtered_examples(); end - - def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end - - def self.fit(*all_args, &block); end - - def self.focus(*all_args, &block); end - - def self.for_filtered_examples(reporter, &block); end - - def self.fspecify(*all_args, &block); end - - def self.id(); end - - def self.idempotently_define_singleton_method(name, &definition); end - - def self.include_context(name, *args, &block); end - - def self.include_examples(name, *args, &block); end - - def self.it(*all_args, &block); end - - def self.it_behaves_like(name, *args, &customization_block); end - - def self.it_should_behave_like(name, *args, &customization_block); end - - def self.location(); end - - def self.metadata(); end - - def self.next_runnable_index_for(file); end - - def self.ordering_strategy(); end - - def self.parent_groups(); end - - def self.pending(*all_args, &block); end - - def self.remove_example(example); end - - def self.reset_memoized(); end - - def self.run(reporter=T.unsafe(nil)); end - - def self.run_after_context_hooks(example_group_instance); end - - def self.run_before_context_hooks(example_group_instance); end - - def self.run_examples(reporter); end - - def self.set_it_up(description, args, registration_collection, &example_group_block); end - - def self.set_ivars(instance, ivars); end - - def self.skip(*all_args, &block); end - - def self.specify(*all_args, &block); end - - def self.store_before_context_ivars(example_group_instance); end - - def self.subclass(parent, description, args, registration_collection, &example_group_block); end - - def self.superclass_before_context_ivars(); end - - def self.superclass_metadata(); end - - def self.top_level?(); end - - def self.top_level_description(); end - - def self.traverse_tree_until(&block); end - - def self.update_inherited_metadata(updates); end - - def self.with_replaced_metadata(meta); end - - def self.xcontext(*args, &example_group_block); end - - def self.xdescribe(*args, &example_group_block); end - - def self.xexample(*all_args, &block); end - - def self.xit(*all_args, &block); end - - def self.xspecify(*all_args, &block); end -end - -class RSpec::Core::ExampleStatusDumper - def dump(); end - - def initialize(examples); end -end - -class RSpec::Core::ExampleStatusDumper - def self.dump(examples); end -end - -class RSpec::Core::ExampleStatusMerger - def initialize(this_run, from_previous_runs); end - - def merge(); end -end - -class RSpec::Core::ExampleStatusMerger - def self.merge(this_run, from_previous_runs); end -end - -class RSpec::Core::ExampleStatusParser - def initialize(string); end - - def parse(); end -end - -class RSpec::Core::ExampleStatusParser - def self.parse(string); end -end - -class RSpec::Core::ExampleStatusPersister - def initialize(examples, file_name); end - - def persist(); end -end - -class RSpec::Core::ExampleStatusPersister - def self.load_from(file_name); end - - def self.persist(examples, file_name); end -end - -RSpec::Core::ExclusionRules = RSpec::Core::FilterRules - -class RSpec::Core::FilterManager - def add_ids(rerun_path, scoped_ids); end - - def add_location(file_path, line_numbers); end - - def empty?(); end - - def exclude(*args); end - - def exclude_only(*args); end - - def exclude_with_low_priority(*args); end - - def exclusions(); end - - def include(*args); end - - def include_only(*args); end - - def include_with_low_priority(*args); end - - def inclusions(); end - - def prune(examples); end -end - -class RSpec::Core::FilterManager -end - -class RSpec::Core::FilterRules - def [](key); end - - def add(updated); end - - def add_with_low_priority(updated); end - - def clear(); end - - def delete(key); end - - def description(); end - - def each_pair(&block); end - - def empty?(); end - - def fetch(*args, &block); end - - def include_example?(example); end - - def initialize(rules=T.unsafe(nil)); end - - def opposite(); end - - def opposite=(opposite); end - - def rules(); end - - def use_only(updated); end - PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped) - PROJECT_DIR = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::FilterRules - def self.build(); end -end - -module RSpec::Core::FilterableItemRepository -end - -class RSpec::Core::FilterableItemRepository::QueryOptimized - def items_for(metadata); end -end - -class RSpec::Core::FilterableItemRepository::QueryOptimized -end - -class RSpec::Core::FilterableItemRepository::UpdateOptimized - def append(item, metadata); end - - def delete(item, metadata); end - - def initialize(applies_predicate); end - - def items_and_filters(); end - - def items_for(request_meta); end - - def prepend(item, metadata); end -end - -class RSpec::Core::FilterableItemRepository::UpdateOptimized -end - -module RSpec::Core::FilterableItemRepository -end - -module RSpec::Core::FlatMap -end - -module RSpec::Core::FlatMap - def self.flat_map(array, &block); end -end - -module RSpec::Core::Formatters -end - -class RSpec::Core::Formatters::BaseBisectFormatter - def example_failed(notification); end - - def example_finished(notification); end - - def initialize(expected_failures); end - - def start_dump(_notification); end -end - -class RSpec::Core::Formatters::BaseBisectFormatter - def self.inherited(formatter); end -end - -class RSpec::Core::Formatters::BaseFormatter - def close(_notification); end - - def example_group(); end - - def example_group=(example_group); end - - def example_group_started(notification); end - - def initialize(output); end - - def output(); end - - def start(notification); end -end - -class RSpec::Core::Formatters::BaseFormatter -end - -class RSpec::Core::Formatters::BaseTextFormatter - def dump_failures(notification); end - - def dump_pending(notification); end - - def dump_summary(summary); end - - def message(notification); end - - def seed(notification); end -end - -class RSpec::Core::Formatters::BaseTextFormatter -end - -class RSpec::Core::Formatters::BisectDRbFormatter - def initialize(_output); end - - def notify_results(results); end -end - -class RSpec::Core::Formatters::BisectDRbFormatter -end - -module RSpec::Core::Formatters::ConsoleCodes - VT100_CODES = ::T.let(nil, ::T.untyped) - VT100_CODE_VALUES = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::ConsoleCodes - def self.config_colors_to_methods(); end - - def self.console_code_for(code_or_symbol); end - - def self.wrap(text, code_or_symbol); end -end - -class RSpec::Core::Formatters::DeprecationFormatter - def count(); end - - def deprecation(notification); end - - def deprecation_message_for(data); end - - def deprecation_stream(); end - - def deprecation_summary(_notification); end - - def initialize(deprecation_stream, summary_stream); end - - def output(); end - - def printer(); end - - def summary_stream(); end - DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped) - RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped) - TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter - def deprecation_formatter(); end - - def deprecation_stream(); end - - def deprecation_summary(); end - - def initialize(deprecation_stream, summary_stream, deprecation_formatter); end - - def print_deferred_deprecation_warnings(); end - - def print_deprecation_message(data); end - - def stash_deprecation_message(deprecation_message); end - - def summary_stream(); end - TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter -end - -class RSpec::Core::Formatters::DeprecationFormatter::FileStream - def initialize(file); end - - def puts(*args); end - - def summarize(summary_stream, deprecation_count); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::FileStream -end - -class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage - def initialize(data); end - - def too_many_warnings_message(); end - - def type(); end - - def type=(_); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter - def deprecation_formatter(); end - - def deprecation_stream(); end - - def deprecation_summary(); end - - def initialize(deprecation_stream, summary_stream, deprecation_formatter); end - - def print_deprecation_message(data); end - - def summary_stream(); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter -end - -class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream - def puts(message); end - - def summarize(summary_stream, deprecation_count); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream -end - -class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage - def initialize(data); end - - def too_many_warnings_message(); end - - def type(); end - - def type=(_); end -end - -class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Formatters::DeprecationFormatter -end - -class RSpec::Core::Formatters::DocumentationFormatter - def example_failed(failure); end - - def example_group_finished(_notification); end - - def example_passed(passed); end - - def example_pending(pending); end - - def example_started(_notification); end -end - -class RSpec::Core::Formatters::DocumentationFormatter -end - -class RSpec::Core::Formatters::ExceptionPresenter - def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end - - def colorized_message_lines(colorizer=T.unsafe(nil)); end - - def description(); end - - def example(); end - - def exception(); end - - def formatted_backtrace(exception=T.unsafe(nil)); end - - def formatted_cause(exception); end - - def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end - - def fully_formatted_lines(failure_number, colorizer); end - - def initialize(exception, example, options=T.unsafe(nil)); end - - def message_lines(); end - PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::ExceptionPresenter::Factory - def build(); end - - def initialize(example); end -end - -class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater - def initialize(parent); end - - def with_truncated_backtrace(child); end -end - -class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater -end - -module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter -end - -module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter - def self.format_backtrace(*_); end -end - -class RSpec::Core::Formatters::ExceptionPresenter::Factory -end - -class RSpec::Core::Formatters::ExceptionPresenter -end - -class RSpec::Core::Formatters::FailureListFormatter - def dump_profile(_profile); end - - def example_failed(failure); end - - def message(_message); end -end - -class RSpec::Core::Formatters::FailureListFormatter -end - -class RSpec::Core::Formatters::FallbackMessageFormatter - def initialize(output); end - - def message(notification); end - - def output(); end -end - -class RSpec::Core::Formatters::FallbackMessageFormatter -end - -module RSpec::Core::Formatters::Helpers - DEFAULT_PRECISION = ::T.let(nil, ::T.untyped) - SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::Helpers - def self.format_duration(duration); end - - def self.format_seconds(float, precision=T.unsafe(nil)); end - - def self.organize_ids(ids); end - - def self.pluralize(count, string); end -end - -class RSpec::Core::Formatters::HtmlFormatter - def dump_summary(summary); end - - def example_failed(failure); end - - def example_passed(passed); end - - def example_pending(pending); end - - def example_started(_notification); end - - def start_dump(_notification); end -end - -class RSpec::Core::Formatters::HtmlFormatter -end - -class RSpec::Core::Formatters::HtmlPrinter - include ::ERB::Util - def flush(); end - - def initialize(output); end - - def make_example_group_header_red(group_id); end - - def make_example_group_header_yellow(group_id); end - - def make_header_red(); end - - def make_header_yellow(); end - - def move_progress(percent_done); end - - def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end - - def print_example_group_end(); end - - def print_example_group_start(group_id, description, number_of_parents); end - - def print_example_passed(description, run_time); end - - def print_example_pending(description, pending_message); end - - def print_html_start(); end - - def print_summary(duration, example_count, failure_count, pending_count); end - GLOBAL_SCRIPTS = ::T.let(nil, ::T.untyped) - GLOBAL_STYLES = ::T.let(nil, ::T.untyped) - HTML_HEADER = ::T.let(nil, ::T.untyped) - REPORT_HEADER = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::HtmlPrinter -end - -class RSpec::Core::Formatters::JsonFormatter - def dump_profile(profile); end - - def dump_profile_slowest_example_groups(profile); end - - def dump_profile_slowest_examples(profile); end - - def dump_summary(summary); end - - def message(notification); end - - def output_hash(); end - - def seed(notification); end - - def stop(notification); end -end - -class RSpec::Core::Formatters::JsonFormatter -end - -class RSpec::Core::Formatters::Loader - def add(formatter_to_use, *paths); end - - def default_formatter(); end - - def default_formatter=(default_formatter); end - - def formatters(); end - - def initialize(reporter); end - - def prepare_default(output_stream, deprecation_stream); end - - def reporter(); end - - def setup_default(output_stream, deprecation_stream); end -end - -class RSpec::Core::Formatters::Loader - def self.formatters(); end -end - -class RSpec::Core::Formatters::ProfileFormatter - def dump_profile(profile); end - - def initialize(output); end - - def output(); end -end - -class RSpec::Core::Formatters::ProfileFormatter -end - -class RSpec::Core::Formatters::ProgressFormatter - def example_failed(_notification); end - - def example_passed(_notification); end - - def example_pending(_notification); end - - def start_dump(_notification); end -end - -class RSpec::Core::Formatters::ProgressFormatter -end - -class RSpec::Core::Formatters::SnippetExtractor - def beginning_line_number(); end - - def expression_lines(); end - - def initialize(source, beginning_line_number, max_line_count=T.unsafe(nil)); end - - def max_line_count(); end - - def source(); end -end - -class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError -end - -class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError -end - -class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError -end - -class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError -end - -class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError -end - -class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError -end - -class RSpec::Core::Formatters::SnippetExtractor - def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=T.unsafe(nil)); end - - def self.extract_line_at(file_path, line_number); end - - def self.least_indentation_from(lines); end - - def self.source_from_file(path); end -end - -class RSpec::Core::Formatters::SyntaxHighlighter - def highlight(lines); end - - def initialize(configuration); end -end - -module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation - RESET_CODE = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation - def self.highlight_syntax(lines); end -end - -module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation -end - -module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation - def self.highlight_syntax(lines); end -end - -RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation - -class RSpec::Core::Formatters::SyntaxHighlighter - def self.attempt_to_add_rspec_terms_to_coderay_keywords(); end -end - -module RSpec::Core::Formatters - def self.register(formatter_class, *notifications); end end module RSpec::Core::HashImitatable - def <(*args, &block); end - - def <=(*args, &block); end - - def >(*args, &block); end - - def >=(*args, &block); end - - def [](key); end - - def []=(key, value); end - - def all?(*args, &block); end - - def any?(*args, &block); end - def assert_valid_keys(*args, &block); end - def assoc(*args, &block); end - - def chain(*args, &block); end - - def chunk(*args, &block); end - - def chunk_while(*args, &block); end - - def clear(*args, &block); end - - def collect(*args, &block); end - - def collect_concat(*args, &block); end - - def compact(*args, &block); end - - def compact!(*args, &block); end - - def compare_by_identity(*args, &block); end - - def compare_by_identity?(*args, &block); end - - def count(*args, &block); end - - def cycle(*args, &block); end - def deep_merge(*args, &block); end def deep_merge!(*args, &block); end @@ -29840,48 +18791,6 @@ module RSpec::Core::HashImitatable def deep_transform_keys!(*args, &block); end - def default(*args, &block); end - - def default=(*args, &block); end - - def default_proc(*args, &block); end - - def default_proc=(*args, &block); end - - def delete(*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_key(*args, &block); end - - def each_pair(*args, &block); end - - def each_slice(*args, &block); end - - def each_value(*args, &block); end - - def each_with_index(*args, &block); end - - def each_with_object(*args, &block); end - - def empty?(*args, &block); end - - def entries(*args, &block); end - def except(*args, &block); end def except!(*args, &block); end @@ -29890,498 +18799,23 @@ module RSpec::Core::HashImitatable def extractable_options?(*args, &block); end - def fetch(*args, &block); end - - def fetch_values(*args, &block); end - - def filter(*args, &block); end - - def filter!(*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 grep(*args, &block); end - - def grep_v(*args, &block); end - - def group_by(*args, &block); end - - def has_key?(*args, &block); end - - def has_value?(*args, &block); end - - def include?(*args, &block); end - - def index(*args, &block); end - - def inject(*args, &block); end - - def invert(*args, &block); end - - def keep_if(*args, &block); end - - def key(*args, &block); end - - def key?(*args, &block); end - - def keys(*args, &block); end - - def lazy(*args, &block); end - - def length(*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 merge(*args, &block); end - - def merge!(*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 partition(*args, &block); end - - def rassoc(*args, &block); end - - def reduce(*args, &block); end - - def rehash(*args, &block); end - - def reject(*args, &block); end - - def reject!(*args, &block); end - - def replace(*args, &block); end - - def reverse_each(*args, &block); end - def save_plist(*args, &block); end - def select(*args, &block); end - - def select!(*args, &block); end - - def shift(*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_by(*args, &block); end - - def store(*args, &block); end - def stringify_keys(*args, &block); end def stringify_keys!(*args, &block); end - def sum(*args, &block); end - def symbolize_keys(*args, &block); end def symbolize_keys!(*args, &block); end - def take(*args, &block); end - - def take_while(*args, &block); end - - def to_a(*args, &block); end - - def to_h(); end - - def to_hash(*args, &block); end - def to_options(*args, &block); end def to_options!(*args, &block); end def to_plist(*args, &block); end - - def to_proc(*args, &block); end - - def to_set(*args, &block); end - - def transform_keys(*args, &block); end - - def transform_keys!(*args, &block); end - - def transform_values(*args, &block); end - - def transform_values!(*args, &block); end - - def uniq(*args, &block); end - - def update(*args, &block); end - - def value?(*args, &block); end - - def values(*args, &block); end - - def values_at(*args, &block); end - - def zip(*args, &block); end -end - -module RSpec::Core::HashImitatable::ClassMethods - def attr_accessor(*names); end - - def hash_attribute_names(); end -end - -module RSpec::Core::HashImitatable::ClassMethods -end - -module RSpec::Core::HashImitatable - def self.included(klass); end -end - -module RSpec::Core::Hooks - def after(*args, &block); end - - def append_after(*args, &block); end - - def append_before(*args, &block); end - - def around(*args, &block); end - - def before(*args, &block); end - - def hooks(); end - - def prepend_after(*args, &block); end - - def prepend_before(*args, &block); end -end - -class RSpec::Core::Hooks::AfterContextHook - def run(example); end -end - -class RSpec::Core::Hooks::AfterContextHook -end - -class RSpec::Core::Hooks::AfterHook - def run(example); end -end - -class RSpec::Core::Hooks::AfterHook -end - -class RSpec::Core::Hooks::AroundHook - def execute_with(example, procsy); end - - def hook_description(); end -end - -class RSpec::Core::Hooks::AroundHook -end - -class RSpec::Core::Hooks::BeforeHook - def run(example); end -end - -class RSpec::Core::Hooks::BeforeHook -end - -class RSpec::Core::Hooks::Hook - def block(); end - - def block=(_); end - - def options(); end - - def options=(_); end -end - -class RSpec::Core::Hooks::Hook - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Hooks::HookCollections - def all_hooks_for(position, scope); end - - def initialize(owner, filterable_item_repo_class); end - - def matching_hooks_for(position, scope, example_or_group); end - - def processable_hooks_for(position, scope, host); end - - def register(prepend_or_append, position, *args, &block); end - - def register_global_singleton_context_hooks(example, globals); end - - def register_globals(host, globals); end - - def run(position, scope, example_or_group); end - - def run_owned_hooks_for(position, scope, example_or_group); end - EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped) - HOOK_TYPES = ::T.let(nil, ::T.untyped) - SCOPES = ::T.let(nil, ::T.untyped) - SCOPE_ALIASES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Hooks::HookCollections -end - -module RSpec::Core::Hooks -end - -class RSpec::Core::InclusionRules - def add(*args); end - - def add_with_low_priority(*args); end - - def split_file_scoped_rules(); end - - def standalone?(); end -end - -class RSpec::Core::InclusionRules -end - -module RSpec::Core::Invocations -end - -class RSpec::Core::Invocations::Bisect - def call(options, err, out); end -end - -class RSpec::Core::Invocations::Bisect -end - -class RSpec::Core::Invocations::DRbWithFallback - def call(options, err, out); end -end - -class RSpec::Core::Invocations::DRbWithFallback -end - -class RSpec::Core::Invocations::InitializeProject - def call(*_args); end -end - -class RSpec::Core::Invocations::InitializeProject -end - -class RSpec::Core::Invocations::PrintHelp - def call(_options, _err, out); end - - def hidden_options(); end - - def hidden_options=(_); end - - def parser(); end - - def parser=(_); end -end - -class RSpec::Core::Invocations::PrintHelp - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Invocations::PrintVersion - def call(_options, _err, out); end -end - -class RSpec::Core::Invocations::PrintVersion -end - -module RSpec::Core::Invocations -end - -class RSpec::Core::LegacyExampleGroupHash - include ::RSpec::Core::HashImitatable - def initialize(metadata); end -end - -class RSpec::Core::LegacyExampleGroupHash - extend ::RSpec::Core::HashImitatable::ClassMethods -end - -module RSpec::Core::MemoizedHelpers - def initialize(*_); end - - def is_expected(); end - - def should(matcher=T.unsafe(nil), message=T.unsafe(nil)); end - - def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil)); end - - def subject(); end -end - -module RSpec::Core::MemoizedHelpers::ClassMethods - def let(name, &block); end - - def let!(name, &block); end - - def subject(name=T.unsafe(nil), &block); end - - def subject!(name=T.unsafe(nil), &block); end -end - -module RSpec::Core::MemoizedHelpers::ClassMethods -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After - def self.article(); end - - def self.hook_expression(); end - - def self.hook_intention(); end -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before - def self.article(); end - - def self.hook_expression(); end - - def self.hook_intention(); end -end - -class RSpec::Core::MemoizedHelpers::ContextHookMemoized - def self.fetch_or_store(key, &_block); end - - def self.isolate_for_context_hook(example_group_instance); end -end - -class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized - def fetch_or_store(key); end -end - -class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized -end - -class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized - def fetch_or_store(key); end -end - -class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized -end - -module RSpec::Core::MemoizedHelpers - def self.define_helpers_on(example_group); end - - def self.get_constant_or_yield(example_group, name); end - - def self.module_for(example_group); end -end - -module RSpec::Core::Metadata - RESERVED_KEYS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Metadata::ExampleGroupHash -end - -class RSpec::Core::Metadata::ExampleGroupHash - def self.backwards_compatibility_default_proc(&example_group_selector); end - - def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end - - def self.hash_with_backwards_compatibility_default_proc(); end -end - -class RSpec::Core::Metadata::ExampleHash -end - -class RSpec::Core::Metadata::ExampleHash - def self.create(group_metadata, user_metadata, index_provider, description, block); end -end - -class RSpec::Core::Metadata::HashPopulator - def block(); end - - def description_args(); end - - def initialize(metadata, user_metadata, index_provider, description_args, block); end - - def metadata(); end - - def populate(); end - - def user_metadata(); end -end - -class RSpec::Core::Metadata::HashPopulator -end - -module RSpec::Core::Metadata - def self.ascend(metadata); end - - def self.ascending(metadata); end - - def self.build_hash_from(args, warn_about_example_group_filtering=T.unsafe(nil)); end - - def self.deep_hash_dup(object); end - - def self.id_from(metadata); end - - def self.location_tuple_from(metadata); end - - def self.relative_path(line); end - - def self.relative_path_regex(); end -end - -module RSpec::Core::MetadataFilter -end - -module RSpec::Core::MetadataFilter - def self.apply?(predicate, filters, metadata); end - - def self.filter_applies?(key, filter_value, metadata); end - - def self.silence_metadata_example_group_deprecations(); end end module RSpec::Core::MockingAdapters @@ -30407,452 +18841,9 @@ end module RSpec::Core::MockingAdapters end -class RSpec::Core::MultipleExceptionError - include ::RSpec::Core::MultipleExceptionError::InterfaceTag - def aggregation_block_label(); end - - def aggregation_metadata(); end - - def all_exceptions(); end - - def exception_count_description(); end - - def failures(); end - - def initialize(*exceptions); end - - def other_errors(); end - - def summary(); end -end - -module RSpec::Core::MultipleExceptionError::InterfaceTag - def add(exception); end -end - -module RSpec::Core::MultipleExceptionError::InterfaceTag - def self.for(ex); end -end - -class RSpec::Core::MultipleExceptionError -end - -module RSpec::Core::Notifications -end - -class RSpec::Core::Notifications::CustomNotification -end - -class RSpec::Core::Notifications::CustomNotification - def self.for(options=T.unsafe(nil)); end -end - -class RSpec::Core::Notifications::DeprecationNotification - def call_site(); end - - def call_site=(_); end - - def deprecated(); end - - def deprecated=(_); end - - def message(); end - - def message=(_); end - - def replacement(); end - - def replacement=(_); end -end - -class RSpec::Core::Notifications::DeprecationNotification - def self.[](*_); end - - def self.from_hash(data); end - - def self.members(); end -end - -class RSpec::Core::Notifications::ExampleNotification - def example(); end - - def example=(_); end -end - -class RSpec::Core::Notifications::ExampleNotification - def self.[](*_); end - - def self.for(example); end - - def self.members(); end -end - -class RSpec::Core::Notifications::ExamplesNotification - def examples(); end - - def failed_examples(); end - - def failure_notifications(); end - - def fully_formatted_failed_examples(colorizer=T.unsafe(nil)); end - - def fully_formatted_pending_examples(colorizer=T.unsafe(nil)); end - - def initialize(reporter); end - - def notifications(); end - - def pending_examples(); end - - def pending_notifications(); end -end - -class RSpec::Core::Notifications::ExamplesNotification -end - -class RSpec::Core::Notifications::FailedExampleNotification - def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end - - def colorized_message_lines(colorizer=T.unsafe(nil)); end - - def description(); end - - def exception(); end - - def formatted_backtrace(); end - - def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end - - def fully_formatted_lines(failure_number, colorizer=T.unsafe(nil)); end - - def initialize(example, exception_presenter=T.unsafe(nil)); end - - def message_lines(); end -end - -class RSpec::Core::Notifications::FailedExampleNotification -end - -class RSpec::Core::Notifications::GroupNotification - def group(); end - - def group=(_); end -end - -class RSpec::Core::Notifications::GroupNotification - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Notifications::MessageNotification - def message(); end - - def message=(_); end -end - -class RSpec::Core::Notifications::MessageNotification - def self.[](*_); end - - def self.members(); end -end - -module RSpec::Core::Notifications::NullColorizer -end - -module RSpec::Core::Notifications::NullColorizer - def self.wrap(line, _code_or_symbol); end -end - -class RSpec::Core::Notifications::NullNotification -end - -class RSpec::Core::Notifications::NullNotification -end - -class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification -end - -class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification -end - -class RSpec::Core::Notifications::PendingExampleFixedNotification -end - -class RSpec::Core::Notifications::PendingExampleFixedNotification -end - -class RSpec::Core::Notifications::ProfileNotification - def duration(); end - - def examples(); end - - def initialize(duration, examples, number_of_examples, example_groups); end - - def number_of_examples(); end - - def percentage(); end - - def slow_duration(); end - - def slowest_examples(); end - - def slowest_groups(); end -end - -class RSpec::Core::Notifications::ProfileNotification -end - -class RSpec::Core::Notifications::SeedNotification - def fully_formatted(); end - - def seed(); end - - def seed=(_); end - - def seed_used?(); end - - def used=(_); end -end - -class RSpec::Core::Notifications::SeedNotification - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Notifications::SkippedExampleNotification - def fully_formatted(pending_number, colorizer=T.unsafe(nil)); end -end - -class RSpec::Core::Notifications::SkippedExampleNotification -end - -class RSpec::Core::Notifications::StartNotification - def count(); end - - def count=(_); end - - def load_time(); end - - def load_time=(_); end -end - -class RSpec::Core::Notifications::StartNotification - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Core::Notifications::SummaryNotification - include ::RSpec::Core::ShellEscape - def colorized_rerun_commands(colorizer=T.unsafe(nil)); end - - def colorized_totals_line(colorizer=T.unsafe(nil)); end - - def duration(); end - - def duration=(_); end - - def errors_outside_of_examples_count(); end - - def errors_outside_of_examples_count=(_); end - - def example_count(); end - - def examples(); end - - def examples=(_); end - - def failed_examples(); end - - def failed_examples=(_); end - - def failure_count(); end - - def formatted_duration(); end - - def formatted_load_time(); end - - def fully_formatted(colorizer=T.unsafe(nil)); end - - def load_time(); end - - def load_time=(_); end - - def pending_count(); end - - def pending_examples(); end - - def pending_examples=(_); end - - def totals_line(); end -end - -class RSpec::Core::Notifications::SummaryNotification - def self.[](*_); end - - def self.members(); end -end - -module RSpec::Core::Notifications -end - -class RSpec::Core::NullReporter -end - -class RSpec::Core::NullReporter -end - -module RSpec::Core::Ordering -end - -class RSpec::Core::Ordering::ConfigurationManager - def force(hash); end - - def order=(type); end - - def ordering_registry(); end - - def register_ordering(name, strategy=T.unsafe(nil)); end - - def seed(); end - - def seed=(seed); end - - def seed_used?(); end -end - -class RSpec::Core::Ordering::ConfigurationManager -end - -class RSpec::Core::Ordering::Custom - def initialize(callable); end - - def order(list); end -end - -class RSpec::Core::Ordering::Custom -end - -class RSpec::Core::Ordering::Identity - def order(items); end -end - -class RSpec::Core::Ordering::Identity -end - -class RSpec::Core::Ordering::Random - def initialize(configuration); end - - def order(items); end - - def used?(); end - MAX_32_BIT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Ordering::Random -end - -class RSpec::Core::Ordering::Registry - def fetch(name, &fallback); end - - def initialize(configuration); end - - def register(sym, strategy); end - - def used_random_seed?(); end -end - -class RSpec::Core::Ordering::Registry -end - -module RSpec::Core::Ordering -end - class RSpec::Core::OutputWrapper - def <<(*args, &block); end - - def advise(*args, &block); end - def as_json(*args, &block); end - def autoclose=(*args, &block); end - - def autoclose?(*args, &block); end - - def binmode(*args, &block); end - - def binmode?(*args, &block); end - - def bytes(*args, &block); end - - def chars(*args, &block); end - - def close(*args, &block); end - - def close_on_exec=(*args, &block); end - - def close_on_exec?(*args, &block); end - - def close_read(*args, &block); end - - def close_write(*args, &block); end - - def closed?(*args, &block); end - - def codepoints(*args, &block); end - - def each(*args, &block); end - - def each_byte(*args, &block); end - - def each_char(*args, &block); end - - def each_codepoint(*args, &block); end - - def each_line(*args, &block); end - - def eof(*args, &block); end - - def eof?(*args, &block); end - - def external_encoding(*args, &block); end - - def fcntl(*args, &block); end - - def fdatasync(*args, &block); end - - def fileno(*args, &block); end - - def flush(*args, &block); end - - def fsync(*args, &block); end - - def getbyte(*args, &block); end - - def getc(*args, &block); end - - def gets(*args, &block); end - - def initialize(output); end - - def inspect(*args, &block); end - - def internal_encoding(*args, &block); end - - def ioctl(*args, &block); end - - def isatty(*args, &block); end - - def lineno(*args, &block); end - - def lineno=(*args, &block); end - - def lines(*args, &block); end - - def method_missing(name, *args, &block); end - def nonblock(*args, &block); end def nonblock=(*args, &block); end @@ -30861,884 +18852,21 @@ class RSpec::Core::OutputWrapper def nread(*args, &block); end - def output(); end - - def output=(output); end - - def pathconf(*args, &block); end - - def pid(*args, &block); end - - def pos(*args, &block); end - - def pos=(*args, &block); end - - def pread(*args, &block); end - - def print(*args, &block); end - - def printf(*args, &block); end - - def putc(*args, &block); end - - def puts(*args, &block); end - - def pwrite(*args, &block); end - - def read(*args, &block); end - - def read_nonblock(*args, &block); end - - def readbyte(*args, &block); end - - def readchar(*args, &block); end - - def readline(*args, &block); end - - def readlines(*args, &block); end - - def readpartial(*args, &block); end - def ready?(*args, &block); end - def reopen(*args, &block); end - - def respond_to?(name, priv=T.unsafe(nil)); end - - def rewind(*args, &block); end - - def seek(*args, &block); end - - def set_encoding(*args, &block); end - - def stat(*args, &block); end - - def sync(*args, &block); end - - def sync=(*args, &block); end - - def sysread(*args, &block); end - - def sysseek(*args, &block); end - - def syswrite(*args, &block); end - - def tell(*args, &block); end - - def to_i(*args, &block); end - - def to_io(*args, &block); end - - def tty?(*args, &block); end - - def ungetbyte(*args, &block); end - - def ungetc(*args, &block); end - def wait(*args, &block); end def wait_readable(*args, &block); end def wait_writable(*args, &block); end - - def write(*args, &block); end - - def write_nonblock(*args, &block); end -end - -class RSpec::Core::OutputWrapper -end - -class RSpec::Core::Parser - def initialize(original_args); end - - def original_args(); end - - def parse(source=T.unsafe(nil)); end -end - -class RSpec::Core::Parser - def self.parse(args, source=T.unsafe(nil)); end -end - -module RSpec::Core::Pending - def pending(message=T.unsafe(nil)); end - - def skip(message=T.unsafe(nil)); end - NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped) - NO_REASON_GIVEN = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Pending::PendingExampleFixedError -end - -class RSpec::Core::Pending::PendingExampleFixedError -end - -class RSpec::Core::Pending::SkipDeclaredInExample - def argument(); end - - def initialize(argument); end -end - -class RSpec::Core::Pending::SkipDeclaredInExample -end - -module RSpec::Core::Pending - def self.mark_fixed!(example); end - - def self.mark_pending!(example, message_or_bool); end - - def self.mark_skipped!(example, message_or_bool); end -end - -class RSpec::Core::Profiler - def example_group_finished(notification); end - - def example_group_started(notification); end - - def example_groups(); end - - def example_started(notification); end - NOTIFICATIONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Profiler -end - -class RSpec::Core::Reporter - def abort_with(msg, exit_status); end - - def close_after(); end - - def deprecation(hash); end - - def example_failed(example); end - - def example_finished(example); end - - def example_group_finished(group); end - - def example_group_started(group); end - - def example_passed(example); end - - def example_pending(example); end - - def example_started(example); end - - def examples(); end - - def exit_early(exit_code); end - - def fail_fast_limit_met?(); end - - def failed_examples(); end - - def finish(); end - - def initialize(configuration); end - - def message(message); end - - def notify(event, notification); end - - def notify_non_example_exception(exception, context_description); end - - def pending_examples(); end - - def prepare_default(loader, output_stream, deprecation_stream); end - - def publish(event, options=T.unsafe(nil)); end - - def register_listener(listener, *notifications); end - - def registered_listeners(notification); end - - def report(expected_example_count); end - - def start(expected_example_count, time=T.unsafe(nil)); end - - def stop(); end - RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Reporter -end - -module RSpec::Core::RubyProject -end - -module RSpec::Core::RubyProject - def self.add_dir_to_load_path(dir); end - - def self.add_to_load_path(*dirs); end - - def self.ascend_until(); end - - def self.determine_root(); end - - def self.find_first_parent_containing(dir); end - - def self.root(); end -end - -class RSpec::Core::Runner - def configuration(); end - - def configure(err, out); end - - def initialize(options, configuration=T.unsafe(nil), world=T.unsafe(nil)); end - - def options(); end - - def run(err, out); end - - def run_specs(example_groups); end - - def setup(err, out); end - - def world(); end -end - -class RSpec::Core::Runner - def self.autorun(); end - - def self.autorun_disabled?(); end - - def self.disable_autorun!(); end - - def self.handle_interrupt(); end - - def self.installed_at_exit?(); end - - def self.invoke(); end - - def self.perform_at_exit(); end - - def self.run(args, err=T.unsafe(nil), out=T.unsafe(nil)); end - - def self.running_in_drb?(); end - - def self.trap_interrupt(); end -end - -class RSpec::Core::Set - include ::Enumerable - def <<(key); end - - def clear(); end - - def delete(key); end - - def each(&block); end - - def empty?(); end - - def include?(key); end - - def initialize(array=T.unsafe(nil)); end - - def merge(values); end -end - -class RSpec::Core::Set end module RSpec::Core::SharedContext include ::RSpec::Its - def __shared_context_recordings(); end - - def after(*args, &block); end - - def append_after(*args, &block); end - - def append_before(*args, &block); end - - def around(*args, &block); end - - def before(*args, &block); end - - def context(*args, &block); end - - def describe(*args, &block); end - - def hooks(*args, &block); end - - def included(group); end - - def let(*args, &block); end - - def let!(*args, &block); end - - def prepend_after(*args, &block); end - - def prepend_before(*args, &block); end - - def subject(*args, &block); end - - def subject!(*args, &block); end -end - -class RSpec::Core::SharedContext::Recording - def args(); end - - def args=(_); end - - def block(); end - - def block=(_); end - - def method_name(); end - - def method_name=(_); end - - def playback_onto(group); end -end - -class RSpec::Core::SharedContext::Recording - def self.[](*_); end - - def self.members(); end -end - -module RSpec::Core::SharedContext - def self.record(methods); end -end - -module RSpec::Core::SharedExampleGroup - def shared_context(name, *args, &block); end - - def shared_examples(name, *args, &block); end - - def shared_examples_for(name, *args, &block); end -end - -class RSpec::Core::SharedExampleGroup::Registry - def add(context, name, *metadata_args, &block); end - - def find(lookup_contexts, name); end -end - -class RSpec::Core::SharedExampleGroup::Registry -end - -module RSpec::Core::SharedExampleGroup::TopLevelDSL -end - -module RSpec::Core::SharedExampleGroup::TopLevelDSL - def self.definitions(); end - - def self.expose_globally!(); end - - def self.exposed_globally?(); end - - def self.remove_globally!(); end -end - -module RSpec::Core::SharedExampleGroup -end - -class RSpec::Core::SharedExampleGroupInclusionStackFrame - def description(); end - - def formatted_inclusion_location(); end - - def inclusion_location(); end - - def initialize(shared_group_name, inclusion_location); end - - def shared_group_name(); end -end - -class RSpec::Core::SharedExampleGroupInclusionStackFrame - def self.current_backtrace(); end - - def self.shared_example_group_inclusions(); end - - def self.with_frame(name, location); end -end - -class RSpec::Core::SharedExampleGroupModule - def definition(); end - - def include_in(klass, inclusion_line, args, customization_block); end - - def included(klass); end - - def initialize(description, definition, metadata); end -end - -class RSpec::Core::SharedExampleGroupModule -end - -module RSpec::Core::ShellEscape - SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::ShellEscape - def self.conditionally_quote(id); end - - def self.escape(shell_command); end - - def self.quote(argument); end - - def self.shell_allows_unquoted_ids?(); end -end - -class RSpec::Core::SuiteHookContext - def initialize(hook_description, reporter); end -end - -class RSpec::Core::SuiteHookContext -end - -class RSpec::Core::Time -end - -class RSpec::Core::Time - def self.now(); end -end - -module RSpec::Core::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Version -end - -module RSpec::Core::Warnings - def deprecate(deprecated, data=T.unsafe(nil)); end - - def warn_deprecation(message, opts=T.unsafe(nil)); end - - def warn_with(message, options=T.unsafe(nil)); end -end - -module RSpec::Core::Warnings -end - -class RSpec::Core::World - def all_example_groups(); end - - def all_examples(); end - - def announce_exclusion_filter(announcements); end - - def announce_filters(); end - - def announce_inclusion_filter(announcements); end - - def everything_filtered_message(); end - - def example_count(groups=T.unsafe(nil)); end - - def example_group_counts_by_spec_file(); end - - def example_groups(); end - - def exclusion_filter(); end - - def filter_manager(); end - - def filtered_examples(); end - - def inclusion_filter(); end - - def initialize(configuration=T.unsafe(nil)); end - - def non_example_failure(); end - - def non_example_failure=(non_example_failure); end - - def num_example_groups_defined_in(file); end - - def ordered_example_groups(); end - - def preceding_declaration_line(absolute_file_name, filter_line); end - - def prepare_example_filtering(); end - - def record(example_group); end - - def registered_example_group_files(); end - - def report_filter_message(message); end - - def reporter(); end - - def reset(); end - - def shared_example_group_registry(); end - - def source_from_file(path); end - - def syntax_highlighter(); end - - def traverse_example_group_trees_until(&block); end - - def wants_to_quit(); end - - def wants_to_quit=(wants_to_quit); end -end - -module RSpec::Core::World::Null -end - -module RSpec::Core::World::Null - def self.all_example_groups(); end - - def self.example_groups(); end - - def self.non_example_failure(); end - - def self.non_example_failure=(_); end - - def self.registered_example_group_files(); end - - def self.traverse_example_group_trees_until(); end -end - -class RSpec::Core::World -end - -module RSpec::Core - def self.path_to_executable(); end -end - -module RSpec::ExampleGroups -end - -module RSpec::ExampleGroups - extend ::RSpec::Support::RecursiveConstMethods - def self.assign_const(group); end - - def self.base_name_for(group); end - - def self.constant_scope_for(group); end - - def self.disambiguate(name, const_scope); end - - def self.remove_all_constants(); end -end - -module RSpec::Expectations -end - -class RSpec::Expectations::BlockExpectationTarget - def not_to(matcher, message=T.unsafe(nil), &block); end - - def to(matcher, message=T.unsafe(nil), &block); end - - def to_not(matcher, message=T.unsafe(nil), &block); end -end - -class RSpec::Expectations::BlockExpectationTarget -end - -class RSpec::Expectations::BlockSnippetExtractor - def body_content_lines(); end - - def initialize(proc, method_name); end - - def method_name(); end -end - -class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError -end - -class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError -end - -class RSpec::Expectations::BlockSnippetExtractor::BlockLocator - def beginning_line_number(); end - - def beginning_line_number=(_); end - - def body_content_locations(); end - - def method_call_location(); end - - def method_name(); end - - def method_name=(_); end - - def source(); end - - def source=(_); end -end - -class RSpec::Expectations::BlockSnippetExtractor::BlockLocator - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor - def beginning_line_number(); end - - def beginning_line_number=(_); end - - def body_tokens(); end - - def method_name(); end - - def method_name=(_); end - - def source(); end - - def source=(_); end - - def state(); end -end - -class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Expectations::BlockSnippetExtractor::Error -end - -class RSpec::Expectations::BlockSnippetExtractor::Error -end - -class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError -end - -class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError -end - -class RSpec::Expectations::BlockSnippetExtractor - def self.try_extracting_single_line_body_of(proc, method_name); end -end - -class RSpec::Expectations::Configuration - def add_should_and_should_not_to(*modules); end - - def backtrace_formatter(); end - - def backtrace_formatter=(backtrace_formatter); end - - def color?(); end - - def false_positives_handler(); end - - def include_chain_clauses_in_custom_matcher_descriptions=(include_chain_clauses_in_custom_matcher_descriptions); end - - def include_chain_clauses_in_custom_matcher_descriptions?(); end - - def max_formatted_output_length=(length); end - - def on_potential_false_positives(); end - - def on_potential_false_positives=(behavior); end - - def reset_syntaxes_to_default(); end - - def syntax(); end - - def syntax=(values); end - - def warn_about_potential_false_positives=(boolean); end - - def warn_about_potential_false_positives?(); end - FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped) -end - -module RSpec::Expectations::Configuration::NullBacktraceFormatter -end - -module RSpec::Expectations::Configuration::NullBacktraceFormatter - def self.format_backtrace(backtrace); end -end - -class RSpec::Expectations::Configuration -end - -module RSpec::Expectations::ExpectationHelper -end - -module RSpec::Expectations::ExpectationHelper - def self.check_message(msg); end - - def self.handle_failure(matcher, message, failure_message_method); end - - def self.modern_matcher_from(matcher); end - - def self.with_matcher(handler, matcher, message); end -end - -class RSpec::Expectations::ExpectationNotMetError -end - -class RSpec::Expectations::ExpectationNotMetError -end - -class RSpec::Expectations::ExpectationTarget - include ::RSpec::Expectations::ExpectationTarget::InstanceMethods - def initialize(value); end - - def target(); end -end - -module RSpec::Expectations::ExpectationTarget::InstanceMethods - def not_to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def to_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end -end - -module RSpec::Expectations::ExpectationTarget::InstanceMethods -end - -module RSpec::Expectations::ExpectationTarget::UndefinedValue -end - -module RSpec::Expectations::ExpectationTarget::UndefinedValue -end - -class RSpec::Expectations::ExpectationTarget - def self.for(value, block); end -end - -class RSpec::Expectations::FailureAggregator - def aggregate(); end - - def block_label(); end - - def call(failure, options); end - - def failures(); end - - def initialize(block_label, metadata); end - - def metadata(); end - - def other_errors(); end -end - -class RSpec::Expectations::FailureAggregator -end - -RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter - -class RSpec::Expectations::LegacyMatcherAdapter - def initialize(matcher); end -end - -class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 - def failure_message(); end - - def failure_message_when_negated(); end -end - -class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 - def self.interface_matches?(matcher); end -end - -class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 - def failure_message(); end - - def failure_message_when_negated(); end -end - -class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 - def self.interface_matches?(matcher); end -end - -class RSpec::Expectations::LegacyMatcherAdapter - def self.wrap(matcher); end end class RSpec::Expectations::MultipleExpectationsNotMetError include ::RSpec::Core::MultipleExceptionError::InterfaceTag - def aggregation_block_label(); end - - def aggregation_metadata(); end - - def all_exceptions(); end - - def exception_count_description(); end - - def failures(); end - - def initialize(failure_aggregator); end - - def other_errors(); end - - def summary(); end -end - -class RSpec::Expectations::MultipleExpectationsNotMetError -end - -class RSpec::Expectations::NegativeExpectationHandler -end - -class RSpec::Expectations::NegativeExpectationHandler - def self.does_not_match?(matcher, actual, &block); end - - def self.handle_matcher(actual, initial_matcher, message=T.unsafe(nil), &block); end - - def self.opposite_should_method(); end - - def self.should_method(); end - - def self.verb(); end -end - -class RSpec::Expectations::PositiveExpectationHandler -end - -class RSpec::Expectations::PositiveExpectationHandler - def self.handle_matcher(actual, initial_matcher, message=T.unsafe(nil), &block); end - - def self.opposite_should_method(); end - - def self.should_method(); end - - def self.verb(); end -end - -module RSpec::Expectations::Syntax -end - -module RSpec::Expectations::Syntax - def self.default_should_host(); end - - def self.disable_expect(syntax_host=T.unsafe(nil)); end - - def self.disable_should(syntax_host=T.unsafe(nil)); end - - def self.enable_expect(syntax_host=T.unsafe(nil)); end - - def self.enable_should(syntax_host=T.unsafe(nil)); end - - def self.expect_enabled?(syntax_host=T.unsafe(nil)); end - - def self.should_enabled?(syntax_host=T.unsafe(nil)); end - - def self.warn_about_should!(); end - - def self.warn_about_should_unless_configured(method_name); end -end - -module RSpec::Expectations::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Expectations::Version -end - -module RSpec::Expectations - def self.configuration(); end - - def self.differ(); end - - def self.fail_with(message, expected=T.unsafe(nil), actual=T.unsafe(nil)); end end module RSpec::Its @@ -31749,2939 +18877,12 @@ end module RSpec::Its end -module RSpec::Matchers - def a_block_changing(*args, &block); end - - def a_block_outputting(*args, &block); end - - def a_block_raising(*args, &block); end - - def a_block_throwing(*args, &block); end - - def a_block_yielding_control(*args, &block); end - - def a_block_yielding_successive_args(*args, &block); end - - def a_block_yielding_with_args(*args, &block); end - - def a_block_yielding_with_no_args(*args, &block); end - - def a_collection_containing_exactly(*args, &block); end - - def a_collection_ending_with(*args, &block); end - - def a_collection_including(*args, &block); end - - def a_collection_starting_with(*args, &block); end - - def a_falsey_value(*args, &block); end - - def a_falsy_value(*args, &block); end - - def a_hash_including(*args, &block); end - - def a_kind_of(*args, &block); end - - def a_nil_value(*args, &block); end - - def a_range_covering(*args, &block); end - - def a_string_ending_with(*args, &block); end - - def a_string_including(*args, &block); end - - def a_string_matching(*args, &block); end - - def a_string_starting_with(*args, &block); end - - def a_truthy_value(*args, &block); end - - def a_value(*args, &block); end - - def a_value_between(*args, &block); end - - def a_value_within(*args, &block); end - - def aggregate_failures(label=T.unsafe(nil), metadata=T.unsafe(nil), &block); end - - def all(expected); end - - def an_instance_of(*args, &block); end - - def an_object_eq_to(*args, &block); end - - def an_object_eql_to(*args, &block); end - - def an_object_equal_to(*args, &block); end - - def an_object_existing(*args, &block); end - - def an_object_having_attributes(*args, &block); end - - def an_object_matching(*args, &block); end - - def an_object_responding_to(*args, &block); end - - def an_object_satisfying(*args, &block); end - - def be(*args); end - - def be_a(klass); end - - def be_a_kind_of(expected); end - - def be_an(klass); end - - def be_an_instance_of(expected); end - - def be_between(min, max); end - - def be_falsey(); end - - def be_falsy(*args, &block); end - - def be_instance_of(expected); end - - def be_kind_of(expected); end - - def be_nil(); end - - def be_truthy(); end - - def be_within(delta); end - - def change(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def changing(*args, &block); end - - def contain_exactly(*items); end - - def containing_exactly(*args, &block); end - - def cover(*values); end - - def covering(*args, &block); end - - def end_with(*expected); end - - def ending_with(*args, &block); end - - def eq(expected); end - - def eq_to(*args, &block); end - - def eql(expected); end - - def eql_to(*args, &block); end - - def equal(expected); end - - def equal_to(*args, &block); end - - def exist(*args); end - - def existing(*args, &block); end - - def expect(value=T.unsafe(nil), &block); end - - def have_attributes(expected); end - - def having_attributes(*args, &block); end - - def include(*expected); end - - def including(*args, &block); end - - def match(expected); end - - def match_array(items); end - - def match_regex(*args, &block); end - - def matching(*args, &block); end - - def output(expected=T.unsafe(nil)); end - - def raise_error(error=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def raise_exception(error=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def raising(*args, &block); end - - def respond_to(*names); end - - def responding_to(*args, &block); end - - def satisfy(description=T.unsafe(nil), &block); end - - def satisfying(*args, &block); end - - def start_with(*expected); end - - def starting_with(*args, &block); end - - def throw_symbol(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end - - def throwing(*args, &block); end - - def within(*args, &block); end - - def yield_control(); end - - def yield_successive_args(*args); end - - def yield_with_args(*args); end - - def yield_with_no_args(); end - - def yielding_control(*args, &block); end - - def yielding_successive_args(*args, &block); end - - def yielding_with_args(*args, &block); end - - def yielding_with_no_args(*args, &block); end - BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped) - DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped) - HAS_REGEX = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::AliasedMatcher - def description(); end - - def failure_message(); end - - def failure_message_when_negated(); end - - def initialize(base_matcher, description_block); end - - def method_missing(*_); end -end - -class RSpec::Matchers::AliasedMatcher -end - -class RSpec::Matchers::AliasedMatcherWithOperatorSupport -end - -class RSpec::Matchers::AliasedMatcherWithOperatorSupport -end - -class RSpec::Matchers::AliasedNegatedMatcher - def does_not_match?(*args, &block); end - - def matches?(*args, &block); end -end - -RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - -class RSpec::Matchers::AliasedNegatedMatcher -end - -module RSpec::Matchers::BuiltIn -end - -class RSpec::Matchers::BuiltIn::All - def does_not_match?(_actual); end - - def failed_objects(); end - - def initialize(matcher); end - - def matcher(); end -end - -class RSpec::Matchers::BuiltIn::All -end - -class RSpec::Matchers::BuiltIn::BaseMatcher - include ::RSpec::Matchers::Composable - include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting - include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - def actual(); end - - def actual_formatted(); end - - def description(); end - - def diffable?(); end - - def expected(); end - - def expected_formatted(); end - - def expects_call_stack_jump?(); end - - def initialize(expected=T.unsafe(nil)); end - - def match_unless_raises(*exceptions); end - - def matcher_name(); end - - def matcher_name=(matcher_name); end - - def matches?(actual); end - - def present_ivars(); end - - def rescued_exception(); end - - def supports_block_expectations?(); end - UNDEFINED = ::T.let(nil, ::T.untyped) -end - -module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - def failure_message(); end - - def failure_message_when_negated(); end -end - -module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - def self.has_default_failure_messages?(matcher); end -end - -module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting -end - -module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting - def self.improve_hash_formatting(inspect_string); end -end - -class RSpec::Matchers::BuiltIn::BaseMatcher - def self.matcher_name(); end -end - -class RSpec::Matchers::BuiltIn::Be - include ::RSpec::Matchers::BuiltIn::BeHelpers - def <(operand); end - - def <=(operand); end - - def ==(operand); end - - def ===(operand); end - - def =~(operand); end - - def >(operand); end - - def >=(operand); end - - def initialize(*args); end -end - -class RSpec::Matchers::BuiltIn::Be -end - -class RSpec::Matchers::BuiltIn::BeAKindOf -end - -class RSpec::Matchers::BuiltIn::BeAKindOf -end - -class RSpec::Matchers::BuiltIn::BeAnInstanceOf -end - -class RSpec::Matchers::BuiltIn::BeAnInstanceOf -end - -class RSpec::Matchers::BuiltIn::BeBetween - def exclusive(); end - - def inclusive(); end - - def initialize(min, max); end -end - -class RSpec::Matchers::BuiltIn::BeBetween -end - -class RSpec::Matchers::BuiltIn::BeComparedTo - include ::RSpec::Matchers::BuiltIn::BeHelpers - def initialize(operand, operator); end -end - -class RSpec::Matchers::BuiltIn::BeComparedTo -end - -class RSpec::Matchers::BuiltIn::BeFalsey -end - -class RSpec::Matchers::BuiltIn::BeFalsey -end - -module RSpec::Matchers::BuiltIn::BeHelpers -end - -module RSpec::Matchers::BuiltIn::BeHelpers -end - -class RSpec::Matchers::BuiltIn::BeNil -end - -class RSpec::Matchers::BuiltIn::BeNil -end - -class RSpec::Matchers::BuiltIn::BePredicate - include ::RSpec::Matchers::BuiltIn::BeHelpers - def does_not_match?(actual, &block); end - - def initialize(*args, &block); end - - def matches?(actual, &block); end -end - -class RSpec::Matchers::BuiltIn::BePredicate -end - -class RSpec::Matchers::BuiltIn::BeTruthy -end - -class RSpec::Matchers::BuiltIn::BeTruthy -end - -class RSpec::Matchers::BuiltIn::BeWithin - def initialize(delta); end - - def of(expected); end - - def percent_of(expected); end -end - -class RSpec::Matchers::BuiltIn::BeWithin -end - -module RSpec::Matchers::BuiltIn::CaptureStderr -end - -module RSpec::Matchers::BuiltIn::CaptureStderr - def self.capture(block); end -end - -module RSpec::Matchers::BuiltIn::CaptureStdout -end - -module RSpec::Matchers::BuiltIn::CaptureStdout - def self.capture(block); end -end - -class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile - def capture(block); end -end - -class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile -end - -class RSpec::Matchers::BuiltIn::Change - def by(expected_delta); end - - def by_at_least(minimum); end - - def by_at_most(maximum); end - - def does_not_match?(event_proc); end - - def from(value); end - - def initialize(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def matches?(event_proc); end - - def to(value); end -end - -class RSpec::Matchers::BuiltIn::Change -end - -class RSpec::Matchers::BuiltIn::ChangeDetails - def actual_after(); end - - def actual_delta(); end - - def changed?(); end - - def initialize(matcher_name, receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def perform_change(event_proc); end - - def value_representation(); end -end - -class RSpec::Matchers::BuiltIn::ChangeDetails -end - -class RSpec::Matchers::BuiltIn::ChangeFromValue - def does_not_match?(event_proc); end - - def initialize(change_details, expected_before); end - - def to(value); end -end - -class RSpec::Matchers::BuiltIn::ChangeFromValue -end - -class RSpec::Matchers::BuiltIn::ChangeRelatively - def does_not_match?(_event_proc); end - - def initialize(change_details, expected_delta, relativity, &comparer); end - - def matches?(event_proc); end -end - -class RSpec::Matchers::BuiltIn::ChangeRelatively -end - -class RSpec::Matchers::BuiltIn::ChangeToValue - def does_not_match?(_event_proc); end - - def from(value); end - - def initialize(change_details, expected_after); end -end - -class RSpec::Matchers::BuiltIn::ChangeToValue -end - -class RSpec::Matchers::BuiltIn::Compound - def diffable_matcher_list(); end - - def does_not_match?(_actual); end - - def evaluator(); end - - def initialize(matcher_1, matcher_2); end - - def matcher_1(); end - - def matcher_2(); end -end - -class RSpec::Matchers::BuiltIn::Compound::And -end - -class RSpec::Matchers::BuiltIn::Compound::And -end - -class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator - def initialize(actual, matcher_1, matcher_2); end - - def matcher_matches?(matcher); end -end - -class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator - def self.matcher_expects_call_stack_jump?(matcher); end -end - -class RSpec::Matchers::BuiltIn::Compound::Or -end - -class RSpec::Matchers::BuiltIn::Compound::Or -end - -class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator - def initialize(actual, *_); end - - def matcher_matches?(matcher); end -end - -class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator -end - -class RSpec::Matchers::BuiltIn::Compound -end - -class RSpec::Matchers::BuiltIn::ContainExactly -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer - def actual_to_expected_matched_indexes(); end - - def expected_to_actual_matched_indexes(); end - - def find_best_solution(); end - - def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end - - def solution(); end -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution - def self.worse_than?(_other); end -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution - def +(derived_candidate_solution); end - - def candidate?(); end - - def ideal?(); end - - def indeterminate_actual_indexes(); end - - def indeterminate_actual_indexes=(_); end - - def indeterminate_expected_indexes(); end - - def indeterminate_expected_indexes=(_); end - - def unmatched_actual_indexes(); end - - def unmatched_actual_indexes=(_); end - - def unmatched_expected_indexes(); end - - def unmatched_expected_indexes=(_); end - - def unmatched_item_count(); end - - def worse_than?(other); end -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer -end - -class RSpec::Matchers::BuiltIn::ContainExactly -end - -class RSpec::Matchers::BuiltIn::Cover - def does_not_match?(range); end - - def initialize(*expected); end - - def matches?(range); end -end - -class RSpec::Matchers::BuiltIn::Cover -end - -class RSpec::Matchers::BuiltIn::EndWith -end - -class RSpec::Matchers::BuiltIn::EndWith -end - -class RSpec::Matchers::BuiltIn::Eq -end - -class RSpec::Matchers::BuiltIn::Eq -end - -class RSpec::Matchers::BuiltIn::Eql -end - -class RSpec::Matchers::BuiltIn::Eql -end - -class RSpec::Matchers::BuiltIn::Equal - LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::BuiltIn::Equal -end - -class RSpec::Matchers::BuiltIn::Exist - def does_not_match?(actual); end - - def initialize(*expected); end -end - -class RSpec::Matchers::BuiltIn::Exist::ExistenceTest - def actual_exists?(); end - - def valid_test?(); end - - def validity_message(); end -end - -class RSpec::Matchers::BuiltIn::Exist::ExistenceTest -end - -class RSpec::Matchers::BuiltIn::Exist -end - -class RSpec::Matchers::BuiltIn::Has - def does_not_match?(actual, &block); end - - def initialize(method_name, *args, &block); end - - def matches?(actual, &block); end -end - -class RSpec::Matchers::BuiltIn::Has -end - -class RSpec::Matchers::BuiltIn::HaveAttributes - def does_not_match?(actual); end - - def initialize(expected); end - - def respond_to_failed(); end -end - -class RSpec::Matchers::BuiltIn::HaveAttributes -end - -class RSpec::Matchers::BuiltIn::Include - def does_not_match?(actual); end - - def expecteds(); end - - def initialize(*expecteds); end -end - -class RSpec::Matchers::BuiltIn::Include -end - -class RSpec::Matchers::BuiltIn::Match - def initialize(expected); end - - def with_captures(*captures); end -end - -class RSpec::Matchers::BuiltIn::Match -end - -class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher - def __delegate_operator(actual, operator, expected); end -end - -class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher -end - -module RSpec::Matchers::BuiltIn::NullCapture -end - -module RSpec::Matchers::BuiltIn::NullCapture - def self.capture(_block); end -end - -class RSpec::Matchers::BuiltIn::OperatorMatcher - def !=(_expected); end - - def !~(_expected); end - - def <(expected); end - - def <=(expected); end - - def ==(expected); end - - def ===(expected); end - - def =~(expected); end - - def >(expected); end - - def >=(expected); end - - def description(); end - - def fail_with_message(message); end - - def initialize(actual); end -end - -class RSpec::Matchers::BuiltIn::OperatorMatcher - def self.get(klass, operator); end - - def self.register(klass, operator, matcher); end - - def self.registry(); end - - def self.unregister(klass, operator); end - - def self.use_custom_matcher_or_delegate(operator); end -end - -class RSpec::Matchers::BuiltIn::Output - def does_not_match?(block); end - - def initialize(expected); end - - def matches?(block); end - - def to_stderr(); end - - def to_stderr_from_any_process(); end - - def to_stdout(); end - - def to_stdout_from_any_process(); end -end - -class RSpec::Matchers::BuiltIn::Output -end - -class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher - def __delegate_operator(actual, operator, expected); end -end - -class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher -end - -class RSpec::Matchers::BuiltIn::RaiseError - include ::RSpec::Matchers::Composable - def description(); end - - def does_not_match?(given_proc); end - - def expects_call_stack_jump?(); end - - def failure_message(); end - - def failure_message_when_negated(); end - - def initialize(expected_error_or_message=T.unsafe(nil), expected_message=T.unsafe(nil), &block); end - - def matches?(given_proc, negative_expectation=T.unsafe(nil), &block); end - - def supports_block_expectations?(); end - - def with_message(expected_message); end -end - -class RSpec::Matchers::BuiltIn::RaiseError -end - -class RSpec::Matchers::BuiltIn::ReliableMatchData - def captures(); end - - def initialize(match_data); end - - def match_data(); end - - def names(); end -end - -class RSpec::Matchers::BuiltIn::ReliableMatchData -end - -class RSpec::Matchers::BuiltIn::RespondTo - def and_any_keywords(); end - - def and_keywords(*keywords); end - - def and_unlimited_arguments(); end - - def argument(); end - - def arguments(); end - - def does_not_match?(actual); end - - def ignoring_method_signature_failure!(); end - - def initialize(*names); end - - def with(n); end - - def with_any_keywords(); end - - def with_keywords(*keywords); end - - def with_unlimited_arguments(); end -end - -class RSpec::Matchers::BuiltIn::RespondTo -end - -class RSpec::Matchers::BuiltIn::Satisfy - def initialize(description=T.unsafe(nil), &block); end - - def matches?(actual, &block); end -end - -class RSpec::Matchers::BuiltIn::Satisfy -end - -class RSpec::Matchers::BuiltIn::SpecificValuesChange - def initialize(change_details, from, to); end - - def matches?(event_proc); end -end - -RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject - -class RSpec::Matchers::BuiltIn::SpecificValuesChange -end - -RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith - -class RSpec::Matchers::BuiltIn::StartOrEndWith - def initialize(*expected); end -end - -class RSpec::Matchers::BuiltIn::StartOrEndWith -end - -class RSpec::Matchers::BuiltIn::StartWith -end - -class RSpec::Matchers::BuiltIn::StartWith -end - -class RSpec::Matchers::BuiltIn::ThrowSymbol - include ::RSpec::Matchers::Composable - def description(); end - - def does_not_match?(given_proc); end - - def expects_call_stack_jump?(); end - - def failure_message(); end - - def failure_message_when_negated(); end - - def initialize(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end - - def matches?(given_proc); end - - def supports_block_expectations?(); end -end - -class RSpec::Matchers::BuiltIn::ThrowSymbol -end - -class RSpec::Matchers::BuiltIn::YieldControl - def at_least(number); end - - def at_most(number); end - - def does_not_match?(block); end - - def exactly(number); end - - def initialize(); end - - def matches?(block); end - - def once(); end - - def thrice(); end - - def times(); end - - def twice(); end -end - -class RSpec::Matchers::BuiltIn::YieldControl -end - -class RSpec::Matchers::BuiltIn::YieldProbe - def assert_used!(); end - - def assert_valid_expect_block!(); end - - def has_block?(); end - - def initialize(block, &callback); end - - def num_yields(); end - - def num_yields=(num_yields); end - - def probe(); end - - def single_yield_args(); end - - def to_proc(); end - - def yielded_args(); end - - def yielded_args=(yielded_args); end - - def yielded_once?(matcher_name); end -end - -class RSpec::Matchers::BuiltIn::YieldProbe - def self.probe(block, &callback); end -end - -class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs - def does_not_match?(block); end - - def initialize(*args); end - - def matches?(block); end -end - -class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs -end - -class RSpec::Matchers::BuiltIn::YieldWithArgs - def does_not_match?(block); end - - def initialize(*args); end - - def matches?(block); end -end - -class RSpec::Matchers::BuiltIn::YieldWithArgs -end - -class RSpec::Matchers::BuiltIn::YieldWithNoArgs - def does_not_match?(block); end - - def matches?(block); end -end - -class RSpec::Matchers::BuiltIn::YieldWithNoArgs -end - -module RSpec::Matchers::BuiltIn -end - -module RSpec::Matchers::Composable - def &(matcher); end - - def ===(value); end - - def and(matcher); end - - def or(matcher); end - - def |(matcher); end -end - -module RSpec::Matchers::Composable - def self.should_enumerate?(item); end - - def self.surface_descriptions_in(item); end - - def self.unreadable_io?(object); end -end - -module RSpec::Matchers::DSL - def alias_matcher(new_name, old_name, options=T.unsafe(nil), &description_override); end - - def define(name, &declarations); end - - def define_negated_matcher(negated_name, base_name, &description_override); end - - def matcher(name, &declarations); end -end - -module RSpec::Matchers::DSL::DefaultImplementations - include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - def description(); end - - def diffable?(); end - - def expects_call_stack_jump?(); end - - def supports_block_expectations?(); end -end - -module RSpec::Matchers::DSL::DefaultImplementations -end - -module RSpec::Matchers::DSL::Macros - def chain(method_name, *attr_names, &definition); end - - def description(&definition); end - - def diffable(); end - - def failure_message(&definition); end - - def failure_message_when_negated(&definition); end - - def match(options=T.unsafe(nil), &match_block); end - - def match_unless_raises(expected_exception=T.unsafe(nil), &match_block); end - - def match_when_negated(options=T.unsafe(nil), &match_block); end - - def supports_block_expectations(); end - RAISE_NOTIFIER = ::T.let(nil, ::T.untyped) -end - -module RSpec::Matchers::DSL::Macros::Deprecated - def failure_message_for_should(&definition); end - - def failure_message_for_should_not(&definition); end - - def match_for_should(&definition); end - - def match_for_should_not(&definition); end -end - -module RSpec::Matchers::DSL::Macros::Deprecated -end - -module RSpec::Matchers::DSL::Macros -end - -class RSpec::Matchers::DSL::Matcher - include ::RSpec::Matchers::DSL::DefaultImplementations - include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - include ::RSpec::Matchers - include ::RSpec::Matchers::Composable - def actual(); end - - def block_arg(); end - - def expected(); end - - def expected_as_array(); end - - def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end - - def name(); end - - def rescued_exception(); end -end - -class RSpec::Matchers::DSL::Matcher - extend ::RSpec::Matchers::DSL::Macros - extend ::RSpec::Matchers::DSL::Macros::Deprecated -end - -module RSpec::Matchers::DSL -end - -module RSpec::Matchers::EnglishPhrasing -end - -module RSpec::Matchers::EnglishPhrasing - def self.list(obj); end - - def self.split_words(sym); end -end - -class RSpec::Matchers::ExpectedsForMultipleDiffs - def initialize(expected_list); end - - def message_with_diff(message, differ, actual); end - DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped) - DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::ExpectedsForMultipleDiffs - def self.for_many_matchers(matchers); end - - def self.from(expected); end -end - -class RSpec::Matchers::MatcherDelegator - include ::RSpec::Matchers::Composable - def base_matcher(); end - - def initialize(base_matcher); end - - def method_missing(*args, &block); end -end - -class RSpec::Matchers::MatcherDelegator -end - -module RSpec::Matchers - extend ::RSpec::Matchers::DSL - def self.alias_matcher(*args, &block); end - - def self.clear_generated_description(); end - - def self.configuration(); end - - def self.generated_description(); end - - def self.is_a_describable_matcher?(obj); end - - def self.is_a_matcher?(obj); end - - def self.last_description(); end - - def self.last_expectation_handler(); end - - def self.last_expectation_handler=(last_expectation_handler); end - - def self.last_matcher(); end - - def self.last_matcher=(last_matcher); end -end - -module RSpec::Mocks - DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped) - IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::AllowanceTarget - def expression(); end - - def not_to(matcher, *_args); end - - def to(matcher, &block); end - - def to_not(matcher, *_args); end -end - -class RSpec::Mocks::AllowanceTarget -end - -class RSpec::Mocks::AndReturnImplementation - def call(*_args_to_ignore, &_block); end - - def initialize(values_to_return); end -end - -class RSpec::Mocks::AndReturnImplementation -end - -class RSpec::Mocks::AndWrapOriginalImplementation - def call(*args, &block); end - - def initial_action=(_value); end - - def initialize(method, block); end - - def inner_action(); end - - def inner_action=(_value); end - - def terminal_action=(_value); end -end - -class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError -end - -class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError -end - -class RSpec::Mocks::AndWrapOriginalImplementation -end - -class RSpec::Mocks::AndYieldImplementation - def call(*_args_to_ignore, &block); end - - def initialize(args_to_yield, eval_context, error_generator); end -end - -class RSpec::Mocks::AndYieldImplementation -end - -module RSpec::Mocks::AnyInstance -end - -class RSpec::Mocks::AnyInstance::Chain - include ::RSpec::Mocks::AnyInstance::Chain::Customizations - def constrained_to_any_of?(*constraints); end - - def expectation_fulfilled!(); end - - def initialize(recorder, *args, &block); end - - def matches_args?(*args); end - - def never(); end - - def playback!(instance); end -end - -module RSpec::Mocks::AnyInstance::Chain::Customizations - def and_call_original(*args, &block); end - - def and_raise(*args, &block); end - - def and_return(*args, &block); end - - def and_throw(*args, &block); end - - def and_wrap_original(*args, &block); end - - def and_yield(*args, &block); end - - def at_least(*args, &block); end - - def at_most(*args, &block); end - - def exactly(*args, &block); end - - def never(*args, &block); end - - def once(*args, &block); end - - def thrice(*args, &block); end - - def time(*args, &block); end - - def times(*args, &block); end - - def twice(*args, &block); end - - def with(*args, &block); end -end - -module RSpec::Mocks::AnyInstance::Chain::Customizations - def self.record(method_name); end -end - -class RSpec::Mocks::AnyInstance::Chain -end - -class RSpec::Mocks::AnyInstance::ErrorGenerator - def raise_does_not_implement_error(klass, method_name); end - - def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end - - def raise_not_supported_with_prepend_error(method_name, problem_mod); end - - def raise_second_instance_received_message_error(unfulfilled_expectations); end -end - -class RSpec::Mocks::AnyInstance::ErrorGenerator -end - -class RSpec::Mocks::AnyInstance::ExpectChainChain - def initialize(*args); end -end - -class RSpec::Mocks::AnyInstance::ExpectChainChain -end - -class RSpec::Mocks::AnyInstance::ExpectationChain - def expectation_fulfilled?(); end - - def initialize(*args, &block); end -end - -class RSpec::Mocks::AnyInstance::ExpectationChain -end - -class RSpec::Mocks::AnyInstance::FluentInterfaceProxy - def initialize(targets); end - - def method_missing(*args, &block); end -end - -class RSpec::Mocks::AnyInstance::FluentInterfaceProxy -end - -class RSpec::Mocks::AnyInstance::MessageChains - def [](method_name); end - - def add(method_name, chain); end - - def all_expectations_fulfilled?(); end - - def each_unfulfilled_expectation_matching(method_name, *args); end - - def has_expectation?(method_name); end - - def playback!(instance, method_name); end - - def received_expected_message!(method_name); end - - def remove_stub_chains_for!(method_name); end - - def unfulfilled_expectations(); end -end - -class RSpec::Mocks::AnyInstance::MessageChains -end - -class RSpec::Mocks::AnyInstance::PositiveExpectationChain - ExpectationInvocationOrder = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::AnyInstance::PositiveExpectationChain -end - -class RSpec::Mocks::AnyInstance::Proxy - def expect_chain(*chain, &block); end - - def initialize(recorder, target_proxies); end - - def klass(); end - - def should_not_receive(method_name, &block); end - - def should_receive(method_name, &block); end - - def stub(method_name_or_method_map, &block); end - - def stub_chain(*chain, &block); end - - def unstub(method_name); end -end - -class RSpec::Mocks::AnyInstance::Proxy -end - class RSpec::Mocks::AnyInstance::Recorder include ::T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions - def already_observing?(method_name); end - - def build_alias_method_name(method_name); end - - def expect_chain(*method_names_and_optional_return_values, &block); end - - def initialize(klass); end - - def instance_that_received(method_name); end - - def klass(); end - - def message_chains(); end - - def notify_received_message(_object, message, args, _blk); end - - def playback!(instance, method_name); end - - def should_not_receive(method_name, &block); end - - def should_receive(method_name, &block); end - - def stop_all_observation!(); end - - def stop_observing!(method_name); end - - def stub(method_name, &block); end - - def stub_chain(*method_names_and_optional_return_values, &block); end - - def stubs(); end - - def unstub(method_name); end - - def verify(); end -end - -class RSpec::Mocks::AnyInstance::Recorder -end - -class RSpec::Mocks::AnyInstance::StubChain - def expectation_fulfilled?(); end - EmptyInvocationOrder = ::T.let(nil, ::T.untyped) - InvocationOrder = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::AnyInstance::StubChain -end - -class RSpec::Mocks::AnyInstance::StubChainChain - def initialize(*args); end -end - -class RSpec::Mocks::AnyInstance::StubChainChain -end - -module RSpec::Mocks::AnyInstance - def self.error_generator(); end -end - -class RSpec::Mocks::AnyInstanceAllowanceTarget - def expression(); end - - def not_to(matcher, *_args); end - - def to(matcher, &block); end - - def to_not(matcher, *_args); end -end - -class RSpec::Mocks::AnyInstanceAllowanceTarget -end - -class RSpec::Mocks::AnyInstanceExpectationTarget - def expression(); end - - def not_to(matcher, &block); end - - def to(matcher, &block); end - - def to_not(matcher, &block); end -end - -class RSpec::Mocks::AnyInstanceExpectationTarget -end - -class RSpec::Mocks::ArgumentListMatcher - def args_match?(*args); end - - def expected_args(); end - - def initialize(*expected_args); end - - def resolve_expected_args_based_on(actual_args); end - MATCH_ALL = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentListMatcher -end - -module RSpec::Mocks::ArgumentMatchers - def a_kind_of(klass); end - - def an_instance_of(klass); end - - def any_args(); end - - def anything(); end - - def array_including(*args); end - - def boolean(); end - - def duck_type(*args); end - - def hash_excluding(*args); end - - def hash_including(*args); end - - def hash_not_including(*args); end - - def instance_of(klass); end - - def kind_of(klass); end - - def no_args(); end -end - -module RSpec::Mocks::ArgumentMatchers - def self.anythingize_lonely_keys(*args); end -end - -class RSpec::Mocks::CallbackInvocationStrategy - def call(doubled_module); end -end - -class RSpec::Mocks::CallbackInvocationStrategy -end - -class RSpec::Mocks::CannotSupportArgMutationsError -end - -class RSpec::Mocks::CannotSupportArgMutationsError -end - -class RSpec::Mocks::ClassNewMethodReference -end - -class RSpec::Mocks::ClassNewMethodReference - def self.applies_to?(method_name); end -end - -class RSpec::Mocks::ClassVerifyingDouble - include ::RSpec::Mocks::ObjectVerifyingDoubleMethods - include ::RSpec::Mocks::TestDouble - include ::RSpec::Mocks::VerifyingDouble -end - -class RSpec::Mocks::ClassVerifyingDouble -end - -class RSpec::Mocks::Configuration - def add_stub_and_should_receive_to(*modules); end - - def allow_message_expectations_on_nil(); end - - def allow_message_expectations_on_nil=(allow_message_expectations_on_nil); end - - def before_verifying_doubles(&block); end - - def color?(); end - - def patch_marshal_to_support_partial_doubles=(val); end - - def reset_syntaxes_to_default(); end - - def syntax(); end - - def syntax=(*values); end - - def temporarily_suppress_partial_double_verification(); end - - def temporarily_suppress_partial_double_verification=(temporarily_suppress_partial_double_verification); end - - def transfer_nested_constants=(transfer_nested_constants); end - - def transfer_nested_constants?(); end - - def verify_doubled_constant_names=(verify_doubled_constant_names); end - - def verify_doubled_constant_names?(); end - - def verify_partial_doubles=(val); end - - def verify_partial_doubles?(); end - - def verifying_double_callbacks(); end - - def when_declaring_verifying_double(&block); end - - def yield_receiver_to_any_instance_implementation_blocks=(yield_receiver_to_any_instance_implementation_blocks); end - - def yield_receiver_to_any_instance_implementation_blocks?(); end -end - -class RSpec::Mocks::Configuration -end - -class RSpec::Mocks::Constant - def hidden=(hidden); end - - def hidden?(); end - - def initialize(name); end - - def mutated?(); end - - def name(); end - - def original_value(); end - - def original_value=(original_value); end - - def previously_defined=(previously_defined); end - - def previously_defined?(); end - - def stubbed=(stubbed); end - - def stubbed?(); end - - def valid_name=(valid_name); end - - def valid_name?(); end -end - -class RSpec::Mocks::Constant - extend ::RSpec::Support::RecursiveConstMethods - def self.original(name); end - - def self.unmutated(name); end -end - -class RSpec::Mocks::ConstantMutator -end - -class RSpec::Mocks::ConstantMutator::BaseMutator - include ::RSpec::Support::RecursiveConstMethods - def full_constant_name(); end - - def idempotently_reset(); end - - def initialize(full_constant_name, mutated_value, transfer_nested_constants); end - - def original_value(); end - - def to_constant(); end -end - -class RSpec::Mocks::ConstantMutator::BaseMutator -end - -class RSpec::Mocks::ConstantMutator::ConstantHider - def mutate(); end - - def reset(); end -end - -class RSpec::Mocks::ConstantMutator::ConstantHider -end - -class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer - def initialize(*args); end - - def mutate(); end - - def reset(); end - - def should_transfer_nested_constants?(); end - - def transfer_nested_constants(); end - - def verify_constants_to_transfer!(); end -end - -class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer -end - -class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter - def mutate(); end - - def reset(); end -end - -class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter -end - -class RSpec::Mocks::ConstantMutator - extend ::RSpec::Support::RecursiveConstMethods - def self.hide(constant_name); end - - def self.mutate(mutator); end - - def self.raise_on_invalid_const(); end - - def self.stub(constant_name, value, options=T.unsafe(nil)); end -end - -class RSpec::Mocks::DirectObjectReference - def const_to_replace(); end - - def defined?(); end - - def description(); end - - def initialize(object); end - - def target(); end - - def when_loaded(); end -end - -class RSpec::Mocks::DirectObjectReference -end - -class RSpec::Mocks::Double - include ::RSpec::Mocks::TestDouble -end - -class RSpec::Mocks::Double -end - -class RSpec::Mocks::ErrorGenerator - def default_error_message(expectation, expected_args, actual_args); end - - def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end - - def expectation_on_nil_message(method_name); end - - def initialize(target=T.unsafe(nil)); end - - def intro(unwrapped=T.unsafe(nil)); end - - def method_call_args_description(args, generic_prefix=T.unsafe(nil), matcher_prefix=T.unsafe(nil)); end - - def opts(); end - - def opts=(opts); end - - def raise_already_invoked_error(message, calling_customization); end - - def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end - - def raise_double_negation_error(wrapped_expression); end - - def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line=T.unsafe(nil), source_id=T.unsafe(nil)); end - - def raise_expectation_on_mocked_method(method); end - - def raise_expectation_on_nil_error(method_name); end - - def raise_expectation_on_unstubbed_method(method); end - - def raise_expired_test_double_error(); end - - def raise_have_received_disallowed(type, reason); end - - def raise_invalid_arguments_error(verifier); end - - def raise_method_not_stubbed_error(method_name); end - - def raise_missing_block_error(args_to_yield); end - - def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end - - def raise_non_public_error(method_name, visibility); end - - def raise_only_valid_on_a_partial_double(method); end - - def raise_out_of_order_error(message); end - - def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line=T.unsafe(nil)); end - - def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id=T.unsafe(nil)); end - - def raise_unexpected_message_error(message, args); end - - def raise_unimplemented_error(doubled_module, method_name, object); end - - def raise_verifying_double_not_defined_error(ref); end - - def raise_wrong_arity_error(args_to_yield, signature); end -end - -class RSpec::Mocks::ErrorGenerator -end - -module RSpec::Mocks::ExampleMethods - include ::RSpec::Mocks::ArgumentMatchers - def allow(target); end - - def allow_any_instance_of(klass); end - - def allow_message_expectations_on_nil(); end - - def class_double(doubled_class, *args); end - - def class_spy(*args); end - - def double(*args); end - - def expect_any_instance_of(klass); end - - def have_received(method_name, &block); end - - def hide_const(constant_name); end - - def instance_double(doubled_class, *args); end - - def instance_spy(*args); end - - def object_double(object_or_name, *args); end - - def object_spy(*args); end - - def receive(method_name, &block); end - - def receive_message_chain(*messages, &block); end - - def receive_messages(message_return_value_hash); end - - def spy(*args); end - - def stub_const(constant_name, value, options=T.unsafe(nil)); end - - def without_partial_double_verification(); end -end - -module RSpec::Mocks::ExampleMethods::ExpectHost - def expect(target); end -end - -module RSpec::Mocks::ExampleMethods::ExpectHost -end - -module RSpec::Mocks::ExampleMethods - def self.declare_double(type, *args); end - - def self.declare_verifying_double(type, ref, *args); end - - def self.extended(object); end - - def self.included(klass); end -end - -class RSpec::Mocks::ExpectChain -end - -class RSpec::Mocks::ExpectChain - def self.expect_chain_on(object, *chain, &blk); end -end - -class RSpec::Mocks::ExpectationTarget - include ::RSpec::Mocks::ExpectationTargetMethods -end - -class RSpec::Mocks::ExpectationTarget -end - -module RSpec::Mocks::ExpectationTargetMethods - include ::RSpec::Mocks::TargetDelegationInstanceMethods - def expression(); end - - def not_to(matcher, &block); end - - def to(matcher, &block); end - - def to_not(matcher, &block); end -end - -module RSpec::Mocks::ExpectationTargetMethods - extend ::RSpec::Mocks::TargetDelegationClassMethods -end - -class RSpec::Mocks::ExpiredTestDoubleError -end - -class RSpec::Mocks::ExpiredTestDoubleError -end - -class RSpec::Mocks::Implementation - def call(*args, &block); end - - def initial_action(); end - - def initial_action=(initial_action); end - - def inner_action(); end - - def inner_action=(inner_action); end - - def terminal_action(); end - - def terminal_action=(terminal_action); end -end - -class RSpec::Mocks::Implementation -end - -class RSpec::Mocks::InstanceMethodReference -end - -class RSpec::Mocks::InstanceMethodReference -end - -class RSpec::Mocks::InstanceMethodStasher - def handle_restoration_failures(); end - - def initialize(object, method); end - - def method_is_stashed?(); end - - def original_method(); end - - def restore(); end - - def stash(); end -end - -class RSpec::Mocks::InstanceMethodStasher -end - -class RSpec::Mocks::InstanceVerifyingDouble - include ::RSpec::Mocks::TestDouble - include ::RSpec::Mocks::VerifyingDouble -end - -class RSpec::Mocks::InstanceVerifyingDouble -end - -class RSpec::Mocks::MarshalExtension -end - -class RSpec::Mocks::MarshalExtension - def self.patch!(); end - - def self.unpatch!(); end -end - -module RSpec::Mocks::Matchers -end - -class RSpec::Mocks::Matchers::ExpectationCustomization - def block(); end - - def block=(block); end - - def initialize(method_name, args, block); end - - def playback_onto(expectation); end -end - -class RSpec::Mocks::Matchers::ExpectationCustomization -end - -class RSpec::Mocks::Matchers::HaveReceived - include ::RSpec::Mocks::Matchers::Matcher - def at_least(*args); end - - def at_most(*args); end - - def description(); end - - def does_not_match?(subject); end - - def exactly(*args); end - - def failure_message(); end - - def failure_message_when_negated(); end - - def initialize(method_name, &block); end - - def matches?(subject, &block); end - - def name(); end - - def once(*args); end - - def ordered(*args); end - - def setup_allowance(_subject, &_block); end - - def setup_any_instance_allowance(_subject, &_block); end - - def setup_any_instance_expectation(_subject, &_block); end - - def setup_any_instance_negative_expectation(_subject, &_block); end - - def setup_expectation(subject, &block); end - - def setup_negative_expectation(subject, &block); end - - def thrice(*args); end - - def time(*args); end - - def times(*args); end - - def twice(*args); end - - def with(*args); end - ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped) - CONSTRAINTS = ::T.let(nil, ::T.untyped) - COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::Matchers::HaveReceived -end - -module RSpec::Mocks::Matchers::Matcher -end - -module RSpec::Mocks::Matchers::Matcher -end - -class RSpec::Mocks::Matchers::Receive - include ::RSpec::Mocks::Matchers::Matcher - def and_call_original(*args, &block); end - - def and_raise(*args, &block); end - - def and_return(*args, &block); end - - def and_throw(*args, &block); end - - def and_wrap_original(*args, &block); end - - def and_yield(*args, &block); end - - def at_least(*args, &block); end - - def at_most(*args, &block); end - - def description(); end - - def does_not_match?(subject, &block); end - - def exactly(*args, &block); end - - def initialize(message, block); end - - def matches?(subject, &block); end - - def name(); end - - def never(*args, &block); end - - def once(*args, &block); end - - def ordered(*args, &block); end - - def setup_allowance(subject, &block); end - - def setup_any_instance_allowance(subject, &block); end - - def setup_any_instance_expectation(subject, &block); end - - def setup_any_instance_negative_expectation(subject, &block); end - - def setup_expectation(subject, &block); end - - def setup_negative_expectation(subject, &block); end - - def thrice(*args, &block); end - - def time(*args, &block); end - - def times(*args, &block); end - - def twice(*args, &block); end - - def with(*args, &block); end -end - -class RSpec::Mocks::Matchers::Receive::DefaultDescribable - def description_for(verb); end - - def initialize(message); end -end - -class RSpec::Mocks::Matchers::Receive::DefaultDescribable -end - -class RSpec::Mocks::Matchers::Receive -end - -class RSpec::Mocks::Matchers::ReceiveMessageChain - include ::RSpec::Mocks::Matchers::Matcher - def and_call_original(*args, &block); end - - def and_raise(*args, &block); end - - def and_return(*args, &block); end - - def and_throw(*args, &block); end - - def and_yield(*args, &block); end - - def description(); end - - def does_not_match?(*_args); end - - def initialize(chain, &block); end - - def matches?(subject, &block); end - - def name(); end - - def setup_allowance(subject, &block); end - - def setup_any_instance_allowance(subject, &block); end - - def setup_any_instance_expectation(subject, &block); end - - def setup_expectation(subject, &block); end - - def setup_negative_expectation(*_args); end - - def with(*args, &block); end -end - -class RSpec::Mocks::Matchers::ReceiveMessageChain -end - -class RSpec::Mocks::Matchers::ReceiveMessages - include ::RSpec::Mocks::Matchers::Matcher - def description(); end - - def does_not_match?(_subject); end - - def initialize(message_return_value_hash); end - - def matches?(subject); end - - def name(); end - - def setup_allowance(subject); end - - def setup_any_instance_allowance(subject); end - - def setup_any_instance_expectation(subject); end - - def setup_expectation(subject); end - - def setup_negative_expectation(_subject); end - - def warn_about_block(); end -end - -class RSpec::Mocks::Matchers::ReceiveMessages -end - -module RSpec::Mocks::Matchers -end - -class RSpec::Mocks::MessageChain - def block(); end - - def chain(); end - - def initialize(object, *chain, &blk); end - - def object(); end - - def setup_chain(); end -end - -class RSpec::Mocks::MessageChain -end - -class RSpec::Mocks::MessageExpectation - include ::RSpec::Mocks::MessageExpectation::ImplementationDetails - def and_call_original(); end - - def and_raise(*args); end - - def and_return(first_value, *values); end - - def and_throw(*args); end - - def and_wrap_original(&block); end - - def and_yield(*args, &block); end - - def at_least(n, &block); end - - def at_most(n, &block); end - - def exactly(n, &block); end - - def never(); end - - def once(&block); end - - def ordered(&block); end - - def thrice(&block); end - - def time(&block); end - - def times(&block); end - - def twice(&block); end - - def with(*args, &block); end -end - -module RSpec::Mocks::MessageExpectation::ImplementationDetails - def actual_received_count_matters?(); end - - def additional_expected_calls(); end - - def advise(*args); end - - def and_yield_receiver_to_implementation(); end - - def argument_list_matcher=(argument_list_matcher); end - - def called_max_times?(); end - - def description_for(verb); end - - def ensure_expected_ordering_received!(); end - - def error_generator(); end - - def error_generator=(error_generator); end - - def expectation_count_type(); end - - def expected_args(); end - - def expected_from=(expected_from); end - - def expected_messages_received?(); end - - def expected_received_count=(expected_received_count); end - - def generate_error(); end - - def ignoring_args?(); end - - def implementation(); end - - def implementation=(implementation); end - - def increase_actual_received_count!(); end - - def initialize(error_generator, expectation_ordering, expected_from, method_double, type=T.unsafe(nil), opts=T.unsafe(nil), &implementation_block); end - - def invoke(parent_stub, *args, &block); end - - def invoke_without_incrementing_received_count(parent_stub, *args, &block); end - - def matches?(message, *args); end - - def matches_at_least_count?(); end - - def matches_at_most_count?(); end - - def matches_exact_count?(); end - - def matches_name_but_not_args(message, *args); end - - def message(); end - - def negative?(); end - - def negative_expectation_for?(message); end - - def ordered?(); end - - def orig_object(); end - - def raise_out_of_order_error(); end - - def raise_unexpected_message_args_error(args_for_multiple_calls); end - - def safe_invoke(parent_stub, *args, &block); end - - def similar_messages(); end - - def type(); end - - def unadvise(args); end - - def verify_messages_received(); end - - def yield_receiver_to_implementation_block?(); end -end - -module RSpec::Mocks::MessageExpectation::ImplementationDetails -end - -class RSpec::Mocks::MessageExpectation end class RSpec::Mocks::MethodDouble include ::T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions - def add_default_stub(*args, &implementation); end - - def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end - - def add_simple_expectation(method_name, response, error_generator, backtrace_line); end - - def add_simple_stub(method_name, response); end - - def add_stub(error_generator, expectation_ordering, expected_from, opts=T.unsafe(nil), &implementation); end - - def build_expectation(error_generator, expectation_ordering); end - - def clear(); end - - def configure_method(); end - - def define_proxy_method(); end - - def expectations(); end - - def message_expectation_class(); end - - def method_name(); end - - def method_stasher(); end - - def object(); end - - def object_singleton_class(); end - - def original_implementation_callable(); end - - def original_method(); end - - def proxy_method_invoked(_obj, *args, &block); end - - def raise_method_not_stubbed_error(); end - - def remove_stub(); end - - def remove_stub_if_present(); end - - def reset(); end - - def restore_original_method(); end - - def restore_original_visibility(); end - - def save_original_implementation_callable!(); end - - def setup_simple_method_double(method_name, response, collection, error_generator=T.unsafe(nil), backtrace_line=T.unsafe(nil)); end - - def show_frozen_warning(); end - - def stubs(); end - - def verify(); end - - def visibility(); end -end - -class RSpec::Mocks::MethodDouble::RSpecPrependedModule -end - -class RSpec::Mocks::MethodDouble::RSpecPrependedModule -end - -class RSpec::Mocks::MethodDouble -end - -class RSpec::Mocks::MethodReference - def defined?(); end - - def implemented?(); end - - def initialize(object_reference, method_name); end - - def unimplemented?(); end - - def visibility(); end - - def with_signature(); end -end - -class RSpec::Mocks::MethodReference - def self.for(object_reference, method_name); end - - def self.instance_method_visibility_for(klass, method_name); end - - def self.method_defined_at_any_visibility?(klass, method_name); end - - def self.method_visibility_for(object, method_name); end -end - -class RSpec::Mocks::MockExpectationAlreadyInvokedError -end - -class RSpec::Mocks::MockExpectationAlreadyInvokedError -end - -class RSpec::Mocks::MockExpectationError -end - -class RSpec::Mocks::MockExpectationError -end - -class RSpec::Mocks::NamedObjectReference - def const_to_replace(); end - - def defined?(); end - - def description(); end - - def initialize(const_name); end - - def target(); end - - def when_loaded(); end -end - -class RSpec::Mocks::NamedObjectReference -end - -class RSpec::Mocks::NegationUnsupportedError -end - -class RSpec::Mocks::NegationUnsupportedError -end - -class RSpec::Mocks::NestedSpace - def initialize(parent); end -end - -class RSpec::Mocks::NestedSpace -end - -class RSpec::Mocks::NoCallbackInvocationStrategy - def call(_doubled_module); end -end - -class RSpec::Mocks::NoCallbackInvocationStrategy -end - -class RSpec::Mocks::ObjectMethodReference -end - -class RSpec::Mocks::ObjectMethodReference -end - -class RSpec::Mocks::ObjectReference - MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ObjectReference - def self.for(object_module_or_name, allow_direct_object_refs=T.unsafe(nil)); end -end - -class RSpec::Mocks::ObjectVerifyingDouble - include ::RSpec::Mocks::ObjectVerifyingDoubleMethods - include ::RSpec::Mocks::TestDouble - include ::RSpec::Mocks::VerifyingDouble -end - -class RSpec::Mocks::ObjectVerifyingDouble -end - -module RSpec::Mocks::ObjectVerifyingDoubleMethods - include ::RSpec::Mocks::TestDouble - include ::RSpec::Mocks::VerifyingDouble - def as_stubbed_const(options=T.unsafe(nil)); end -end - -module RSpec::Mocks::ObjectVerifyingDoubleMethods -end - -class RSpec::Mocks::OrderGroup - def clear(); end - - def consume(); end - - def empty?(); end - - def handle_order_constraint(expectation); end - - def invoked(message); end - - def ready_for?(expectation); end - - def register(expectation); end - - def verify_invocation_order(expectation); end -end - -class RSpec::Mocks::OrderGroup -end - -class RSpec::Mocks::OutsideOfExampleError -end - -class RSpec::Mocks::OutsideOfExampleError -end - -class RSpec::Mocks::PartialClassDoubleProxy - include ::RSpec::Mocks::PartialClassDoubleProxyMethods -end - -class RSpec::Mocks::PartialClassDoubleProxy -end - -module RSpec::Mocks::PartialClassDoubleProxyMethods - def initialize(source_space, *args); end - - def method_double_from_ancestor_for(message); end - - def original_method_handle_for(message); end - - def original_unbound_method_handle_from_ancestor_for(message); end - - def superclass_proxy(); end -end - -module RSpec::Mocks::PartialClassDoubleProxyMethods -end - -class RSpec::Mocks::PartialDoubleProxy - def original_method_handle_for(message); end - - def visibility_for(method_name); end -end - -class RSpec::Mocks::PartialDoubleProxy -end - -class RSpec::Mocks::Proxy - def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end - - def add_simple_expectation(method_name, response, location); end - - def add_simple_stub(method_name, response); end - - def add_stub(method_name, opts=T.unsafe(nil), &implementation); end - - def build_expectation(method_name); end - - def check_for_unexpected_arguments(expectation); end - - def ensure_implemented(*_args); end - - def has_negative_expectation?(message); end - - def initialize(object, order_group, options=T.unsafe(nil)); end - - def message_received(message, *args, &block); end - - def messages_arg_list(); end - - def method_double_if_exists_for_message(message); end - - def object(); end - - def original_method_handle_for(_message); end - - def prepended_modules_of_singleton_class(); end - - def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end - - def raise_unexpected_message_error(method_name, args); end - - def received_message?(method_name, *args, &block); end - - def record_message_received(message, *args, &block); end - - def remove_stub(method_name); end - - def remove_stub_if_present(method_name); end - - def replay_received_message_on(expectation, &block); end - - def reset(); end - - def verify(); end - - def visibility_for(_method_name); end - DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::Proxy::SpecificMessage - def ==(expectation); end - - def args(); end - - def args=(_); end - - def message(); end - - def message=(_); end - - def object(); end - - def object=(_); end -end - -class RSpec::Mocks::Proxy::SpecificMessage - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Mocks::Proxy - def self.prepended_modules_of(klass); end -end - -class RSpec::Mocks::ProxyForNil - def disallow_expectations(); end - - def disallow_expectations=(disallow_expectations); end - - def initialize(order_group); end - - def warn_about_expectations(); end - - def warn_about_expectations=(warn_about_expectations); end -end - -class RSpec::Mocks::ProxyForNil -end - -class RSpec::Mocks::RootSpace - def any_instance_proxy_for(*_args); end - - def any_instance_recorder_for(*_args); end - - def any_instance_recorders_from_ancestry_of(_object); end - - def new_scope(); end - - def proxy_for(*_args); end - - def register_constant_mutator(_mutator); end - - def registered?(_object); end - - def reset_all(); end - - def superclass_proxy_for(*_args); end - - def verify_all(); end -end - -class RSpec::Mocks::RootSpace -end - -class RSpec::Mocks::SimpleMessageExpectation - def called_max_times?(); end - - def initialize(message, response, error_generator, backtrace_line=T.unsafe(nil)); end - - def invoke(*_); end - - def matches?(message, *_); end - - def unadvise(_); end - - def verify_messages_received(); end -end - -class RSpec::Mocks::SimpleMessageExpectation -end - -class RSpec::Mocks::Space - def any_instance_mutex(); end - - def any_instance_proxy_for(klass); end - - def any_instance_recorder_for(klass, only_return_existing=T.unsafe(nil)); end - - def any_instance_recorders(); end - - def any_instance_recorders_from_ancestry_of(object); end - - def constant_mutator_for(name); end - - def ensure_registered(object); end - - def new_scope(); end - - def proxies(); end - - def proxies_of(klass); end - - def proxy_for(object); end - - def proxy_mutex(); end - - def register_constant_mutator(mutator); end - - def registered?(object); end - - def reset_all(); end - - def superclass_proxy_for(klass); end - - def verify_all(); end -end - -class RSpec::Mocks::Space -end - -class RSpec::Mocks::StubChain -end - -class RSpec::Mocks::StubChain - def self.stub_chain_on(object, *chain, &blk); end -end - -module RSpec::Mocks::Syntax -end - -module RSpec::Mocks::Syntax - def self.default_should_syntax_host(); end - - def self.disable_expect(syntax_host=T.unsafe(nil)); end - - def self.disable_should(syntax_host=T.unsafe(nil)); end - - def self.enable_expect(syntax_host=T.unsafe(nil)); end - - def self.enable_should(syntax_host=T.unsafe(nil)); end - - def self.expect_enabled?(syntax_host=T.unsafe(nil)); end - - def self.should_enabled?(syntax_host=T.unsafe(nil)); end - - def self.warn_about_should!(); end - - def self.warn_unless_should_configured(method_name, replacement=T.unsafe(nil)); end -end - -class RSpec::Mocks::TargetBase - include ::RSpec::Mocks::TargetDelegationInstanceMethods - def initialize(target); end -end - -class RSpec::Mocks::TargetBase - extend ::RSpec::Mocks::TargetDelegationClassMethods -end - -module RSpec::Mocks::TargetDelegationClassMethods - def delegate_not_to(matcher_method, options=T.unsafe(nil)); end - - def delegate_to(matcher_method); end - - def disallow_negation(method_name); end -end - -module RSpec::Mocks::TargetDelegationClassMethods -end - -module RSpec::Mocks::TargetDelegationInstanceMethods - def target(); end -end - -module RSpec::Mocks::TargetDelegationInstanceMethods -end - -module RSpec::Mocks::TestDouble - def ==(other); end - - def __build_mock_proxy_unless_expired(order_group); end - - def __disallow_further_usage!(); end - - def as_null_object(); end - - def freeze(); end - - def initialize(name=T.unsafe(nil), stubs=T.unsafe(nil)); end - - def inspect(); end - - def null_object?(); end - - def respond_to?(message, incl_private=T.unsafe(nil)); end - - def to_s(); end -end - -module RSpec::Mocks::TestDouble -end - -module RSpec::Mocks::TestDoubleFormatter -end - -module RSpec::Mocks::TestDoubleFormatter - def self.format(dbl, unwrap=T.unsafe(nil)); end -end - -class RSpec::Mocks::TestDoubleProxy -end - -class RSpec::Mocks::TestDoubleProxy -end - -class RSpec::Mocks::UnsupportedMatcherError -end - -class RSpec::Mocks::UnsupportedMatcherError -end - -module RSpec::Mocks::VerifyingDouble - def __send__(name, *args, &block); end - - def initialize(doubled_module, *args); end - - def method_missing(message, *args, &block); end - - def respond_to?(message, include_private=T.unsafe(nil)); end - - def send(name, *args, &block); end -end - -module RSpec::Mocks::VerifyingDouble::SilentIO -end - -module RSpec::Mocks::VerifyingDouble::SilentIO -end - -module RSpec::Mocks::VerifyingDouble -end - -class RSpec::Mocks::VerifyingDoubleNotDefinedError -end - -class RSpec::Mocks::VerifyingDoubleNotDefinedError -end - -class RSpec::Mocks::VerifyingExistingClassNewMethodDouble -end - -class RSpec::Mocks::VerifyingExistingClassNewMethodDouble -end - -class RSpec::Mocks::VerifyingExistingMethodDouble - def initialize(object, method_name, proxy); end - - def unimplemented?(); end - - def with_signature(); end -end - -class RSpec::Mocks::VerifyingExistingMethodDouble - def self.for(object, method_name, proxy); end -end - -class RSpec::Mocks::VerifyingMessageExpectation - def initialize(*args); end - - def method_reference(); end - - def method_reference=(method_reference); end -end - -class RSpec::Mocks::VerifyingMessageExpectation -end - -class RSpec::Mocks::VerifyingMethodDouble - def add_expectation(*args, &block); end - - def add_stub(*args, &block); end - - def initialize(object, method_name, proxy, method_reference); end - - def proxy_method_invoked(obj, *args, &block); end - - def validate_arguments!(actual_args); end -end - -class RSpec::Mocks::VerifyingMethodDouble -end - -class RSpec::Mocks::VerifyingPartialClassDoubleProxy - include ::RSpec::Mocks::PartialClassDoubleProxyMethods -end - -class RSpec::Mocks::VerifyingPartialClassDoubleProxy -end - -class RSpec::Mocks::VerifyingPartialDoubleProxy - include ::RSpec::Mocks::VerifyingProxyMethods - def ensure_implemented(_method_name); end - - def initialize(object, expectation_ordering, optional_callback_invocation_strategy=T.unsafe(nil)); end - - def method_reference(); end -end - -class RSpec::Mocks::VerifyingPartialDoubleProxy -end - -class RSpec::Mocks::VerifyingProxy - include ::RSpec::Mocks::VerifyingProxyMethods - def initialize(object, order_group, doubled_module, method_reference_class); end - - def method_reference(); end - - def validate_arguments!(method_name, args); end - - def visibility_for(method_name); end -end - -class RSpec::Mocks::VerifyingProxy -end - -module RSpec::Mocks::VerifyingProxyMethods - def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end - - def add_simple_stub(method_name, *args); end - - def add_stub(method_name, opts=T.unsafe(nil), &implementation); end - - def ensure_implemented(method_name); end - - def ensure_publicly_implemented(method_name, _object); end -end - -module RSpec::Mocks::VerifyingProxyMethods -end - -module RSpec::Mocks::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Mocks::Version -end - -module RSpec::Mocks - def self.allow_message(subject, message, opts=T.unsafe(nil), &block); end - - def self.configuration(); end - - def self.error_generator(); end - - def self.expect_message(subject, message, opts=T.unsafe(nil), &block); end - - def self.setup(); end - - def self.space(); end - - def self.teardown(); end - - def self.verify(); end - - def self.with_temporary_scope(); end end class RSpec::Retry @@ -34719,495 +18920,6 @@ class RSpec::Retry def self.setup(); end end -RSpec::SharedContext = RSpec::Core::SharedContext - -module RSpec::Support - DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped) - DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) - KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped) -end - -module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - AVOID_RESCUING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - def self.===(exception); end -end - -class RSpec::Support::BlockSignature -end - -class RSpec::Support::BlockSignature -end - -class RSpec::Support::ComparableVersion - include ::Comparable - def initialize(string); end - - def segments(); end - - def string(); end -end - -class RSpec::Support::ComparableVersion -end - -class RSpec::Support::Differ - def color?(); end - - def diff(actual, expected); end - - def diff_as_object(actual, expected); end - - def diff_as_string(actual, expected); end - - def initialize(opts=T.unsafe(nil)); end -end - -class RSpec::Support::Differ -end - -class RSpec::Support::DirectoryMaker -end - -class RSpec::Support::DirectoryMaker - def self.mkdir_p(path); end -end - -class RSpec::Support::EncodedString - def <<(string); end - - def ==(*args, &block); end - - def empty?(*args, &block); end - - def encoding(*args, &block); end - - def eql?(*args, &block); end - - def initialize(string, encoding=T.unsafe(nil)); end - - def lines(*args, &block); end - - def source_encoding(); end - - def split(regex_or_string); end - - def to_str(); end - REPLACE = ::T.let(nil, ::T.untyped) - US_ASCII = ::T.let(nil, ::T.untyped) - UTF_8 = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::EncodedString - def self.pick_encoding(source_a, source_b); end -end - -module RSpec::Support::FuzzyMatcher -end - -module RSpec::Support::FuzzyMatcher - def self.values_match?(expected, actual); end -end - -class RSpec::Support::LooseSignatureVerifier -end - -class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher - def has_kw_args_in?(args); end - - def initialize(signature); end - - def invalid_kw_args_from(_kw_args); end - - def missing_kw_args_from(_kw_args); end - - def non_kw_args_arity_description(); end - - def valid_non_kw_args?(*args); end -end - -class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher -end - -class RSpec::Support::LooseSignatureVerifier -end - -class RSpec::Support::MethodSignature - def arbitrary_kw_args?(); end - - def classify_arity(arity=T.unsafe(nil)); end - - def classify_parameters(); end - - def could_contain_kw_args?(args); end - - def description(); end - - def has_kw_args_in?(args); end - - def initialize(method); end - - def invalid_kw_args_from(given_kw_args); end - - def max_non_kw_args(); end - - def min_non_kw_args(); end - - def missing_kw_args_from(given_kw_args); end - - def non_kw_args_arity_description(); end - - def optional_kw_args(); end - - def required_kw_args(); end - - def unlimited_args?(); end - - def valid_non_kw_args?(positional_arg_count, optional_max_arg_count=T.unsafe(nil)); end - INFINITY = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::MethodSignature -end - -class RSpec::Support::MethodSignatureExpectation - def empty?(); end - - def expect_arbitrary_keywords(); end - - def expect_arbitrary_keywords=(expect_arbitrary_keywords); end - - def expect_unlimited_arguments(); end - - def expect_unlimited_arguments=(expect_unlimited_arguments); end - - def keywords(); end - - def keywords=(values); end - - def max_count(); end - - def max_count=(number); end - - def min_count(); end - - def min_count=(number); end -end - -class RSpec::Support::MethodSignatureExpectation -end - -class RSpec::Support::MethodSignatureVerifier - def error_message(); end - - def initialize(signature, args=T.unsafe(nil)); end - - def kw_args(); end - - def max_non_kw_args(); end - - def min_non_kw_args(); end - - def non_kw_args(); end - - def valid?(); end - - def with_expectation(expectation); end -end - -class RSpec::Support::MethodSignatureVerifier -end - -class RSpec::Support::Mutex - NEW_MUTEX_METHOD = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::Mutex - def self.new(); end -end - -module RSpec::Support::OS -end - -module RSpec::Support::OS - def self.windows?(); end - - def self.windows_file_path?(); end -end - -class RSpec::Support::ObjectFormatter - def format(object); end - - def initialize(max_formatted_output_length=T.unsafe(nil)); end - - def max_formatted_output_length(); end - - def max_formatted_output_length=(max_formatted_output_length); end - - def prepare_array(array); end - - def prepare_element(element); end - - def prepare_for_inspection(object); end - - def prepare_hash(input_hash); end - - def recursive_structure?(object); end - - def sort_hash_keys(input_hash); end - - def with_entering_structure(structure); end - ELLIPSIS = ::T.let(nil, ::T.untyped) - INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::BaseInspector - def formatter(); end - - def formatter=(_); end - - def object(); end - - def object=(_); end - - def pretty_print(pp); end -end - -class RSpec::Support::ObjectFormatter::BaseInspector - def self.[](*_); end - - def self.can_inspect?(_object); end - - def self.members(); end -end - -class RSpec::Support::ObjectFormatter::BigDecimalInspector -end - -class RSpec::Support::ObjectFormatter::BigDecimalInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::DateTimeInspector - FORMAT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::DateTimeInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::DelegatorInspector -end - -class RSpec::Support::ObjectFormatter::DelegatorInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::DescribableMatcherInspector -end - -class RSpec::Support::ObjectFormatter::DescribableMatcherInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::InspectableItem - def pretty_print(pp); end - - def text(); end - - def text=(_); end -end - -class RSpec::Support::ObjectFormatter::InspectableItem - def self.[](*_); end - - def self.members(); end -end - -class RSpec::Support::ObjectFormatter::InspectableObjectInspector -end - -class RSpec::Support::ObjectFormatter::InspectableObjectInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::TimeInspector - FORMAT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::TimeInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter::UninspectableObjectInspector - def klass(); end - - def native_object_id(); end - OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::UninspectableObjectInspector - def self.can_inspect?(object); end -end - -class RSpec::Support::ObjectFormatter - def self.default_instance(); end - - def self.format(object); end - - def self.prepare_for_inspection(object); end -end - -module RSpec::Support::RecursiveConstMethods - def const_defined_on?(mod, const_name); end - - def constants_defined_on(mod); end - - def get_const_defined_on(mod, const_name); end - - def normalize_const_name(const_name); end - - def recursive_const_defined?(const_name); end - - def recursive_const_get(const_name); end -end - -module RSpec::Support::RecursiveConstMethods -end - -class RSpec::Support::ReentrantMutex - def synchronize(); end -end - -class RSpec::Support::ReentrantMutex -end - -module RSpec::Support::Ruby -end - -module RSpec::Support::Ruby - def self.jruby?(); end - - def self.jruby_9000?(); end - - def self.jruby_version(); end - - def self.mri?(); end - - def self.non_mri?(); end - - def self.rbx?(); end - - def self.truffleruby?(); end -end - -module RSpec::Support::RubyFeatures -end - -module RSpec::Support::RubyFeatures - def self.caller_locations_supported?(); end - - def self.fork_supported?(); end - - def self.kw_args_supported?(); end - - def self.module_prepends_supported?(); end - - def self.module_refinement_supported?(); end - - def self.optional_and_splat_args_supported?(); end - - def self.required_kw_args_supported?(); end - - def self.ripper_supported?(); end - - def self.supports_exception_cause?(); end - - def self.supports_rebinding_module_methods?(); end - - def self.supports_taint?(); end -end - -RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier - -module RSpec::Support::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Support::Version -end - -module RSpec::Support::Warnings - def deprecate(deprecated, options=T.unsafe(nil)); end - - def warn_deprecation(message, options=T.unsafe(nil)); end - - def warn_with(message, options=T.unsafe(nil)); end - - def warning(text, options=T.unsafe(nil)); end -end - -module RSpec::Support::Warnings -end - -module RSpec::Support::WithKeywordsWhenNeeded -end - -module RSpec::Support::WithKeywordsWhenNeeded - def self.class_exec(klass, *args, &block); end -end - -module RSpec::Support - def self.class_of(object); end - - def self.define_optimized_require_for_rspec(lib, &require_relative); end - - def self.deregister_matcher_definition(&block); end - - def self.failure_notifier(); end - - def self.failure_notifier=(callable); end - - def self.is_a_matcher?(object); end - - def self.matcher_definitions(); end - - def self.method_handle_for(object, method_name); end - - def self.notify_failure(failure, options=T.unsafe(nil)); end - - def self.register_matcher_definition(&block); end - - def self.require_rspec_core(f); end - - def self.require_rspec_expectations(f); end - - def self.require_rspec_matchers(f); end - - def self.require_rspec_mocks(f); end - - def self.require_rspec_support(f); end - - def self.rspec_description_for_object(object); end - - def self.thread_local_data(); end - - def self.warning_notifier(); end - - def self.warning_notifier=(warning_notifier); end - - def self.with_failure_notifier(callable); end -end - -module RSpec::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Version -end - module RSpec::Wait end @@ -35275,44 +18987,6 @@ module RSpec::Wait def self.with_wait(options); end end -module RSpec - extend ::RSpec::Support::Warnings - extend ::RSpec::Core::Warnings - def self.clear_examples(); end - - def self.configuration(); end - - def self.configuration=(configuration); end - - def self.configure(); end - - def self.const_missing(name); end - - def self.context(*args, &example_group_block); end - - def self.current_example(); end - - def self.current_example=(example); end - - def self.describe(*args, &example_group_block); end - - def self.example_group(*args, &example_group_block); end - - def self.fcontext(*args, &example_group_block); end - - def self.fdescribe(*args, &example_group_block); end - - def self.reset(); end - - def self.world(); end - - def self.world=(world); end - - def self.xcontext(*args, &example_group_block); end - - def self.xdescribe(*args, &example_group_block); end -end - module Racc Racc_No_Extensions = ::T.let(nil, ::T.untyped) end @@ -35338,214 +19012,6 @@ class Racc::Parser Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped) end -module Rainbow -end - -class Rainbow::Color - def ground(); end -end - -class Rainbow::Color::Indexed - def codes(); end - - def initialize(ground, num); end - - def num(); end -end - -class Rainbow::Color::Indexed -end - -class Rainbow::Color::Named - def initialize(ground, name); end - NAMES = ::T.let(nil, ::T.untyped) -end - -class Rainbow::Color::Named - def self.color_names(); end - - def self.valid_names(); end -end - -class Rainbow::Color::RGB - def b(); end - - def g(); end - - def initialize(ground, *values); end - - def r(); end -end - -class Rainbow::Color::RGB - def self.to_ansi_domain(value); end -end - -class Rainbow::Color::X11Named - include ::Rainbow::X11ColorNames - def initialize(ground, name); end -end - -class Rainbow::Color::X11Named - def self.color_names(); end - - def self.valid_names(); end -end - -class Rainbow::Color - def self.build(ground, values); end - - def self.parse_hex_color(hex); end -end - -class Rainbow::NullPresenter - def background(*_values); end - - def bg(*_values); end - - def black(); end - - def blink(); end - - def blue(); end - - def bold(); end - - def bright(); end - - def color(*_values); end - - def cyan(); end - - def dark(); end - - def faint(); end - - def fg(*_values); end - - def foreground(*_values); end - - def green(); end - - def hide(); end - - def inverse(); end - - def italic(); end - - def magenta(); end - - def method_missing(method_name, *args); end - - def red(); end - - def reset(); end - - def underline(); end - - def white(); end - - def yellow(); end -end - -class Rainbow::NullPresenter -end - -class Rainbow::Presenter - def background(*values); end - - def bg(*values); end - - def black(); end - - def blink(); end - - def blue(); end - - def bold(); end - - def bright(); end - - def color(*values); end - - def cyan(); end - - def dark(); end - - def faint(); end - - def fg(*values); end - - def foreground(*values); end - - def green(); end - - def hide(); end - - def inverse(); end - - def italic(); end - - def magenta(); end - - def method_missing(method_name, *args); end - - def red(); end - - def reset(); end - - def underline(); end - - def white(); end - - def yellow(); end - TERM_EFFECTS = ::T.let(nil, ::T.untyped) -end - -class Rainbow::Presenter -end - -class Rainbow::StringUtils -end - -class Rainbow::StringUtils - def self.uncolor(string); end - - def self.wrap_with_sgr(string, codes); end -end - -class Rainbow::Wrapper - def enabled(); end - - def enabled=(enabled); end - - def initialize(enabled=T.unsafe(nil)); end - - def wrap(string); end -end - -class Rainbow::Wrapper -end - -module Rainbow::X11ColorNames - NAMES = ::T.let(nil, ::T.untyped) -end - -module Rainbow::X11ColorNames -end - -module Rainbow - def self.enabled(); end - - def self.enabled=(value); end - - def self.global(); end - - def self.new(); end - - def self.uncolor(string); end -end - class Random def self.bytes(_); end end @@ -35570,1994 +19036,6 @@ module Readline def self.completion_quote_character(); end end -class Regexp - TOKEN_KEYS = ::T.let(nil, ::T.untyped) -end - -module Regexp::Expression -end - -class Regexp::Expression::Alternation - def alternatives(); end -end - -Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative - -class Regexp::Expression::Alternation -end - -class Regexp::Expression::Alternative -end - -class Regexp::Expression::Alternative -end - -module Regexp::Expression::Anchor -end - -Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine - -Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString - -class Regexp::Expression::Anchor::Base - def match_length(); end -end - -class Regexp::Expression::Anchor::Base -end - -class Regexp::Expression::Anchor::BeginningOfLine -end - -class Regexp::Expression::Anchor::BeginningOfLine -end - -class Regexp::Expression::Anchor::BeginningOfString -end - -class Regexp::Expression::Anchor::BeginningOfString -end - -Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine - -Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString - -Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine - -class Regexp::Expression::Anchor::EndOfLine -end - -class Regexp::Expression::Anchor::EndOfLine -end - -class Regexp::Expression::Anchor::EndOfString -end - -class Regexp::Expression::Anchor::EndOfString -end - -class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine -end - -class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine -end - -class Regexp::Expression::Anchor::MatchStart -end - -class Regexp::Expression::Anchor::MatchStart -end - -class Regexp::Expression::Anchor::NonWordBoundary -end - -class Regexp::Expression::Anchor::NonWordBoundary -end - -class Regexp::Expression::Anchor::WordBoundary -end - -class Regexp::Expression::Anchor::WordBoundary -end - -module Regexp::Expression::Anchor -end - -module Regexp::Expression::Assertion -end - -class Regexp::Expression::Assertion::Base -end - -class Regexp::Expression::Assertion::Base -end - -class Regexp::Expression::Assertion::Lookahead -end - -class Regexp::Expression::Assertion::Lookahead -end - -class Regexp::Expression::Assertion::Lookbehind -end - -class Regexp::Expression::Assertion::Lookbehind -end - -class Regexp::Expression::Assertion::NegativeLookahead -end - -class Regexp::Expression::Assertion::NegativeLookahead -end - -class Regexp::Expression::Assertion::NegativeLookbehind -end - -class Regexp::Expression::Assertion::NegativeLookbehind -end - -module Regexp::Expression::Assertion -end - -module Regexp::Expression::Backreference -end - -class Regexp::Expression::Backreference::Base - def match_length(); end - - def referenced_expression(); end - - def referenced_expression=(referenced_expression); end -end - -class Regexp::Expression::Backreference::Base -end - -class Regexp::Expression::Backreference::Name - def name(); end - - def reference(); end -end - -class Regexp::Expression::Backreference::Name -end - -class Regexp::Expression::Backreference::NameCall -end - -class Regexp::Expression::Backreference::NameCall -end - -class Regexp::Expression::Backreference::NameRecursionLevel - def recursion_level(); end -end - -class Regexp::Expression::Backreference::NameRecursionLevel -end - -class Regexp::Expression::Backreference::Number - def number(); end - - def reference(); end -end - -class Regexp::Expression::Backreference::Number -end - -class Regexp::Expression::Backreference::NumberCall -end - -class Regexp::Expression::Backreference::NumberCall -end - -class Regexp::Expression::Backreference::NumberCallRelative -end - -class Regexp::Expression::Backreference::NumberCallRelative -end - -class Regexp::Expression::Backreference::NumberRecursionLevel - def recursion_level(); end -end - -class Regexp::Expression::Backreference::NumberRecursionLevel -end - -class Regexp::Expression::Backreference::NumberRelative - def effective_number(); end - - def effective_number=(effective_number); end -end - -class Regexp::Expression::Backreference::NumberRelative -end - -module Regexp::Expression::Backreference -end - -class Regexp::Expression::Base - def =~(string, offset=T.unsafe(nil)); end - - def a?(); end - - def ascii_classes?(); end - - def attributes(); end - - def case_insensitive?(); end - - def coded_offset(); end - - def conditional_level(); end - - def conditional_level=(conditional_level); end - - def d?(); end - - def default_classes?(); end - - def extended?(); end - - def free_spacing?(); end - - def full_length(); end - - def greedy?(); end - - def i?(); end - - def ignore_case?(); end - - def initialize(token, options=T.unsafe(nil)); end - - def is?(test_token, test_type=T.unsafe(nil)); end - - def lazy?(); end - - def level(); end - - def level=(level); end - - def m?(); end - - def match(string, offset=T.unsafe(nil)); end - - def match?(string); end - - def matches?(string); end - - def multiline?(); end - - def nesting_level(); end - - def nesting_level=(nesting_level); end - - def offset(); end - - def one_of?(scope, top=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def possessive?(); end - - def quantified?(); end - - def quantifier(); end - - def quantifier=(quantifier); end - - def quantifier_affix(expression_format); end - - def quantify(token, text, min=T.unsafe(nil), max=T.unsafe(nil), mode=T.unsafe(nil)); end - - def quantity(); end - - def reluctant?(); end - - def repetitions(); end - - def set_level(); end - - def set_level=(set_level); end - - def starts_at(); end - - def strfre(format=T.unsafe(nil), indent_offset=T.unsafe(nil), index=T.unsafe(nil)); end - - def strfregexp(format=T.unsafe(nil), indent_offset=T.unsafe(nil), index=T.unsafe(nil)); end - - def terminal?(); end - - def text(); end - - def text=(text); end - - def to_h(); end - - def to_re(format=T.unsafe(nil)); end - - def to_s(format=T.unsafe(nil)); end - - def token(); end - - def token=(token); end - - def ts(); end - - def ts=(ts); end - - def type(); end - - def type=(type); end - - def type?(test_type); end - - def u?(); end - - def unicode_classes?(); end - - def unquantified_clone(); end - - def x?(); end -end - -class Regexp::Expression::Base -end - -class Regexp::Expression::CharacterSet - def close(); end - - def closed(); end - - def closed=(closed); end - - def closed?(); end - - def negate(); end - - def negated?(); end - - def negative(); end - - def negative=(negative); end - - def negative?(); end -end - -class Regexp::Expression::CharacterSet::IntersectedSequence -end - -class Regexp::Expression::CharacterSet::IntersectedSequence -end - -class Regexp::Expression::CharacterSet::Intersection -end - -Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence - -class Regexp::Expression::CharacterSet::Intersection -end - -class Regexp::Expression::CharacterSet::Range - def complete?(); end - - def to_s(_format=T.unsafe(nil)); end -end - -class Regexp::Expression::CharacterSet::Range -end - -class Regexp::Expression::CharacterSet -end - -module Regexp::Expression::CharacterType -end - -class Regexp::Expression::CharacterType::Any -end - -class Regexp::Expression::CharacterType::Any -end - -class Regexp::Expression::CharacterType::Base - def match_length(); end -end - -class Regexp::Expression::CharacterType::Base -end - -class Regexp::Expression::CharacterType::Digit -end - -class Regexp::Expression::CharacterType::Digit -end - -class Regexp::Expression::CharacterType::ExtendedGrapheme -end - -class Regexp::Expression::CharacterType::ExtendedGrapheme -end - -class Regexp::Expression::CharacterType::Hex -end - -class Regexp::Expression::CharacterType::Hex -end - -class Regexp::Expression::CharacterType::Linebreak -end - -class Regexp::Expression::CharacterType::Linebreak -end - -class Regexp::Expression::CharacterType::NonDigit -end - -class Regexp::Expression::CharacterType::NonDigit -end - -class Regexp::Expression::CharacterType::NonHex -end - -class Regexp::Expression::CharacterType::NonHex -end - -class Regexp::Expression::CharacterType::NonSpace -end - -class Regexp::Expression::CharacterType::NonSpace -end - -class Regexp::Expression::CharacterType::NonWord -end - -class Regexp::Expression::CharacterType::NonWord -end - -class Regexp::Expression::CharacterType::Space -end - -class Regexp::Expression::CharacterType::Space -end - -class Regexp::Expression::CharacterType::Word -end - -class Regexp::Expression::CharacterType::Word -end - -module Regexp::Expression::CharacterType -end - -class Regexp::Expression::Comment -end - -class Regexp::Expression::Comment -end - -module Regexp::Expression::Conditional -end - -class Regexp::Expression::Conditional::Branch -end - -class Regexp::Expression::Conditional::Branch -end - -class Regexp::Expression::Conditional::Condition - def match_length(); end - - def reference(); end - - def referenced_expression(); end - - def referenced_expression=(referenced_expression); end -end - -class Regexp::Expression::Conditional::Condition -end - -class Regexp::Expression::Conditional::Expression - def add_sequence(active_opts=T.unsafe(nil)); end - - def branch(active_opts=T.unsafe(nil)); end - - def branches(); end - - def condition(); end - - def condition=(exp); end - - def reference(); end - - def referenced_expression(); end - - def referenced_expression=(referenced_expression); end -end - -class Regexp::Expression::Conditional::Expression -end - -class Regexp::Expression::Conditional::TooManyBranches - def initialize(); end -end - -class Regexp::Expression::Conditional::TooManyBranches -end - -module Regexp::Expression::Conditional -end - -module Regexp::Expression::EscapeSequence -end - -class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence -end - -class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence -end - -class Regexp::Expression::EscapeSequence::AsciiEscape -end - -class Regexp::Expression::EscapeSequence::AsciiEscape -end - -class Regexp::Expression::EscapeSequence::Backspace -end - -class Regexp::Expression::EscapeSequence::Backspace -end - -class Regexp::Expression::EscapeSequence::Base - def char(); end - - def codepoint(); end - - def match_length(); end -end - -class Regexp::Expression::EscapeSequence::Base -end - -class Regexp::Expression::EscapeSequence::Bell -end - -class Regexp::Expression::EscapeSequence::Bell -end - -class Regexp::Expression::EscapeSequence::Codepoint -end - -class Regexp::Expression::EscapeSequence::Codepoint -end - -class Regexp::Expression::EscapeSequence::CodepointList - def chars(); end - - def codepoints(); end -end - -class Regexp::Expression::EscapeSequence::CodepointList -end - -class Regexp::Expression::EscapeSequence::Control -end - -class Regexp::Expression::EscapeSequence::Control -end - -class Regexp::Expression::EscapeSequence::FormFeed -end - -class Regexp::Expression::EscapeSequence::FormFeed -end - -class Regexp::Expression::EscapeSequence::Hex -end - -class Regexp::Expression::EscapeSequence::Hex -end - -class Regexp::Expression::EscapeSequence::Literal -end - -class Regexp::Expression::EscapeSequence::Literal -end - -class Regexp::Expression::EscapeSequence::Meta -end - -class Regexp::Expression::EscapeSequence::Meta -end - -class Regexp::Expression::EscapeSequence::MetaControl -end - -class Regexp::Expression::EscapeSequence::MetaControl -end - -class Regexp::Expression::EscapeSequence::Newline -end - -class Regexp::Expression::EscapeSequence::Newline -end - -class Regexp::Expression::EscapeSequence::Octal -end - -class Regexp::Expression::EscapeSequence::Octal -end - -class Regexp::Expression::EscapeSequence::Return -end - -class Regexp::Expression::EscapeSequence::Return -end - -class Regexp::Expression::EscapeSequence::Tab -end - -class Regexp::Expression::EscapeSequence::Tab -end - -class Regexp::Expression::EscapeSequence::VerticalTab -end - -class Regexp::Expression::EscapeSequence::VerticalTab -end - -module Regexp::Expression::EscapeSequence -end - -class Regexp::Expression::FreeSpace - def match_length(); end -end - -class Regexp::Expression::FreeSpace -end - -module Regexp::Expression::Group -end - -class Regexp::Expression::Group::Absence -end - -class Regexp::Expression::Group::Absence -end - -class Regexp::Expression::Group::Atomic -end - -class Regexp::Expression::Group::Atomic -end - -class Regexp::Expression::Group::Base - def capturing?(); end - - def comment?(); end -end - -class Regexp::Expression::Group::Base -end - -class Regexp::Expression::Group::Capture - def identifier(); end - - def number(); end - - def number=(number); end - - def number_at_level(); end - - def number_at_level=(number_at_level); end -end - -class Regexp::Expression::Group::Capture -end - -class Regexp::Expression::Group::Comment - def to_s(_format=T.unsafe(nil)); end -end - -class Regexp::Expression::Group::Comment -end - -class Regexp::Expression::Group::Named - def name(); end -end - -class Regexp::Expression::Group::Named -end - -class Regexp::Expression::Group::Options - def option_changes(); end - - def option_changes=(option_changes); end -end - -class Regexp::Expression::Group::Options -end - -class Regexp::Expression::Group::Passive -end - -class Regexp::Expression::Group::Passive -end - -module Regexp::Expression::Group -end - -module Regexp::Expression::Keep -end - -class Regexp::Expression::Keep::Mark - def match_length(); end -end - -class Regexp::Expression::Keep::Mark -end - -module Regexp::Expression::Keep -end - -class Regexp::Expression::Literal - def match_length(); end -end - -class Regexp::Expression::Literal -end - -Regexp::Expression::MatchLength = Regexp::MatchLength - -class Regexp::Expression::PosixClass - def match_length(); end - - def name(); end - - def negative?(); end -end - -class Regexp::Expression::PosixClass -end - -class Regexp::Expression::Quantifier - def greedy?(); end - - def initialize(token, text, min, max, mode); end - - def lazy?(); end - - def max(); end - - def min(); end - - def mode(); end - - def possessive?(); end - - def reluctant?(); end - - def text(); end - - def to_h(); end - - def to_str(); end - - def token(); end - MODES = ::T.let(nil, ::T.untyped) -end - -class Regexp::Expression::Quantifier -end - -class Regexp::Expression::Root - def initialize(*args); end -end - -class Regexp::Expression::Root - def self.build(options=T.unsafe(nil)); end - - def self.build_token(); end -end - -class Regexp::Expression::Sequence - def initialize(*args); end -end - -class Regexp::Expression::Sequence - def self.add_to(subexpression, params=T.unsafe(nil), active_opts=T.unsafe(nil)); end - - def self.at_levels(level, set_level, conditional_level); end -end - -class Regexp::Expression::SequenceOperation - def add_sequence(active_opts=T.unsafe(nil)); end - - def operands(); end - - def operator(); end - - def sequences(); end -end - -class Regexp::Expression::SequenceOperation -end - -class Regexp::Expression::Subexpression - include ::Enumerable - def <<(exp); end - - def [](*args, &block); end - - def at(*args, &block); end - - def dig(*indices); end - - def each(*args, &block); end - - def each_expression(include_self=T.unsafe(nil), &block); end - - def empty?(*args, &block); end - - def expressions(); end - - def expressions=(expressions); end - - def fetch(*args, &block); end - - def flat_map(include_self=T.unsafe(nil), &block); end - - def index(*args, &block); end - - def inner_match_length(); end - - def join(*args, &block); end - - def last(*args, &block); end - - def length(*args, &block); end - - def match_length(); end - - def strfre_tree(format=T.unsafe(nil), include_self=T.unsafe(nil), separator=T.unsafe(nil)); end - - def strfregexp_tree(format=T.unsafe(nil), include_self=T.unsafe(nil), separator=T.unsafe(nil)); end - - def te(); end - - def to_h(); end - - def traverse(include_self=T.unsafe(nil), &block); end - - def values_at(*args, &block); end - - def walk(include_self=T.unsafe(nil), &block); end -end - -class Regexp::Expression::Subexpression -end - -module Regexp::Expression::UnicodeProperty -end - -class Regexp::Expression::UnicodeProperty::Age -end - -class Regexp::Expression::UnicodeProperty::Age -end - -class Regexp::Expression::UnicodeProperty::Alnum -end - -class Regexp::Expression::UnicodeProperty::Alnum -end - -class Regexp::Expression::UnicodeProperty::Alpha -end - -class Regexp::Expression::UnicodeProperty::Alpha -end - -class Regexp::Expression::UnicodeProperty::Any -end - -class Regexp::Expression::UnicodeProperty::Any -end - -class Regexp::Expression::UnicodeProperty::Ascii -end - -class Regexp::Expression::UnicodeProperty::Ascii -end - -class Regexp::Expression::UnicodeProperty::Assigned -end - -class Regexp::Expression::UnicodeProperty::Assigned -end - -class Regexp::Expression::UnicodeProperty::Base - def match_length(); end - - def name(); end - - def negative?(); end - - def shortcut(); end -end - -class Regexp::Expression::UnicodeProperty::Base -end - -class Regexp::Expression::UnicodeProperty::Blank -end - -class Regexp::Expression::UnicodeProperty::Blank -end - -class Regexp::Expression::UnicodeProperty::Block -end - -class Regexp::Expression::UnicodeProperty::Block -end - -class Regexp::Expression::UnicodeProperty::Cntrl -end - -class Regexp::Expression::UnicodeProperty::Cntrl -end - -module Regexp::Expression::UnicodeProperty::Codepoint -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Any -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Any -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Base -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Base -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Control -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Control -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Format -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Format -end - -class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse -end - -class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned -end - -class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned -end - -module Regexp::Expression::UnicodeProperty::Codepoint -end - -class Regexp::Expression::UnicodeProperty::Derived -end - -class Regexp::Expression::UnicodeProperty::Derived -end - -class Regexp::Expression::UnicodeProperty::Digit -end - -class Regexp::Expression::UnicodeProperty::Digit -end - -class Regexp::Expression::UnicodeProperty::Emoji -end - -class Regexp::Expression::UnicodeProperty::Emoji -end - -class Regexp::Expression::UnicodeProperty::Graph -end - -class Regexp::Expression::UnicodeProperty::Graph -end - -module Regexp::Expression::UnicodeProperty::Letter -end - -class Regexp::Expression::UnicodeProperty::Letter::Any -end - -class Regexp::Expression::UnicodeProperty::Letter::Any -end - -class Regexp::Expression::UnicodeProperty::Letter::Base -end - -class Regexp::Expression::UnicodeProperty::Letter::Base -end - -class Regexp::Expression::UnicodeProperty::Letter::Cased -end - -class Regexp::Expression::UnicodeProperty::Letter::Cased -end - -class Regexp::Expression::UnicodeProperty::Letter::Lowercase -end - -class Regexp::Expression::UnicodeProperty::Letter::Lowercase -end - -class Regexp::Expression::UnicodeProperty::Letter::Modifier -end - -class Regexp::Expression::UnicodeProperty::Letter::Modifier -end - -class Regexp::Expression::UnicodeProperty::Letter::Other -end - -class Regexp::Expression::UnicodeProperty::Letter::Other -end - -class Regexp::Expression::UnicodeProperty::Letter::Titlecase -end - -class Regexp::Expression::UnicodeProperty::Letter::Titlecase -end - -class Regexp::Expression::UnicodeProperty::Letter::Uppercase -end - -class Regexp::Expression::UnicodeProperty::Letter::Uppercase -end - -module Regexp::Expression::UnicodeProperty::Letter -end - -class Regexp::Expression::UnicodeProperty::Lower -end - -class Regexp::Expression::UnicodeProperty::Lower -end - -module Regexp::Expression::UnicodeProperty::Mark -end - -class Regexp::Expression::UnicodeProperty::Mark::Any -end - -class Regexp::Expression::UnicodeProperty::Mark::Any -end - -class Regexp::Expression::UnicodeProperty::Mark::Base -end - -class Regexp::Expression::UnicodeProperty::Mark::Base -end - -class Regexp::Expression::UnicodeProperty::Mark::Combining -end - -class Regexp::Expression::UnicodeProperty::Mark::Combining -end - -class Regexp::Expression::UnicodeProperty::Mark::Enclosing -end - -class Regexp::Expression::UnicodeProperty::Mark::Enclosing -end - -class Regexp::Expression::UnicodeProperty::Mark::Nonspacing -end - -class Regexp::Expression::UnicodeProperty::Mark::Nonspacing -end - -class Regexp::Expression::UnicodeProperty::Mark::Spacing -end - -class Regexp::Expression::UnicodeProperty::Mark::Spacing -end - -module Regexp::Expression::UnicodeProperty::Mark -end - -class Regexp::Expression::UnicodeProperty::Newline -end - -class Regexp::Expression::UnicodeProperty::Newline -end - -module Regexp::Expression::UnicodeProperty::Number -end - -class Regexp::Expression::UnicodeProperty::Number::Any -end - -class Regexp::Expression::UnicodeProperty::Number::Any -end - -class Regexp::Expression::UnicodeProperty::Number::Base -end - -class Regexp::Expression::UnicodeProperty::Number::Base -end - -class Regexp::Expression::UnicodeProperty::Number::Decimal -end - -class Regexp::Expression::UnicodeProperty::Number::Decimal -end - -class Regexp::Expression::UnicodeProperty::Number::Letter -end - -class Regexp::Expression::UnicodeProperty::Number::Letter -end - -class Regexp::Expression::UnicodeProperty::Number::Other -end - -class Regexp::Expression::UnicodeProperty::Number::Other -end - -module Regexp::Expression::UnicodeProperty::Number -end - -class Regexp::Expression::UnicodeProperty::Print -end - -class Regexp::Expression::UnicodeProperty::Print -end - -class Regexp::Expression::UnicodeProperty::Punct -end - -class Regexp::Expression::UnicodeProperty::Punct -end - -module Regexp::Expression::UnicodeProperty::Punctuation -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Any -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Any -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Base -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Base -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Close -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Close -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Connector -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Connector -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Dash -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Dash -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Final -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Final -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Initial -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Initial -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Open -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Open -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Other -end - -class Regexp::Expression::UnicodeProperty::Punctuation::Other -end - -module Regexp::Expression::UnicodeProperty::Punctuation -end - -class Regexp::Expression::UnicodeProperty::Script -end - -class Regexp::Expression::UnicodeProperty::Script -end - -module Regexp::Expression::UnicodeProperty::Separator -end - -class Regexp::Expression::UnicodeProperty::Separator::Any -end - -class Regexp::Expression::UnicodeProperty::Separator::Any -end - -class Regexp::Expression::UnicodeProperty::Separator::Base -end - -class Regexp::Expression::UnicodeProperty::Separator::Base -end - -class Regexp::Expression::UnicodeProperty::Separator::Line -end - -class Regexp::Expression::UnicodeProperty::Separator::Line -end - -class Regexp::Expression::UnicodeProperty::Separator::Paragraph -end - -class Regexp::Expression::UnicodeProperty::Separator::Paragraph -end - -class Regexp::Expression::UnicodeProperty::Separator::Space -end - -class Regexp::Expression::UnicodeProperty::Separator::Space -end - -module Regexp::Expression::UnicodeProperty::Separator -end - -class Regexp::Expression::UnicodeProperty::Space -end - -class Regexp::Expression::UnicodeProperty::Space -end - -module Regexp::Expression::UnicodeProperty::Symbol -end - -class Regexp::Expression::UnicodeProperty::Symbol::Any -end - -class Regexp::Expression::UnicodeProperty::Symbol::Any -end - -class Regexp::Expression::UnicodeProperty::Symbol::Base -end - -class Regexp::Expression::UnicodeProperty::Symbol::Base -end - -class Regexp::Expression::UnicodeProperty::Symbol::Currency -end - -class Regexp::Expression::UnicodeProperty::Symbol::Currency -end - -class Regexp::Expression::UnicodeProperty::Symbol::Math -end - -class Regexp::Expression::UnicodeProperty::Symbol::Math -end - -class Regexp::Expression::UnicodeProperty::Symbol::Modifier -end - -class Regexp::Expression::UnicodeProperty::Symbol::Modifier -end - -class Regexp::Expression::UnicodeProperty::Symbol::Other -end - -class Regexp::Expression::UnicodeProperty::Symbol::Other -end - -module Regexp::Expression::UnicodeProperty::Symbol -end - -class Regexp::Expression::UnicodeProperty::Upper -end - -class Regexp::Expression::UnicodeProperty::Upper -end - -class Regexp::Expression::UnicodeProperty::Word -end - -class Regexp::Expression::UnicodeProperty::Word -end - -class Regexp::Expression::UnicodeProperty::XPosixPunct -end - -class Regexp::Expression::UnicodeProperty::XPosixPunct -end - -class Regexp::Expression::UnicodeProperty::Xdigit -end - -class Regexp::Expression::UnicodeProperty::Xdigit -end - -module Regexp::Expression::UnicodeProperty -end - -class Regexp::Expression::WhiteSpace - def merge(exp); end -end - -class Regexp::Expression::WhiteSpace -end - -module Regexp::Expression - def self.parsed(exp); end -end - -class Regexp::Lexer - def lex(input, syntax=T.unsafe(nil), &block); end - CLOSING_TOKENS = ::T.let(nil, ::T.untyped) - OPENING_TOKENS = ::T.let(nil, ::T.untyped) -end - -class Regexp::Lexer - def self.lex(input, syntax=T.unsafe(nil), &block); end - - def self.scan(input, syntax=T.unsafe(nil), &block); end -end - -class Regexp::MatchLength - include ::Enumerable - def each(opts=T.unsafe(nil), &blk); end - - def endless_each(&block); end - - def fixed?(); end - - def include?(length); end - - def initialize(exp, opts=T.unsafe(nil)); end - - def max(); end - - def min(); end - - def to_re(); end -end - -class Regexp::MatchLength - def self.of(obj); end -end - -class Regexp::Parser - include ::Regexp::Expression - include ::Regexp::Syntax - include ::Regexp::Expression::UnicodeProperty - def parse(input, syntax=T.unsafe(nil), &block); end - ENC_FLAGS = ::T.let(nil, ::T.untyped) - MOD_FLAGS = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Regexp::Parser::ParserError -end - -class Regexp::Parser::ParserError -end - -class Regexp::Parser::UnknownTokenError - def initialize(type, token); end -end - -class Regexp::Parser::UnknownTokenError -end - -class Regexp::Parser::UnknownTokenTypeError - def initialize(type, token); end -end - -class Regexp::Parser::UnknownTokenTypeError -end - -class Regexp::Parser - def self.parse(input, syntax=T.unsafe(nil), &block); end -end - -class Regexp::Scanner - def emit(type, token, text, ts, te); end - - def scan(input_object, &block); end - PROP_MAPS_DIR = ::T.let(nil, ::T.untyped) -end - -class Regexp::Scanner::InvalidBackrefError - def initialize(what, reason); end -end - -class Regexp::Scanner::InvalidBackrefError -end - -class Regexp::Scanner::InvalidGroupError - def initialize(what, reason); end -end - -class Regexp::Scanner::InvalidGroupError -end - -class Regexp::Scanner::InvalidGroupOption - def initialize(option, text); end -end - -class Regexp::Scanner::InvalidGroupOption -end - -class Regexp::Scanner::InvalidSequenceError - def initialize(what=T.unsafe(nil), where=T.unsafe(nil)); end -end - -class Regexp::Scanner::InvalidSequenceError -end - -class Regexp::Scanner::PrematureEndError - def initialize(where=T.unsafe(nil)); end -end - -class Regexp::Scanner::PrematureEndError -end - -class Regexp::Scanner::ScannerError -end - -class Regexp::Scanner::ScannerError -end - -class Regexp::Scanner::UnknownUnicodePropertyError - def initialize(name); end -end - -class Regexp::Scanner::UnknownUnicodePropertyError -end - -class Regexp::Scanner::ValidationError - def initialize(reason); end -end - -class Regexp::Scanner::ValidationError -end - -class Regexp::Scanner - def self.long_prop_map(); end - - def self.scan(input_object, &block); end - - def self.short_prop_map(); end -end - -module Regexp::Syntax - VERSION_CONST_REGEXP = ::T.let(nil, ::T.untyped) - VERSION_FORMAT = ::T.let(nil, ::T.untyped) - VERSION_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Regexp::Syntax::Any -end - -class Regexp::Syntax::Any -end - -class Regexp::Syntax::Base - include ::Regexp::Syntax::Token - def check!(type, token); end - - def check?(type, token); end - - def excludes(type, tokens); end - - def features(); end - - def implementations(type); end - - def implements(type, tokens); end - - def implements!(type, token); end - - def implements?(type, token); end - - def normalize(type, token); end - - def normalize_backref(type, token); end - - def normalize_group(type, token); end -end - -class Regexp::Syntax::Base -end - -class Regexp::Syntax::InvalidVersionNameError - def initialize(name); end -end - -class Regexp::Syntax::InvalidVersionNameError -end - -class Regexp::Syntax::NotImplementedError - def initialize(syntax, type, token); end -end - -class Regexp::Syntax::NotImplementedError -end - -class Regexp::Syntax::SyntaxError -end - -class Regexp::Syntax::SyntaxError -end - -module Regexp::Syntax::Token - All = ::T.let(nil, ::T.untyped) - Map = ::T.let(nil, ::T.untyped) - Types = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Anchor - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - MatchStart = ::T.let(nil, ::T.untyped) - String = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Anchor -end - -module Regexp::Syntax::Token::Assertion - All = ::T.let(nil, ::T.untyped) - Lookahead = ::T.let(nil, ::T.untyped) - Lookbehind = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Assertion -end - -module Regexp::Syntax::Token::Backreference - All = ::T.let(nil, ::T.untyped) - Name = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) - RecursionLevel = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Backreference -end - -module Regexp::Syntax::Token::CharacterSet - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::CharacterSet -end - -module Regexp::Syntax::Token::CharacterType - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Clustered = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Hex = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::CharacterType -end - -module Regexp::Syntax::Token::Conditional - All = ::T.let(nil, ::T.untyped) - Condition = ::T.let(nil, ::T.untyped) - Delimiters = ::T.let(nil, ::T.untyped) - Separator = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Conditional -end - -module Regexp::Syntax::Token::Escape - ASCII = ::T.let(nil, ::T.untyped) - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Control = ::T.let(nil, ::T.untyped) - Hex = ::T.let(nil, ::T.untyped) - Meta = ::T.let(nil, ::T.untyped) - Octal = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - Unicode = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Escape -end - -module Regexp::Syntax::Token::FreeSpace - All = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::FreeSpace -end - -module Regexp::Syntax::Token::Group - All = ::T.let(nil, ::T.untyped) - Atomic = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Comment = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Named = ::T.let(nil, ::T.untyped) - Passive = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - V1_8_6 = ::T.let(nil, ::T.untyped) - V2_4_1 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Group -end - -module Regexp::Syntax::Token::Keep - All = ::T.let(nil, ::T.untyped) - Mark = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Keep -end - -module Regexp::Syntax::Token::Literal - All = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Literal -end - -module Regexp::Syntax::Token::Meta - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Meta -end - -module Regexp::Syntax::Token::PosixClass - All = ::T.let(nil, ::T.untyped) - Extensions = ::T.let(nil, ::T.untyped) - NonType = ::T.let(nil, ::T.untyped) - Standard = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::PosixClass -end - -module Regexp::Syntax::Token::Quantifier - All = ::T.let(nil, ::T.untyped) - Greedy = ::T.let(nil, ::T.untyped) - Interval = ::T.let(nil, ::T.untyped) - IntervalAll = ::T.let(nil, ::T.untyped) - IntervalPossessive = ::T.let(nil, ::T.untyped) - IntervalReluctant = ::T.let(nil, ::T.untyped) - Possessive = ::T.let(nil, ::T.untyped) - Reluctant = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Quantifier -end - -module Regexp::Syntax::Token::SubexpressionCall - All = ::T.let(nil, ::T.untyped) - Name = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::SubexpressionCall -end - -module Regexp::Syntax::Token::UnicodeProperty - Age = ::T.let(nil, ::T.untyped) - Age_V1_9_3 = ::T.let(nil, ::T.untyped) - Age_V2_0_0 = ::T.let(nil, ::T.untyped) - Age_V2_2_0 = ::T.let(nil, ::T.untyped) - Age_V2_3_0 = ::T.let(nil, ::T.untyped) - Age_V2_4_0 = ::T.let(nil, ::T.untyped) - Age_V2_5_0 = ::T.let(nil, ::T.untyped) - Age_V2_6_0 = ::T.let(nil, ::T.untyped) - Age_V2_6_2 = ::T.let(nil, ::T.untyped) - Age_V2_6_3 = ::T.let(nil, ::T.untyped) - All = ::T.let(nil, ::T.untyped) - CharType_V1_9_0 = ::T.let(nil, ::T.untyped) - CharType_V2_5_0 = ::T.let(nil, ::T.untyped) - Derived = ::T.let(nil, ::T.untyped) - Derived_V1_9_0 = ::T.let(nil, ::T.untyped) - Derived_V2_0_0 = ::T.let(nil, ::T.untyped) - Derived_V2_4_0 = ::T.let(nil, ::T.untyped) - Derived_V2_5_0 = ::T.let(nil, ::T.untyped) - Emoji = ::T.let(nil, ::T.untyped) - Emoji_V2_5_0 = ::T.let(nil, ::T.untyped) - NonType = ::T.let(nil, ::T.untyped) - POSIX = ::T.let(nil, ::T.untyped) - Script = ::T.let(nil, ::T.untyped) - Script_V1_9_0 = ::T.let(nil, ::T.untyped) - Script_V1_9_3 = ::T.let(nil, ::T.untyped) - Script_V2_0_0 = ::T.let(nil, ::T.untyped) - Script_V2_2_0 = ::T.let(nil, ::T.untyped) - Script_V2_3_0 = ::T.let(nil, ::T.untyped) - Script_V2_4_0 = ::T.let(nil, ::T.untyped) - Script_V2_5_0 = ::T.let(nil, ::T.untyped) - Script_V2_6_0 = ::T.let(nil, ::T.untyped) - Script_V2_6_2 = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - UnicodeBlock = ::T.let(nil, ::T.untyped) - UnicodeBlock_V1_9_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_0_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_2_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_3_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_4_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_5_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_6_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_6_2 = ::T.let(nil, ::T.untyped) - V1_9_0 = ::T.let(nil, ::T.untyped) - V1_9_3 = ::T.let(nil, ::T.untyped) - V2_0_0 = ::T.let(nil, ::T.untyped) - V2_2_0 = ::T.let(nil, ::T.untyped) - V2_3_0 = ::T.let(nil, ::T.untyped) - V2_4_0 = ::T.let(nil, ::T.untyped) - V2_5_0 = ::T.let(nil, ::T.untyped) - V2_6_0 = ::T.let(nil, ::T.untyped) - V2_6_2 = ::T.let(nil, ::T.untyped) - V2_6_3 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::UnicodeProperty::Category - All = ::T.let(nil, ::T.untyped) - Codepoint = ::T.let(nil, ::T.untyped) - Letter = ::T.let(nil, ::T.untyped) - Mark = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) - Punctuation = ::T.let(nil, ::T.untyped) - Separator = ::T.let(nil, ::T.untyped) - Symbol = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::UnicodeProperty::Category -end - -module Regexp::Syntax::Token::UnicodeProperty -end - -module Regexp::Syntax::Token -end - -class Regexp::Syntax::UnknownSyntaxNameError - def initialize(name); end -end - -class Regexp::Syntax::UnknownSyntaxNameError -end - -class Regexp::Syntax::V1_8_6 -end - -class Regexp::Syntax::V1_8_6 -end - -class Regexp::Syntax::V1_9 -end - -class Regexp::Syntax::V1_9 -end - -class Regexp::Syntax::V1_9_1 -end - -class Regexp::Syntax::V1_9_1 -end - -class Regexp::Syntax::V1_9_3 -end - -class Regexp::Syntax::V1_9_3 -end - -class Regexp::Syntax::V2_0_0 -end - -class Regexp::Syntax::V2_0_0 -end - -class Regexp::Syntax::V2_1 -end - -class Regexp::Syntax::V2_1 -end - -class Regexp::Syntax::V2_2 -end - -class Regexp::Syntax::V2_2 -end - -class Regexp::Syntax::V2_2_0 -end - -class Regexp::Syntax::V2_2_0 -end - -class Regexp::Syntax::V2_3 -end - -class Regexp::Syntax::V2_3 -end - -class Regexp::Syntax::V2_3_0 -end - -class Regexp::Syntax::V2_3_0 -end - -class Regexp::Syntax::V2_4 -end - -class Regexp::Syntax::V2_4 -end - -class Regexp::Syntax::V2_4_0 -end - -class Regexp::Syntax::V2_4_0 -end - -class Regexp::Syntax::V2_4_1 -end - -class Regexp::Syntax::V2_4_1 -end - -class Regexp::Syntax::V2_5 -end - -class Regexp::Syntax::V2_5 -end - -class Regexp::Syntax::V2_5_0 -end - -class Regexp::Syntax::V2_5_0 -end - -class Regexp::Syntax::V2_6_0 -end - -class Regexp::Syntax::V2_6_0 -end - -class Regexp::Syntax::V2_6_2 -end - -class Regexp::Syntax::V2_6_2 -end - -class Regexp::Syntax::V2_6_3 -end - -class Regexp::Syntax::V2_6_3 -end - -module Regexp::Syntax - def self.comparable_version(name); end - - def self.fallback_version_class(version); end - - def self.inherit_from_version(parent_version, new_version); end - - def self.new(name); end - - def self.specified_versions(); end - - def self.supported?(name); end - - def self.version_class(version); end - - def self.version_const_name(version_string); end - - def self.warn_if_future_version(const_name); end -end - -class Regexp::Token - def conditional_level(); end - - def conditional_level=(_); end - - def level(); end - - def level=(_); end - - def next(); end - - def next=(_); end - - def offset(); end - - def previous(); end - - def previous=(previous); end - - def set_level(); end - - def set_level=(_); end - - def te(); end - - def te=(_); end - - def text(); end - - def text=(_); end - - def token(); end - - def token=(_); end - - def ts(); end - - def ts=(_); end - - def type(); end - - def type=(_); end -end - -class Regexp::Token - def self.[](*_); end - - def self.members(); end -end - class Requirement def self.cask(val=T.unsafe(nil)); end @@ -37915,1893 +19393,34 @@ module Ronn def self.version(); end end -class RuboCop::AST::AliasNode - def new_identifier(); end - - def old_identifier(); end -end - -class RuboCop::AST::AliasNode -end - -class RuboCop::AST::AndNode - include ::RuboCop::AST::BinaryOperatorNode - include ::RuboCop::AST::PredicateOperatorNode - def alternate_operator(); end - - def inverse_operator(); end -end - -class RuboCop::AST::AndNode -end - -class RuboCop::AST::ArgsNode - include ::RuboCop::AST::CollectionNode - def empty_and_without_delimiters?(); end -end - -class RuboCop::AST::ArgsNode -end - -class RuboCop::AST::ArrayNode - def bracketed?(); end - - def each_value(&block); end - - def percent_literal?(type=T.unsafe(nil)); end - - def square_brackets?(); end - - def values(); end - PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::ArrayNode -end - -module RuboCop::AST::BasicLiteralNode - def value(); end -end - -module RuboCop::AST::BasicLiteralNode -end - -module RuboCop::AST::BinaryOperatorNode - def conditions(); end - - def lhs(); end - - def rhs(); end -end - -module RuboCop::AST::BinaryOperatorNode -end - -class RuboCop::AST::BlockNode - include ::RuboCop::AST::MethodIdentifierPredicates - def arguments(); end - - def arguments?(); end - - def body(); end - - def braces?(); end - - def closing_delimiter(); end - - def delimiters(); end - - def keywords?(); end - - def lambda?(); end - - def method_name(); end - - def opening_delimiter(); end - - def send_node(); end - - def void_context?(); end - VOID_CONTEXT_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::BlockNode -end - -class RuboCop::AST::BreakNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates - include ::RuboCop::AST::ParameterizedNode -end - -class RuboCop::AST::BreakNode -end - -class RuboCop::AST::Builder - NODE_MAP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::Builder -end - -class RuboCop::AST::CaseMatchNode - include ::RuboCop::AST::ConditionalNode - def each_in_pattern(); end - - def else?(); end - - def else_branch(); end - - def in_pattern_branches(); end - - def keyword(); end -end - -class RuboCop::AST::CaseMatchNode -end - -class RuboCop::AST::CaseNode - include ::RuboCop::AST::ConditionalNode - def each_when(); end - - def else?(); end - - def else_branch(); end - - def keyword(); end - - def when_branches(); end -end - -class RuboCop::AST::CaseNode -end - -class RuboCop::AST::ClassNode - def body(); end - - def identifier(); end - - def parent_class(); end -end - -class RuboCop::AST::ClassNode -end - module RuboCop::AST::CollectionNode - def &(*args, &block); end - - def *(*args, &block); end - - def +(*args, &block); end - - def -(*args, &block); end - - def <<(*args, &block); end - - def [](*args, &block); end - - def []=(*args, &block); 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 chain(*args, &block); end - - def chunk(*args, &block); end - - def chunk_while(*args, &block); end - - def clear(*args, &block); 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 difference(*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 empty?(*args, &block); end - - def entries(*args, &block); end - def extract_options!(*args, &block); end - def fetch(*args, &block); end - - def fill(*args, &block); end - - def filter(*args, &block); end - - def filter!(*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 grep(*args, &block); end - - def grep_v(*args, &block); end - - def group_by(*args, &block); end - - def include?(*args, &block); end - - def index(*args, &block); end - - def inject(*args, &block); end - - def insert(*args, &block); end - - def join(*args, &block); end - - def keep_if(*args, &block); end - - def last(*args, &block); end - - def lazy(*args, &block); end - - def length(*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(*args, &block); end - - def permutation(*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 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 save_plist(*args, &block); end - def select(*args, &block); end - - def select!(*args, &block); 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 sum(*args, &block); end - - def take(*args, &block); end - - def take_while(*args, &block); end - - def to_ary(*args, &block); end - def to_default_s(*args, &block); end def to_formatted_s(*args, &block); end - def to_h(*args, &block); end - def to_plist(*args, &block); 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 union(*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 zip(*args, &block); end - - def |(*args, &block); end - ARRAY_METHODS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::CollectionNode - extend ::Forwardable -end - -module RuboCop::AST::ConditionalNode - def body(); end - - def condition(); end - - def multiline_condition?(); end - - def single_line_condition?(); end -end - -module RuboCop::AST::ConditionalNode -end - -class RuboCop::AST::DefNode - include ::RuboCop::AST::ParameterizedNode - include ::RuboCop::AST::MethodIdentifierPredicates - def argument_forwarding?(); end - - def arguments(); end - - def body(); end - - def method_name(); end - - def receiver(); end - - def void_context?(); end -end - -class RuboCop::AST::DefNode -end - -class RuboCop::AST::DefinedNode - include ::RuboCop::AST::ParameterizedNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates -end - -class RuboCop::AST::DefinedNode -end - -class RuboCop::AST::EnsureNode - def body(); end -end - -class RuboCop::AST::EnsureNode -end - -class RuboCop::AST::FloatNode - include ::RuboCop::AST::NumericNode -end - -class RuboCop::AST::FloatNode -end - -class RuboCop::AST::ForNode - def body(); end - - def collection(); end - - def do?(); end - - def keyword(); end - - def variable(); end - - def void_context?(); end -end - -class RuboCop::AST::ForNode -end - -class RuboCop::AST::ForwardArgsNode - include ::RuboCop::AST::CollectionNode -end - -class RuboCop::AST::ForwardArgsNode -end - -module RuboCop::AST::HashElementNode - def delimiter_delta(other); end - - def key(); end - - def key_delta(other, alignment=T.unsafe(nil)); end - - def same_line?(other); end - - def value(); end - - def value_delta(other); end -end - -module RuboCop::AST::HashElementNode -end - -class RuboCop::AST::HashNode - def braces?(); end - - def each_key(); end - - def each_pair(); end - - def each_value(); end - - def empty?(); end - - def keys(); end - - def mixed_delimiters?(); end - - def pairs(); end - - def pairs_on_same_line?(); end - - def values(); end -end - -class RuboCop::AST::HashNode -end - -class RuboCop::AST::IfNode - include ::RuboCop::AST::ConditionalNode - include ::RuboCop::AST::ModifierNode - def branches(); end - - def each_branch(); end - - def else?(); end - - def else_branch(); end - - def elsif?(); end - - def elsif_conditional?(); end - - def if?(); end - - def if_branch(); end - - def inverse_keyword(); end - - def keyword(); end - - def nested_conditional?(); end - - def ternary?(); end - - def unless?(); end -end - -class RuboCop::AST::IfNode -end - -class RuboCop::AST::IntNode - include ::RuboCop::AST::NumericNode -end - -class RuboCop::AST::IntNode -end - -class RuboCop::AST::KeywordSplatNode - include ::RuboCop::AST::HashElementNode - def colon?(); end - - def hash_rocket?(); end - - def operator(); end - DOUBLE_SPLAT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::KeywordSplatNode -end - -module RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates - def access_modifier?(); end - - def adjacent_def_modifier?(node=T.unsafe(nil)); end - - def arguments(); end - - def arithmetic_operation?(); end - - def assignment?(); end - - def bare_access_modifier?(); end - - def bare_access_modifier_declaration?(node=T.unsafe(nil)); end - - def binary_operation?(); end - - def block_literal?(); end - - def block_node(); end - - def command?(name); end - - def const_receiver?(); end - - def def_modifier?(); end - - def dot?(); end - - def double_colon?(); end - - def implicit_call?(); end - - def lambda?(); end - - def lambda_literal?(); end - - def macro?(); end - - def macro_scope?(node=T.unsafe(nil)); end - - def method_name(); end - - def non_bare_access_modifier?(); end - - def non_bare_access_modifier_declaration?(node=T.unsafe(nil)); end - - def receiver(); end - - def safe_navigation?(); end - - def self_receiver?(); end - - def setter_method?(); end - - def special_modifier?(); end - - def unary_operation?(); end - ARITHMETIC_OPERATORS = ::T.let(nil, ::T.untyped) - SPECIAL_MODIFIERS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::MethodDispatchNode - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::AST::MethodIdentifierPredicates - def assignment_method?(); end - - def bang_method?(); end - - def camel_case_method?(); end - - def comparison_method?(); end - - def const_receiver?(); end - - def enumerator_method?(); end - - def method?(name); end - - def negation_method?(); end - - def operator_method?(); end - - def predicate_method?(); end - - def prefix_bang?(); end - - def prefix_not?(); end - - def self_receiver?(); end - ENUMERATOR_METHODS = ::T.let(nil, ::T.untyped) - OPERATOR_METHODS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::MethodIdentifierPredicates -end - -module RuboCop::AST::ModifierNode - def modifier_form?(); end -end - -module RuboCop::AST::ModifierNode -end - -class RuboCop::AST::ModuleNode - def body(); end - - def identifier(); end -end - -class RuboCop::AST::ModuleNode end class RuboCop::AST::Node - include ::RuboCop::AST::Sexp - include ::RuboCop::RSpec::Node - def __ENCODING___type?(); end - - def __FILE___type?(); end - - def __LINE___type?(); end - - def alias_type?(); end - - def ancestors(); end - - def and_asgn_type?(); end - - def and_type?(); end - - def arg_expr_type?(); end - - def arg_type?(); end - - def args_type?(); end - - def argument?(); end - - def array_pattern_type?(); end - - def array_pattern_with_tail_type?(); end - - def array_type?(); end - - def assignment?(); end - - def assignment_or_similar?(node=T.unsafe(nil)); end - - def back_ref_type?(); end - - def basic_conditional?(); end - - def basic_literal?(); end - - def begin_type?(); end - def block_args(node=T.unsafe(nil)); end def block_body(node=T.unsafe(nil)); end - def block_pass_type?(); end - - def block_type?(); end - - def blockarg_expr_type?(); end - - def blockarg_type?(); end - - def boolean_type?(); end - - def break_type?(); end - - def call_type?(); end - - def case_match_type?(); end - - def case_type?(); end - - def casgn_type?(); end - def cask_block?(node=T.unsafe(nil)); end - def cbase_type?(); end - - def chained?(); end - - def child_nodes(); end - - def class_constructor?(node=T.unsafe(nil)); end - - def class_type?(); end - - def complete!(); end - - def complete?(); end - - def complex_type?(); end - - def conditional?(); end - - def const_name(); end - - def const_pattern_type?(); end - - def const_type?(); end - - def csend_type?(); end - - def cvar_type?(); end - - def cvasgn_type?(); end - - def def_e_type?(); end - - def def_type?(); end - - def defined_module(); end - - def defined_module_name(); end - - def defined_type?(); end - - def defs_e_type?(); end - - def defs_type?(); end - - def descendants(); end - - def dstr_type?(); end - - def dsym_type?(); end - - def each_ancestor(*types, &block); end - - def each_child_node(*types); end - - def each_descendant(*types, &block); end - - def each_node(*types, &block); end - - def eflipflop_type?(); end - - def empty_else_type?(); end - - def empty_source?(); end - - def ensure_type?(); end - - def equals_asgn?(); end - - def erange_type?(); end - - def false_type?(); end - - def falsey_literal?(); end - - def first_line(); end - - def float_type?(); end - - def for_type?(); end - - def forward_args_type?(); end - - def forwarded_args_type?(); end - - def guard_clause?(); end - - def gvar_type?(); end - - def gvasgn_type?(); end - - def hash_pattern_type?(); end - - def hash_type?(); end - - def ident_type?(); end - - def if_guard_type?(); end - - def if_type?(); end - - def iflipflop_type?(); end - - def immutable_literal?(); end - - def in_match_type?(); end - - def in_pattern_type?(); end - - def index_type?(); end - - def indexasgn_type?(); end - - def int_type?(); end - - def irange_type?(); end - - def ivar_type?(); end - - def ivasgn_type?(); end - def key_node(node=T.unsafe(nil)); end - def keyword?(); end - - def kwarg_type?(); end - - def kwbegin_type?(); end - - def kwnilarg_type?(); end - - def kwoptarg_type?(); end - - def kwrestarg_type?(); end - - def kwsplat_type?(); end - - def lambda?(node=T.unsafe(nil)); end - - def lambda_or_proc?(node=T.unsafe(nil)); end - - def lambda_type?(); end - - def last_line(); end - - def line_count(); end - - def literal?(); end - - def lvar_type?(); end - - def lvasgn_type?(); end - - def masgn_type?(); end - - def match_alt_type?(); end - - def match_as_type?(); end - - def match_current_line_type?(); end - - def match_guard_clause?(node=T.unsafe(nil)); end - - def match_nil_pattern_type?(); end - - def match_rest_type?(); end - - def match_var_type?(); end - - def match_with_lvasgn_type?(); end - - def match_with_trailing_comma_type?(); end - def method_node(node=T.unsafe(nil)); end - def mlhs_type?(); end - - def module_type?(); end - - def mrasgn_type?(); end - - def multiline?(); end - - def mutable_literal?(); end - - def new_class_or_module_block?(node=T.unsafe(nil)); end - - def next_type?(); end - - def nil_type?(); end - - def node_parts(); end - - def nonempty_line_count(); end - - def not_type?(); end - - def nth_ref_type?(); end - - def numargs_type?(); end - - def numblock_type?(); end - - def numeric_type?(); end - - def objc_kwarg_type?(); end - - def objc_restarg_type?(); end - - def objc_varargs_type?(); end - - def op_asgn_type?(); end - - def operator_keyword?(); end - - def optarg_type?(); end - - def or_asgn_type?(); end - - def or_type?(); end - - def pair_type?(); end - - def parent(); end - - def parent=(node); end - - def parent_module_name(); end - - def parenthesized_call?(); end - - def pin_type?(); end - - def postexe_type?(); end - - def preexe_type?(); end - - def proc?(node=T.unsafe(nil)); end - - def procarg0_type?(); end - - def pure?(); end - - def range_type?(); end - - def rasgn_type?(); end - - def rational_type?(); end - - def receiver(node=T.unsafe(nil)); end - - def recursive_basic_literal?(); end - - def recursive_literal?(); end - - def redo_type?(); end - - def reference?(); end - - def regexp_type?(); end - - def regopt_type?(); end - - def resbody_type?(); end - - def rescue_type?(); end - - def restarg_expr_type?(); end - - def restarg_type?(); end - - def retry_type?(); end - - def return_type?(); end - - def root_type?(); end - - def sclass_type?(); end - - def self_type?(); end - - def send_type?(); end - - def shadowarg_type?(); end - - def shorthand_asgn?(); end - - def sibling_index(); end - - def single_line?(); end - - def source(); end - - def source_length(); end - - def source_range(); end - - def special_keyword?(); end - - def splat_type?(); end - - def str_content(node=T.unsafe(nil)); end - - def str_type?(); end - - def super_type?(); end - - def sym_type?(); end - - def true_type?(); end - - def truthy_literal?(); end - - def undef_type?(); end - - def unless_guard_type?(); end - - def until_post_type?(); end - - def until_type?(); end - def val_node(node=T.unsafe(nil)); end - - def value_used?(); end - - def variable?(); end - - def visit_descendants(types, &block); end - - def when_type?(); end - - def while_post_type?(); end - - def while_type?(); end - - def xstr_type?(); end - - def yield_type?(); end - - def zsuper_type?(); end - ASSIGNMENTS = ::T.let(nil, ::T.untyped) - BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped) - BASIC_LITERALS = ::T.let(nil, ::T.untyped) - COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped) - COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped) - CONDITIONALS = ::T.let(nil, ::T.untyped) - EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped) - FALSEY_LITERALS = ::T.let(nil, ::T.untyped) - IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - LITERALS = ::T.let(nil, ::T.untyped) - MUTABLE_LITERALS = ::T.let(nil, ::T.untyped) - OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped) - REFERENCES = ::T.let(nil, ::T.untyped) - SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped) - SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped) - TRUTHY_LITERALS = ::T.let(nil, ::T.untyped) - VARIABLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::Node - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::AST::NodePattern - def ==(other); end - - def eql?(other); end - - def initialize(str); end - - def marshal_dump(); end - - def marshal_load(pattern); end - - def match(*args); end - - def pattern(); end -end - -class RuboCop::AST::NodePattern::Invalid -end - -class RuboCop::AST::NodePattern::Invalid -end - -module RuboCop::AST::NodePattern::Macros - def def_node_matcher(method_name, pattern_str); end - - def def_node_search(method_name, pattern_str); end - - def node_search(method_name, compiler, on_match, prelude, called_from); end - - def node_search_all(method_name, compiler, called_from); end - - def node_search_body(method_name, trailing_params, prelude, match_code, on_match); end - - def node_search_first(method_name, compiler, called_from); end -end - -module RuboCop::AST::NodePattern::Macros -end - -class RuboCop::AST::NodePattern - def self.descend(element, &block); end -end - -module RuboCop::AST::NumericNode - def sign?(); end - SIGN_REGEX = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::NumericNode -end - -class RuboCop::AST::OrNode - include ::RuboCop::AST::BinaryOperatorNode - include ::RuboCop::AST::PredicateOperatorNode - def alternate_operator(); end - - def inverse_operator(); end -end - -class RuboCop::AST::OrNode -end - -class RuboCop::AST::PairNode - include ::RuboCop::AST::HashElementNode - def colon?(); end - - def delimiter(with_spacing=T.unsafe(nil)); end - - def hash_rocket?(); end - - def inverse_delimiter(with_spacing=T.unsafe(nil)); end - - def value_on_new_line?(); end - COLON = ::T.let(nil, ::T.untyped) - HASH_ROCKET = ::T.let(nil, ::T.untyped) - SPACED_COLON = ::T.let(nil, ::T.untyped) - SPACED_HASH_ROCKET = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::PairNode -end - -module RuboCop::AST::ParameterizedNode - def arguments?(); end - - def block_argument?(); end - - def first_argument(); end - - def last_argument(); end - - def parenthesized?(); end - - def rest_argument?(); end - - def splat_argument?(); end -end - -module RuboCop::AST::ParameterizedNode -end - -module RuboCop::AST::PredicateOperatorNode - def logical_operator?(); end - - def operator(); end - - def semantic_operator?(); end - LOGICAL_AND = ::T.let(nil, ::T.untyped) - LOGICAL_OR = ::T.let(nil, ::T.untyped) - SEMANTIC_AND = ::T.let(nil, ::T.untyped) - SEMANTIC_OR = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::PredicateOperatorNode -end - -class RuboCop::AST::ProcessedSource - include ::RuboCop::Ext::ProcessedSource - def [](*args); end - - def ast(); end - - def ast_with_comments(); end - - def buffer(); end - - def checksum(); end - - def commented?(source_range); end - - def comments(); end - - def comments_before_line(line); end - - def current_line(token); end - - def diagnostics(); end - - def each_comment(); end - - def each_token(); end - - def file_path(); end - - def find_comment(); end - - def find_token(); end - - def following_line(token); end - - def initialize(source, ruby_version, path=T.unsafe(nil)); end - - def line_indentation(line_number); end - - def lines(); end - - def parser_error(); end - - def path(); end - - def preceding_line(token); end - - def raw_source(); end - - def ruby_version(); end - - def start_with?(string); end - - def tokens(); end - - def valid_syntax?(); end - STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::ProcessedSource - def self.from_file(path, ruby_version); end -end - -class RuboCop::AST::RangeNode - def begin(); end - - def end(); end -end - -class RuboCop::AST::RangeNode -end - -class RuboCop::AST::RegexpNode - def content(); end - - def regopt(); end - - def to_regexp(); end - OPTIONS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::RegexpNode -end - -class RuboCop::AST::ResbodyNode - def body(); end - - def exception_variable(); end -end - -class RuboCop::AST::ResbodyNode -end - -class RuboCop::AST::RetryNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates - include ::RuboCop::AST::ParameterizedNode -end - -class RuboCop::AST::RetryNode -end - -class RuboCop::AST::ReturnNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates - include ::RuboCop::AST::ParameterizedNode -end - -class RuboCop::AST::ReturnNode -end - -class RuboCop::AST::SelfClassNode - def body(); end - - def identifier(); end -end - -class RuboCop::AST::SelfClassNode -end - -class RuboCop::AST::SendNode - include ::RuboCop::AST::ParameterizedNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates - def attribute_accessor?(node=T.unsafe(nil)); end -end - -class RuboCop::AST::SendNode -end - -module RuboCop::AST::Sexp - def s(type, *children); end -end - -module RuboCop::AST::Sexp -end - -class RuboCop::AST::StrNode - include ::RuboCop::AST::BasicLiteralNode -end - -class RuboCop::AST::StrNode -end - -class RuboCop::AST::SuperNode - include ::RuboCop::AST::ParameterizedNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates -end - -class RuboCop::AST::SuperNode -end - -class RuboCop::AST::SymbolNode - include ::RuboCop::AST::BasicLiteralNode -end - -class RuboCop::AST::SymbolNode -end - -class RuboCop::AST::Token - def begin_pos(); end - - def column(); end - - def comma?(); end - - def comment?(); end - - def end?(); end - - def end_pos(); end - - def equal_sign?(); end - - def initialize(pos, type, text); end - - def left_array_bracket?(); end - - def left_brace?(); end - - def left_bracket?(); end - - def left_curly_brace?(); end - - def left_parens?(); end - - def left_ref_bracket?(); end - - def line(); end - - def pos(); end - - def rescue_modifier?(); end - - def right_bracket?(); end - - def right_curly_brace?(); end - - def right_parens?(); end - - def semicolon?(); end - - def space_after?(); end - - def space_before?(); end - - def text(); end - - def type(); end -end - -class RuboCop::AST::Token - def self.from_parser_token(parser_token); end -end - -module RuboCop::AST::Traversal - def on_alias(node); end - - def on_and(node); end - - def on_and_asgn(node); end - - def on_arg(node); end - - def on_arg_expr(node); end - - def on_args(node); end - - def on_array(node); end - - def on_array_pattern(node); end - - def on_array_pattern_with_tail(node); end - - def on_back_ref(node); end - - def on_begin(node); end - - def on_block(node); end - - def on_block_pass(node); end - - def on_blockarg(node); end - - def on_break(node); end - - def on_case(node); end - - def on_case_match(node); end - - def on_casgn(node); end - - def on_cbase(node); end - - def on_class(node); end - - def on_complex(node); end - - def on_const(node); end - - def on_const_pattern(node); end - - def on_csend(node); end - - def on_cvar(node); end - - def on_cvasgn(node); end - - def on_def(node); end - - def on_defined?(node); end - - def on_defs(node); end - - def on_dstr(node); end - - def on_dsym(node); end - - def on_eflipflop(node); end - - def on_empty_else(node); end - - def on_ensure(node); end - - def on_erange(node); end - - def on_false(node); end - - def on_float(node); end - - def on_for(node); end - - def on_forward_args(node); end - - def on_forwarded_args(node); end - - def on_gvar(node); end - - def on_gvasgn(node); end - - def on_hash(node); end - - def on_hash_pattern(node); end - - def on_if(node); end - - def on_if_guard(node); end - - def on_iflipflop(node); end - - def on_in_match(node); end - - def on_in_pattern(node); end - - def on_int(node); end - - def on_irange(node); end - - def on_ivar(node); end - - def on_ivasgn(node); end - - def on_kwarg(node); end - - def on_kwbegin(node); end - - def on_kwoptarg(node); end - - def on_kwrestarg(node); end - - def on_kwsplat(node); end - - def on_lambda(node); end - - def on_lvar(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_match_alt(node); end - - def on_match_as(node); end - - def on_match_current_line(node); end - - def on_match_nil_pattern(node); end - - def on_match_rest(node); end - - def on_match_var(node); end - - def on_match_with_lvasgn(node); end - - def on_match_with_trailing_comma(node); end - - def on_mlhs(node); end - - def on_module(node); end - - def on_next(node); end - - def on_nil(node); end - - def on_not(node); end - - def on_nth_ref(node); end - - def on_numblock(node); end - - def on_op_asgn(node); end - - def on_optarg(node); end - - def on_or(node); end - - def on_or_asgn(node); end - - def on_pair(node); end - - def on_pin(node); end - - def on_postexe(node); end - - def on_preexe(node); end - - def on_rational(node); end - - def on_redo(node); end - - def on_regexp(node); end - - def on_regopt(node); end - - def on_resbody(node); end - - def on_rescue(node); end - - def on_restarg(node); end - - def on_retry(node); end - - def on_return(node); end - - def on_sclass(node); end - - def on_self(node); end - - def on_send(node); end - - def on_shadowarg(node); end - - def on_splat(node); end - - def on_str(node); end - - def on_super(node); end - - def on_sym(node); end - - def on_true(node); end - - def on_undef(node); end - - def on_unless_guard(node); end - - def on_until(node); end - - def on_until_post(node); end - - def on_when(node); end - - def on_while(node); end - - def on_while_post(node); end - - def on_xstr(node); end - - def on_yield(node); end - - def on_zsuper(node); end - - def walk(node); end - MANY_CHILD_NODES = ::T.let(nil, ::T.untyped) - NO_CHILD_NODES = ::T.let(nil, ::T.untyped) - ONE_CHILD_NODE = ::T.let(nil, ::T.untyped) - SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::Traversal -end - -class RuboCop::AST::UntilNode - include ::RuboCop::AST::ConditionalNode - include ::RuboCop::AST::ModifierNode - def do?(); end - - def inverse_keyword(); end - - def keyword(); end -end - -class RuboCop::AST::UntilNode -end - -module RuboCop::AST::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::Version -end - -class RuboCop::AST::WhenNode - def body(); end - - def branch_index(); end - - def conditions(); end - - def each_condition(); end - - def then?(); end -end - -class RuboCop::AST::WhenNode -end - -class RuboCop::AST::WhileNode - include ::RuboCop::AST::ConditionalNode - include ::RuboCop::AST::ModifierNode - def do?(); end - - def inverse_keyword(); end - - def keyword(); end -end - -class RuboCop::AST::WhileNode -end - -class RuboCop::AST::YieldNode - include ::RuboCop::AST::ParameterizedNode - include ::RuboCop::AST::MethodDispatchNode - include ::RuboCop::AST::MethodIdentifierPredicates -end - -class RuboCop::AST::YieldNode -end - -class RuboCop::CLI - def config_store(); end - - def options(); end - - def run(args=T.unsafe(nil)); end - STATUS_ERROR = ::T.let(nil, ::T.untyped) - STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped) - STATUS_OFFENSES = ::T.let(nil, ::T.untyped) - STATUS_SUCCESS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::CLI::Command -end - -class RuboCop::CLI::Command::AutoGenerateConfig - def run(); end - PHASE_1 = ::T.let(nil, ::T.untyped) - PHASE_1_DISABLED = ::T.let(nil, ::T.untyped) - PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped) - PHASE_2 = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::AutoGenerateConfig -end - -class RuboCop::CLI::Command::Base - def env(); end - - def initialize(env); end -end - -class RuboCop::CLI::Command::Base - def self.by_command_name(name); end - - def self.command_name(); end - - def self.command_name=(command_name); end - - def self.inherited(subclass); end -end - -class RuboCop::CLI::Command::ExecuteRunner - include ::RuboCop::Formatter::TextUtil - def run(); end -end - -class RuboCop::CLI::Command::ExecuteRunner -end - -class RuboCop::CLI::Command::InitDotfile - def run(); end - DOTFILE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::InitDotfile -end - -class RuboCop::CLI::Command::ShowCops - def run(); end -end - -class RuboCop::CLI::Command::ShowCops -end - -class RuboCop::CLI::Command::Version - def run(); end -end - -class RuboCop::CLI::Command::Version -end - -module RuboCop::CLI::Command - def self.run(env, name); end -end - -class RuboCop::CLI::Environment - def config_store(); end - - def initialize(options, config_store, paths); end - - def options(); end - - def paths(); end - - def run(name); end -end - -class RuboCop::CLI::Environment -end - -class RuboCop::CLI::Finished -end - -class RuboCop::CLI::Finished -end - -class RuboCop::CLI -end - -class RuboCop::CachedData - def from_json(text); end - - def initialize(filename); end - - def to_json(offenses); end -end - -class RuboCop::CachedData end class RuboCop::Cask::AST::CaskBlock @@ -39892,439 +19511,6 @@ class RuboCop::Cask::AST::Stanza def zap?(); end end -class RuboCop::CommentConfig - def cop_disabled_line_ranges(); end - - def cop_enabled_at_line?(cop, line_number); end - - def extra_enabled_comments(); end - - def initialize(processed_source); end - - def processed_source(); end - COMMENT_DIRECTIVE_REGEXP = ::T.let(nil, ::T.untyped) - COPS_PATTERN = ::T.let(nil, ::T.untyped) - COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped) - COP_NAME_PATTERN = ::T.let(nil, ::T.untyped) - REDUNDANT_DISABLE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CommentConfig::CopAnalysis - def line_ranges(); end - - def line_ranges=(_); end - - def start_line_number(); end - - def start_line_number=(_); end -end - -class RuboCop::CommentConfig::CopAnalysis - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::CommentConfig -end - -class RuboCop::Config - include ::RuboCop::PathUtil - include ::RuboCop::FileFinder - def [](*args, &block); end - - def []=(*args, &block); end - - def add_excludes_from_higher_level(highest_config); end - - def allowed_camel_case_file?(file); end - - def base_dir_for_path_parameters(); end - - def bundler_lock_file_path(); end - - def check(); end - - def delete(*args, &block); end - - def deprecation_check(); end - - def disabled_new_cops?(); end - - def each(*args, &block); end - - def each_key(*args, &block); end - - def enabled_new_cops?(); end - - def file_to_exclude?(file); end - - def file_to_include?(file); end - - def for_all_cops(); end - - def for_cop(cop); end - - def for_department(department_name); end - - def initialize(hash=T.unsafe(nil), loaded_path=T.unsafe(nil)); end - - def internal?(); end - - def key?(*args, &block); end - - def keys(*args, &block); end - - def loaded_path(); end - - def make_excludes_absolute(); end - - def map(*args, &block); end - - def merge(*args, &block); end - - def path_relative_to_config(path); end - - def patterns_to_exclude(); end - - def patterns_to_include(); end - - def pending_cops(); end - - def possibly_include_hidden?(); end - - def signature(); end - - def smart_loaded_path(); end - - def target_rails_version(); end - - def target_ruby_version(*args, &block); end - - def to_h(*args, &block); end - - def to_hash(*args, &block); end - - def transform_values(*args, &block); end - - def validate(*args, &block); end - DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Config::CopConfig - def metadata(); end - - def metadata=(_); end - - def name(); end - - def name=(_); end -end - -class RuboCop::Config::CopConfig - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Config - extend ::Forwardable - def self.create(hash, path); end -end - -class RuboCop::ConfigLoader - AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped) - DEFAULT_FILE = ::T.let(nil, ::T.untyped) - DOTFILE = ::T.let(nil, ::T.untyped) - RUBOCOP_HOME = ::T.let(nil, ::T.untyped) - XDG_CONFIG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigLoader - extend ::RuboCop::FileFinder - def self.add_excludes_from_files(config, config_file); end - - def self.add_inheritance_from_auto_generated_file(); end - - def self.add_missing_namespaces(path, hash); end - - def self.auto_gen_config(); end - - def self.auto_gen_config=(auto_gen_config); end - - def self.auto_gen_config?(); end - - def self.clear_options(); end - - def self.configuration_file_for(target_dir); end - - def self.configuration_from_file(config_file); end - - def self.debug(); end - - def self.debug=(debug); end - - def self.debug?(); end - - def self.default_configuration(); end - - def self.default_configuration=(default_configuration); end - - def self.disable_pending_cops(); end - - def self.disable_pending_cops=(disable_pending_cops); end - - def self.enable_pending_cops(); end - - def self.enable_pending_cops=(enable_pending_cops); end - - def self.ignore_parent_exclusion(); end - - def self.ignore_parent_exclusion=(ignore_parent_exclusion); end - - def self.ignore_parent_exclusion?(); end - - def self.load_file(file); end - - def self.merge(base_hash, derived_hash); end - - def self.merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end - - def self.options_config(); end - - def self.options_config=(options_config); end - - def self.possible_new_cops?(config); end - - def self.warn_on_pending_cops(pending_cops); end -end - -class RuboCop::ConfigLoaderResolver - def merge(base_hash, derived_hash, **opts); end - - def merge_with_default(config, config_file, unset_nil:); end - - def override_department_setting_for_cops(base_hash, derived_hash); end - - def resolve_inheritance(path, hash, file, debug); end - - def resolve_inheritance_from_gems(hash); end - - def resolve_requires(path, hash); end -end - -class RuboCop::ConfigLoaderResolver -end - -class RuboCop::ConfigNotFoundError -end - -class RuboCop::ConfigNotFoundError -end - -class RuboCop::ConfigObsoletion - def initialize(config); end - - def reject_obsolete_cops_and_parameters(); end - MOVED_COPS = ::T.let(nil, ::T.untyped) - OBSOLETE_COPS = ::T.let(nil, ::T.untyped) - OBSOLETE_ENFORCED_STYLES = ::T.let(nil, ::T.untyped) - OBSOLETE_PARAMETERS = ::T.let(nil, ::T.untyped) - REMOVED_COPS = ::T.let(nil, ::T.untyped) - REMOVED_COPS_WITH_REASON = ::T.let(nil, ::T.untyped) - RENAMED_COPS = ::T.let(nil, ::T.untyped) - SPLIT_COPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigObsoletion -end - -class RuboCop::ConfigStore - def for(file_or_dir); end - - def for_dir(dir); end - - def for_file(file); end - - def force_default_config!(); end - - def options_config=(options_config); end -end - -class RuboCop::ConfigStore -end - -class RuboCop::ConfigValidator - def for_all_cops(*args, &block); end - - def initialize(config); end - - def smart_loaded_path(*args, &block); end - - def target_ruby_version(); end - - def validate(); end - - def validate_section_presence(name); end - COMMON_PARAMS = ::T.let(nil, ::T.untyped) - INTERNAL_PARAMS = ::T.let(nil, ::T.untyped) - NEW_COPS_VALUES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigValidator - extend ::Forwardable -end - -module RuboCop::Cop::Alignment - SPACE = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Alignment -end - -class RuboCop::Cop::AlignmentCorrector -end - -class RuboCop::Cop::AlignmentCorrector - extend ::RuboCop::Cop::RangeHelp - extend ::RuboCop::Cop::Alignment - def self.align_end(processed_source, node, align_to); end - - def self.correct(processed_source, node, column_delta); end - - def self.processed_source(); end -end - -class RuboCop::Cop::AmbiguousCopName - def initialize(name, origin, badges); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::AmbiguousCopName -end - -module RuboCop::Cop::ArrayMinSize -end - -module RuboCop::Cop::ArrayMinSize -end - -module RuboCop::Cop::ArraySyntax -end - -module RuboCop::Cop::ArraySyntax -end - -module RuboCop::Cop::AutocorrectLogic - def autocorrect?(); end - - def autocorrect_enabled?(); end - - def autocorrect_requested?(); end - - def correctable?(); end - - def disable_offense(node); end - - def disable_uncorrectable?(); end - - def safe_autocorrect?(); end - - def support_autocorrect?(); end -end - -module RuboCop::Cop::AutocorrectLogic -end - -class RuboCop::Cop::Badge - def ==(other); end - - def cop_name(); end - - def department(); end - - def eql?(other); end - - def initialize(department, cop_name); end - - def match?(other); end - - def qualified?(); end - - def with_department(department); end -end - -class RuboCop::Cop::Badge::InvalidBadge - def initialize(token); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Badge::InvalidBadge -end - -class RuboCop::Cop::Badge - def self.for(class_name); end - - def self.parse(identifier); end -end - -module RuboCop::Cop::Bundler -end - -class RuboCop::Cop::Bundler::DuplicatedGem - include ::RuboCop::Cop::RangeHelp - def gem_declarations(node0); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::DuplicatedGem -end - -class RuboCop::Cop::Bundler::GemComment - include ::RuboCop::Cop::DefNode - def gem_declaration?(node=T.unsafe(nil)); end - - def on_send(node); end - CHECKED_OPTIONS_CONFIG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - VERSION_SPECIFIERS_OPTION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::GemComment -end - -class RuboCop::Cop::Bundler::InsecureProtocolSource - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def insecure_protocol_source?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::InsecureProtocolSource -end - -class RuboCop::Cop::Bundler::OrderedGems - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::OrderedGemNode - def autocorrect(node); end - - def gem_declarations(node0); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::OrderedGems -end - -module RuboCop::Cop::Bundler -end - class RuboCop::Cop::Cask::HomepageMatchesUrl def cask_node(*args, &block); end @@ -40346,7 +19532,6 @@ module RuboCop::Cop::Cask::OnHomepageStanza end class RuboCop::Cop::Cask::StanzaGrouping - include ::RuboCop::Cop::RangeHelp def cask_node(*args, &block); end def toplevel_stanzas(*args, &block); end @@ -40360,392 +19545,10 @@ class RuboCop::Cop::Cask::StanzaOrder def toplevel_stanzas(*args, &block); end end -module RuboCop::Cop::CheckAssignment - def on_and_asgn(node); end - - def on_casgn(node); end - - def on_cvasgn(node); end - - def on_gvasgn(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_op_asgn(node); end - - def on_or_asgn(node); end - - def on_send(node); end -end - -module RuboCop::Cop::CheckAssignment - def self.extract_rhs(node); end -end - -module RuboCop::Cop::CheckLineBreakable - def extract_breakable_node(node, max); end -end - -module RuboCop::Cop::CheckLineBreakable -end - -module RuboCop::Cop::ClassishLength - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax -end - -module RuboCop::Cop::ClassishLength -end - -module RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax -end - -module RuboCop::Cop::CodeLength -end - -class RuboCop::Cop::Commissioner - include ::RuboCop::AST::Traversal - def errors(); end - - def initialize(cops, forces=T.unsafe(nil), options=T.unsafe(nil)); end - - def investigate(processed_source); end -end - -class RuboCop::Cop::Commissioner -end - -class RuboCop::Cop::ConditionCorrector -end - -class RuboCop::Cop::ConditionCorrector - def self.correct_negative_condition(node); end -end - -module RuboCop::Cop::ConfigurableEnforcedStyle - def alternative_style(); end - - def alternative_styles(); end - - def ambiguous_style_detected(*possibilities); end - - def conflicting_styles_detected(); end - - def correct_style_detected(); end - - def detected_style(); end - - def detected_style=(style); end - - def no_acceptable_style!(); end - - def no_acceptable_style?(); end - - def opposite_style_detected(); end - - def style(); end - - def style_configured?(); end - - def style_detected(detected); end - - def style_parameter_name(); end - - def supported_styles(); end - - def unexpected_style_detected(unexpected); end - - def unrecognized_style_detected(); end -end - -module RuboCop::Cop::ConfigurableEnforcedStyle -end - -module RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def check_name(node, name, name_range); end - - def class_emitter_method?(node, name); end - - def report_opposing_styles(node, name); end - - def valid_name?(node, name, given_style=T.unsafe(nil)); end -end - -module RuboCop::Cop::ConfigurableFormatting -end - -module RuboCop::Cop::ConfigurableMax -end - -module RuboCop::Cop::ConfigurableMax -end - -module RuboCop::Cop::ConfigurableNaming - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - FORMATS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::ConfigurableNaming -end - -module RuboCop::Cop::ConfigurableNumbering - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - FORMATS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::ConfigurableNumbering -end - class RuboCop::Cop::Cop - include ::RuboCop::AST::Sexp - include ::RuboCop::Cop::Util - include ::RuboCop::PathUtil - include ::RuboCop::Cop::IgnoredNode - include ::RuboCop::Cop::AutocorrectLogic - def add_offense(node, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil)); end - - def config(); end - - def config_to_allow_offenses(); end - - def config_to_allow_offenses=(hash); end - - def cop_config(); end - - def cop_name(); end - - def correct(node); end - - def corrections(); end - - def disable_uncorrectable(node); end - - def duplicate_location?(location); end - - def excluded_file?(file); end - - def external_dependency_checksum(); end - - def find_location(node, loc); end - def highlights(); end - def initialize(config=T.unsafe(nil), options=T.unsafe(nil)); end - - def join_force?(_force_class); end - - def message(_node=T.unsafe(nil)); end - def messages(); end - - def name(); end - - def offenses(); end - - def parse(source, path=T.unsafe(nil)); end - - def processed_source(); end - - def processed_source=(processed_source); end - - def reason_to_not_correct(node); end - - def relevant_file?(file); end - - def target_rails_version(); end - - def target_ruby_version(); end -end - -class RuboCop::Cop::Cop::Correction - def call(corrector); end - - def cop(); end - - def cop=(_); end - - def lambda=(_); end - - def node(); end - - def node=(_); end -end - -class RuboCop::Cop::Cop::Correction - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Cop::Cop - extend ::RuboCop::AST::Sexp - extend ::RuboCop::AST::NodePattern::Macros - def self.all(); end - - def self.autocorrect_incompatible_with(); end - - def self.badge(); end - - def self.cop_name(); end - - def self.department(); end - - def self.exclude_from_registry(); end - - def self.inherited(subclass); end - - def self.lint?(); end - - def self.match?(given_names); end - - def self.qualified_cop_name(name, origin); end - - def self.registry(); end -end - -class RuboCop::Cop::Corrector - def corrections(); end - - def diagnostics(); end - - def initialize(source_buffer, corrections=T.unsafe(nil)); end - - def insert_after(node_or_range, content); end - - def insert_before(node_or_range, content); end - - def remove(node_or_range); end - - def remove_leading(node_or_range, size); end - - def remove_preceding(node_or_range, size); end - - def remove_trailing(node_or_range, size); end - - def replace(node_or_range, content); end - - def rewrite(); end - - def wrap(node_or_range, before, after); end -end - -class RuboCop::Cop::Corrector -end - -module RuboCop::Cop::DefNode - def non_public_modifier?(node=T.unsafe(nil)); end - NON_PUBLIC_MODIFIERS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::DefNode - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::DocumentationComment - include ::RuboCop::Cop::Style::AnnotationComment -end - -module RuboCop::Cop::DocumentationComment - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::Duplication -end - -module RuboCop::Cop::Duplication -end - -class RuboCop::Cop::EachToForCorrector - def call(corrector); end - - def initialize(block_node); end - CORRECTION_WITHOUT_ARGUMENTS = ::T.let(nil, ::T.untyped) - CORRECTION_WITH_ARGUMENTS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::EachToForCorrector - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::EmptyLineCorrector -end - -class RuboCop::Cop::EmptyLineCorrector - def self.correct(node); end - - def self.insert_before(node); end -end - -module RuboCop::Cop::EmptyParameter - def empty_arguments?(node=T.unsafe(nil)); end -end - -module RuboCop::Cop::EmptyParameter - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::EndKeywordAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::EndKeywordAlignment -end - -module RuboCop::Cop::EnforceSuperclass - def on_class(node); end - - def on_send(node); end -end - -module RuboCop::Cop::EnforceSuperclass - def self.included(base); end -end - -module RuboCop::Cop::FirstElementLineBreak -end - -module RuboCop::Cop::FirstElementLineBreak -end - -class RuboCop::Cop::ForToEachCorrector - def call(corrector); end - - def initialize(for_node); end - CORRECTION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::ForToEachCorrector - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::Force - def cops(); end - - def initialize(cops); end - - def investigate(_processed_source); end - - def name(); end - - def run_hook(method_name, *args); end -end - -class RuboCop::Cop::Force - def self.all(); end - - def self.force_name(); end - - def self.inherited(subclass); end end class RuboCop::Cop::FormulaAudit::ComponentsOrder @@ -40789,7 +19592,6 @@ class RuboCop::Cop::FormulaAudit::Test end class RuboCop::Cop::FormulaCop - include ::RuboCop::Cop::RangeHelp def dependency_name_hash_match?(node0, param1); end def dependency_type_hash_match?(node0, param1); end @@ -40799,9375 +19601,6 @@ class RuboCop::Cop::FormulaCop def required_dependency_name?(node0, param1); end end -module RuboCop::Cop::FrozenStringLiteral - FROZEN_STRING_LITERAL = ::T.let(nil, ::T.untyped) - FROZEN_STRING_LITERAL_ENABLED = ::T.let(nil, ::T.untyped) - FROZEN_STRING_LITERAL_TYPES = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::FrozenStringLiteral - def self.frozen_string_literal_comment_exists?(); end -end - -module RuboCop::Cop::Gemspec -end - -class RuboCop::Cop::Gemspec::DuplicatedAssignment - include ::RuboCop::Cop::RangeHelp - def assignment_method_declarations(node0); end - - def gem_specification(node0); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::DuplicatedAssignment -end - -class RuboCop::Cop::Gemspec::OrderedDependencies - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::OrderedGemNode - def autocorrect(node); end - - def dependency_declarations(node0); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::OrderedDependencies -end - -class RuboCop::Cop::Gemspec::RequiredRubyVersion - def investigate(processed_source); end - - def required_ruby_version(node0); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::RequiredRubyVersion -end - -class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage - def gem_specification?(node0); end - - def on_const(node); end - - def ruby_version?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage -end - -module RuboCop::Cop::Gemspec -end - -class RuboCop::Cop::Generator - def initialize(name, github_user, output: T.unsafe(nil)); end - - def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end - - def inject_require(root_file_path: T.unsafe(nil)); end - - def todo(); end - - def write_source(); end - - def write_spec(); end - CONFIGURATION_ADDED_MESSAGE = ::T.let(nil, ::T.untyped) - SOURCE_TEMPLATE = ::T.let(nil, ::T.untyped) - SPEC_TEMPLATE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator::ConfigurationInjector - def initialize(configuration_file_path:, badge:, version_added:); end - - def inject(); end - TEMPLATE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator::ConfigurationInjector -end - -class RuboCop::Cop::Generator::RequireFileInjector - def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end - - def inject(); end - REQUIRE_PATH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator::RequireFileInjector -end - -class RuboCop::Cop::Generator -end - -module RuboCop::Cop::HashAlignmentStyles -end - -class RuboCop::Cop::HashAlignmentStyles::KeyAlignment - def checkable_layout?(_node); end - - def deltas(first_pair, current_pair); end - - def deltas_for_first_pair(first_pair, _node); end -end - -class RuboCop::Cop::HashAlignmentStyles::KeyAlignment -end - -class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment - include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment - def deltas_for_first_pair(*_nodes); end -end - -class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment -end - -class RuboCop::Cop::HashAlignmentStyles::TableAlignment - include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment - def deltas_for_first_pair(first_pair, node); end -end - -class RuboCop::Cop::HashAlignmentStyles::TableAlignment -end - -module RuboCop::Cop::HashAlignmentStyles::ValueAlignment - def checkable_layout?(node); end - - def deltas(first_pair, current_pair); end -end - -module RuboCop::Cop::HashAlignmentStyles::ValueAlignment -end - -module RuboCop::Cop::HashAlignmentStyles -end - -module RuboCop::Cop::HashTransformMethod - def autocorrect(node); end - - def on_block(node); end - - def on_csend(node); end - - def on_send(node); end -end - -class RuboCop::Cop::HashTransformMethod::Autocorrection - def block_node(); end - - def block_node=(_); end - - def leading(); end - - def leading=(_); end - - def match(); end - - def match=(_); end - - def set_new_arg_name(transformed_argname, corrector); end - - def set_new_body_expression(transforming_body_expr, corrector); end - - def set_new_method_name(new_method_name, corrector); end - - def strip_prefix_and_suffix(node, corrector); end - - def trailing(); end - - def trailing=(_); end -end - -class RuboCop::Cop::HashTransformMethod::Autocorrection - def self.[](*_); end - - def self.from_each_with_object(node, match); end - - def self.from_hash_brackets_map(node, match); end - - def self.from_map_to_h(node, match); end - - def self.members(); end -end - -class RuboCop::Cop::HashTransformMethod::Captures - def noop_transformation?(); end - - def transformation_uses_both_args?(); end - - def transformed_argname(); end - - def transformed_argname=(_); end - - def transforming_body_expr(); end - - def transforming_body_expr=(_); end - - def unchanged_body_expr(); end - - def unchanged_body_expr=(_); end -end - -class RuboCop::Cop::HashTransformMethod::Captures - def self.[](*_); end - - def self.members(); end -end - -module RuboCop::Cop::HashTransformMethod -end - -module RuboCop::Cop::Heredoc - def on_dstr(node); end - - def on_heredoc(_node); end - - def on_str(node); end - - def on_xstr(node); end - OPENING_DELIMITER = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Heredoc -end - -module RuboCop::Cop::IgnoredMethods -end - -module RuboCop::Cop::IgnoredMethods -end - -module RuboCop::Cop::IgnoredNode - def ignore_node(node); end - - def ignored_node?(node); end - - def part_of_ignored_node?(node); end -end - -module RuboCop::Cop::IgnoredNode -end - -module RuboCop::Cop::IgnoredPattern -end - -module RuboCop::Cop::IgnoredPattern -end - -module RuboCop::Cop::IntegerNode -end - -module RuboCop::Cop::IntegerNode -end - -module RuboCop::Cop::Interpolation - def on_dstr(node); end - - def on_dsym(node); end - - def on_node_with_interpolations(node); end - - def on_regexp(node); end - - def on_xstr(node); end -end - -module RuboCop::Cop::Interpolation -end - -class RuboCop::Cop::LambdaLiteralToMethodCorrector - def call(corrector); end - - def initialize(block_node); end -end - -class RuboCop::Cop::LambdaLiteralToMethodCorrector -end - -module RuboCop::Cop::Layout -end - -class RuboCop::Cop::Layout::AccessModifierIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def on_class(node); end - - def on_module(node); end - - def on_sclass(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::AccessModifierIndentation -end - -class RuboCop::Cop::Layout::ArgumentAlignment - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ArgumentAlignment -end - -class RuboCop::Cop::Layout::ArrayAlignment - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_array(node); end - ALIGN_ELEMENTS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ArrayAlignment -end - -class RuboCop::Cop::Layout::AssignmentIndentation - include ::RuboCop::Cop::CheckAssignment - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def check_assignment(node, rhs); end - - def leftmost_multiple_assignment(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::AssignmentIndentation -end - -class RuboCop::Cop::Layout::BlockAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def block_end_align_target?(node=T.unsafe(nil), param1); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::BlockAlignment -end - -class RuboCop::Cop::Layout::BlockEndNewline - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::BlockEndNewline -end - -class RuboCop::Cop::Layout::CaseIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_case(case_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::CaseIndentation -end - -class RuboCop::Cop::Layout::ClassStructure - def autocorrect(node); end - - def on_class(class_node); end - - def visibility_block?(node=T.unsafe(nil)); end - HUMANIZED_NODE_TYPE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClassStructure -end - -class RuboCop::Cop::Layout::ClosingHeredocIndentation - include ::RuboCop::Cop::Heredoc - def autocorrect(node); end - - def on_heredoc(node); end - MSG = ::T.let(nil, ::T.untyped) - MSG_ARG = ::T.let(nil, ::T.untyped) - SIMPLE_HEREDOC = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClosingHeredocIndentation -end - -class RuboCop::Cop::Layout::ClosingParenthesisIndentation - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_begin(node); end - - def on_csend(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end - MSG_ALIGN = ::T.let(nil, ::T.untyped) - MSG_INDENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClosingParenthesisIndentation -end - -class RuboCop::Cop::Layout::CommentIndentation - include ::RuboCop::Cop::Alignment - def autocorrect(comment); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::CommentIndentation -end - -class RuboCop::Cop::Layout::ConditionPosition - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_if(node); end - - def on_until(node); end - - def on_while(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ConditionPosition -end - -class RuboCop::Cop::Layout::DefEndAlignment - include ::RuboCop::Cop::EndKeywordAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::DefEndAlignment -end - -class RuboCop::Cop::Layout::DotPosition - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end -end - -class RuboCop::Cop::Layout::DotPosition -end - -class RuboCop::Cop::Layout::ElseAlignment - include ::RuboCop::Cop::EndKeywordAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::CheckAssignment - def autocorrect(node); end - - def on_case(node); end - - def on_case_match(node); end - - def on_if(node, base=T.unsafe(nil)); end - - def on_rescue(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ElseAlignment -end - -class RuboCop::Cop::Layout::EmptyComment - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyComment -end - -class RuboCop::Cop::Layout::EmptyLineAfterGuardClause - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_if(node); end - END_OF_HEREDOC_LINE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineAfterGuardClause -end - -class RuboCop::Cop::Layout::EmptyLineAfterMagicComment - include ::RuboCop::Cop::RangeHelp - def autocorrect(token); end - - def investigate(source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineAfterMagicComment -end - -class RuboCop::Cop::Layout::EmptyLineBetweenDefs - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def check_defs(nodes); end - - def on_begin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineBetweenDefs -end - -class RuboCop::Cop::Layout::EmptyLines - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - LINE_OFFSET = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLines -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def on_class(node); end - - def on_module(node); end - - def on_sclass(node); end - - def on_send(node); end - MSG_AFTER = ::T.let(nil, ::T.untyped) - MSG_AFTER_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) - MSG_BEFORE_AND_AFTER = ::T.let(nil, ::T.untyped) - MSG_BEFORE_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier -end - -class RuboCop::Cop::Layout::EmptyLinesAroundArguments - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundArguments -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_kwbegin(node); end - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody -end - -module RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def constant_definition?(node=T.unsafe(nil)); end - - def empty_line_required?(node=T.unsafe(nil)); end - MSG_DEFERRED = ::T.let(nil, ::T.untyped) - MSG_EXTRA = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Layout::EmptyLinesAroundBody - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::Layout::EmptyLinesAroundClassBody - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_class(node); end - - def on_sclass(node); end - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundClassBody -end - -class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_kwbegin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords -end - -class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody -end - -class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody - include ::RuboCop::Cop::Layout::EmptyLinesAroundBody - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_module(node); end - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody -end - -class RuboCop::Cop::Layout::EndAlignment - include ::RuboCop::Cop::CheckAssignment - include ::RuboCop::Cop::EndKeywordAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_case(node); end - - def on_class(node); end - - def on_if(node); end - - def on_module(node); end - - def on_until(node); end - - def on_while(node); end -end - -class RuboCop::Cop::Layout::EndAlignment -end - -class RuboCop::Cop::Layout::EndOfLine - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - - def offense_message(line); end - - def unimportant_missing_cr?(index, last_line, line); end - MSG_DETECTED = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EndOfLine -end - -class RuboCop::Cop::Layout::ExtraSpacing - include ::RuboCop::Cop::PrecedingFollowingAlignment - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped) - MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ExtraSpacing -end - -class RuboCop::Cop::Layout::FirstArgumentIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def eligible_method_call?(node=T.unsafe(nil)); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArgumentIndentation -end - -class RuboCop::Cop::Layout::FirstArrayElementIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::MultilineElementIndentation - def autocorrect(node); end - - def on_array(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArrayElementIndentation -end - -class RuboCop::Cop::Layout::FirstArrayElementLineBreak - include ::RuboCop::Cop::FirstElementLineBreak - def autocorrect(node); end - - def on_array(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArrayElementLineBreak -end - -class RuboCop::Cop::Layout::FirstHashElementIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::MultilineElementIndentation - def autocorrect(node); end - - def on_csend(node); end - - def on_hash(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstHashElementIndentation -end - -class RuboCop::Cop::Layout::FirstHashElementLineBreak - include ::RuboCop::Cop::FirstElementLineBreak - def autocorrect(node); end - - def on_hash(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstHashElementLineBreak -end - -class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak - include ::RuboCop::Cop::FirstElementLineBreak - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - - def on_super(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak -end - -class RuboCop::Cop::Layout::FirstMethodParameterLineBreak - include ::RuboCop::Cop::FirstElementLineBreak - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstMethodParameterLineBreak -end - -class RuboCop::Cop::Layout::FirstParameterIndentation - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::MultilineElementIndentation - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstParameterIndentation -end - -class RuboCop::Cop::Layout::HashAlignment - include ::RuboCop::Cop::HashAlignmentStyles - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def column_deltas(); end - - def column_deltas=(column_deltas); end - - def offences_by(); end - - def offences_by=(offences_by); end - - def on_hash(node); end - - def on_send(node); end - - def on_super(node); end - - def on_yield(node); end - MESSAGES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HashAlignment -end - -class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis -end - -class RuboCop::Cop::Layout::HeredocIndentation - include ::RuboCop::Cop::Heredoc - def autocorrect(node); end - - def on_heredoc(node); end - TYPE_MSG = ::T.let(nil, ::T.untyped) - WIDTH_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HeredocIndentation -end - -class RuboCop::Cop::Layout::IndentationConsistency - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_begin(node); end - - def on_kwbegin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationConsistency -end - -class RuboCop::Cop::Layout::IndentationStyle - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationStyle -end - -class RuboCop::Cop::Layout::IndentationWidth - include ::RuboCop::Cop::EndKeywordAlignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::CheckAssignment - include ::RuboCop::Cop::IgnoredPattern - def access_modifier?(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def on_block(node); end - - def on_case(case_node); end - - def on_class(node); end - - def on_csend(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_ensure(node); end - - def on_for(node); end - - def on_if(node, base=T.unsafe(nil)); end - - def on_kwbegin(node); end - - def on_module(node); end - - def on_resbody(node); end - - def on_rescue(node); end - - def on_sclass(node); end - - def on_until(node, base=T.unsafe(nil)); end - - def on_while(node, base=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationWidth -end - -class RuboCop::Cop::Layout::InitialIndentation - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(_processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::InitialIndentation -end - -class RuboCop::Cop::Layout::LeadingCommentSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(comment); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LeadingCommentSpace -end - -class RuboCop::Cop::Layout::LeadingEmptyLines - def autocorrect(node); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LeadingEmptyLines -end - -class RuboCop::Cop::Layout::LineLength - include ::RuboCop::Cop::CheckLineBreakable - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IgnoredPattern - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::LineLengthHelp - def autocorrect(range); end - - def investigate(processed_source); end - - def investigate_post_walk(processed_source); end - - def on_array(node); end - - def on_block(node); end - - def on_hash(node); end - - def on_potential_breakable_node(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LineLength -end - -class RuboCop::Cop::Layout::MultilineArrayBraceLayout - include ::RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_array(node); end - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineArrayBraceLayout -end - -class RuboCop::Cop::Layout::MultilineArrayLineBreaks - include ::RuboCop::Cop::MultilineElementLineBreaks - def autocorrect(node); end - - def on_array(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineArrayLineBreaks -end - -class RuboCop::Cop::Layout::MultilineAssignmentLayout - include ::RuboCop::Cop::CheckAssignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def check_assignment(node, rhs); end - - def check_by_enforced_style(node, rhs); end - - def check_new_line_offense(node, rhs); end - - def check_same_line_offense(node, rhs); end - NEW_LINE_OFFENSE = ::T.let(nil, ::T.untyped) - SAME_LINE_OFFENSE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineAssignmentLayout -end - -class RuboCop::Cop::Layout::MultilineBlockLayout - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - ARG_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PIPE_SIZE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineBlockLayout -end - -class RuboCop::Cop::Layout::MultilineHashBraceLayout - include ::RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_hash(node); end - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineHashBraceLayout -end - -class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks - include ::RuboCop::Cop::MultilineElementLineBreaks - def autocorrect(node); end - - def on_hash(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks -end - -class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks - include ::RuboCop::Cop::MultilineElementLineBreaks - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks -end - -class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout - include ::RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_send(node); end - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout -end - -class RuboCop::Cop::Layout::MultilineMethodCallIndentation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::MultilineExpressionIndentation - def autocorrect(node); end - - def validate_config(); end -end - -class RuboCop::Cop::Layout::MultilineMethodCallIndentation -end - -class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout - include ::RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout -end - -class RuboCop::Cop::Layout::MultilineOperationIndentation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::MultilineExpressionIndentation - def autocorrect(node); end - - def on_and(node); end - - def on_or(node); end - - def validate_config(); end -end - -class RuboCop::Cop::Layout::MultilineOperationIndentation -end - -class RuboCop::Cop::Layout::ParameterAlignment - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ParameterAlignment -end - -class RuboCop::Cop::Layout::RescueEnsureAlignment - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def investigate(processed_source); end - - def on_ensure(node); end - - def on_resbody(node); end - ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) - ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) - ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RUBY_2_5_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::RescueEnsureAlignment -end - -class RuboCop::Cop::Layout::SpaceAfterColon - def autocorrect(range); end - - def on_kwoptarg(node); end - - def on_pair(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterColon -end - -class RuboCop::Cop::Layout::SpaceAfterComma - include ::RuboCop::Cop::SpaceAfterPunctuation - def autocorrect(comma); end - - def kind(token); end - - def space_style_before_rcurly(); end -end - -class RuboCop::Cop::Layout::SpaceAfterComma -end - -class RuboCop::Cop::Layout::SpaceAfterMethodName - include ::RuboCop::Cop::RangeHelp - def autocorrect(pos_before_left_paren); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterMethodName -end - -class RuboCop::Cop::Layout::SpaceAfterNot - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def whitespace_after_operator?(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterNot -end - -class RuboCop::Cop::Layout::SpaceAfterSemicolon - include ::RuboCop::Cop::SpaceAfterPunctuation - def autocorrect(semicolon); end - - def kind(token); end - - def space_style_before_rcurly(); end -end - -class RuboCop::Cop::Layout::SpaceAfterSemicolon -end - -class RuboCop::Cop::Layout::SpaceAroundBlockParameters - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(target); end - - def on_block(node); end -end - -class RuboCop::Cop::Layout::SpaceAroundBlockParameters -end - -class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(range); end - - def on_optarg(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault -end - -class RuboCop::Cop::Layout::SpaceAroundKeyword - def autocorrect(range); end - - def on_and(node); end - - def on_block(node); end - - def on_break(node); end - - def on_case(node); end - - def on_defined?(node); end - - def on_ensure(node); end - - def on_for(node); end - - def on_if(node); end - - def on_kwbegin(node); end - - def on_next(node); end - - def on_or(node); end - - def on_postexe(node); end - - def on_preexe(node); end - - def on_resbody(node); end - - def on_rescue(node); end - - def on_return(node); end - - def on_send(node); end - - def on_super(node); end - - def on_until(node); end - - def on_when(node); end - - def on_while(node); end - - def on_yield(node); end - - def on_zsuper(node); end - ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped) - ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped) - ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) - DO = ::T.let(nil, ::T.untyped) - MSG_AFTER = ::T.let(nil, ::T.untyped) - MSG_BEFORE = ::T.let(nil, ::T.untyped) - NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) - SAFE_NAVIGATION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundKeyword -end - -class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_const(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator -end - -class RuboCop::Cop::Layout::SpaceAroundOperators - include ::RuboCop::Cop::PrecedingFollowingAlignment - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::RationalLiteral - def autocorrect(range); end - - def on_and(node); end - - def on_and_asgn(node); end - - def on_assignment(node); end - - def on_binary(node); end - - def on_casgn(node); end - - def on_class(node); end - - def on_cvasgn(node); end - - def on_gvasgn(node); end - - def on_if(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_op_asgn(node); end - - def on_or(node); end - - def on_or_asgn(node); end - - def on_pair(node); end - - def on_resbody(node); end - - def on_send(node); end - - def on_special_asgn(node); end - EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped) - IRREGULAR_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundOperators -end - -class RuboCop::Cop::Layout::SpaceBeforeBlockBraces - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_block(node); end - DETECTED_MSG = ::T.let(nil, ::T.untyped) - MISSING_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeBlockBraces -end - -class RuboCop::Cop::Layout::SpaceBeforeComma - include ::RuboCop::Cop::SpaceBeforePunctuation - include ::RuboCop::Cop::RangeHelp - def autocorrect(space); end - - def kind(token); end -end - -class RuboCop::Cop::Layout::SpaceBeforeComma -end - -class RuboCop::Cop::Layout::SpaceBeforeComment - def autocorrect(range); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeComment -end - -class RuboCop::Cop::Layout::SpaceBeforeFirstArg - include ::RuboCop::Cop::PrecedingFollowingAlignment - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeFirstArg -end - -class RuboCop::Cop::Layout::SpaceBeforeSemicolon - include ::RuboCop::Cop::SpaceBeforePunctuation - include ::RuboCop::Cop::RangeHelp - def autocorrect(space); end - - def kind(token); end -end - -class RuboCop::Cop::Layout::SpaceBeforeSemicolon -end - -class RuboCop::Cop::Layout::SpaceInLambdaLiteral - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(lambda_node); end - - def on_send(node); end - MSG_REQUIRE_NO_SPACE = ::T.let(nil, ::T.untyped) - MSG_REQUIRE_SPACE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInLambdaLiteral -end - -class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_array(node); end - EMPTY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets -end - -class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral - include ::RuboCop::Cop::MatchRange - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_array(node); end - - def on_percent_literal(node); end - MSG = ::T.let(nil, ::T.untyped) - MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral -end - -class RuboCop::Cop::Layout::SpaceInsideBlockBraces - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_block(node); end -end - -class RuboCop::Cop::Layout::SpaceInsideBlockBraces -end - -class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(range); end - - def on_hash(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces -end - -class RuboCop::Cop::Layout::SpaceInsideParens - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(range); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) - MSG_SPACE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideParens -end - -class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters - include ::RuboCop::Cop::MatchRange - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_array(node); end - - def on_percent_literal(node); end - - def on_xstr(node); end - BEGIN_REGEX = ::T.let(nil, ::T.untyped) - END_REGEX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters -end - -class RuboCop::Cop::Layout::SpaceInsideRangeLiteral - def autocorrect(node); end - - def on_erange(node); end - - def on_irange(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideRangeLiteral -end - -class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_send(node); end - BRACKET_METHODS = ::T.let(nil, ::T.untyped) - EMPTY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets -end - -class RuboCop::Cop::Layout::SpaceInsideStringInterpolation - include ::RuboCop::Cop::Interpolation - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(begin_node); end - - def on_interpolation(begin_node); end - NO_SPACE_MSG = ::T.let(nil, ::T.untyped) - SPACE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideStringInterpolation -end - -class RuboCop::Cop::Layout::TrailingEmptyLines - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end -end - -class RuboCop::Cop::Layout::TrailingEmptyLines -end - -class RuboCop::Cop::Layout::TrailingWhitespace - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::TrailingWhitespace -end - -module RuboCop::Cop::Layout -end - -class RuboCop::Cop::LineBreakCorrector -end - -class RuboCop::Cop::LineBreakCorrector - extend ::RuboCop::Cop::Alignment - extend ::RuboCop::Cop::TrailingBody - extend ::RuboCop::Cop::Util - extend ::RuboCop::PathUtil - def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end - - def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end - - def self.move_comment(eol_comment:, node:, corrector:); end - - def self.processed_source(); end -end - -module RuboCop::Cop::LineLengthHelp -end - -module RuboCop::Cop::LineLengthHelp -end - -module RuboCop::Cop::Lint -end - -class RuboCop::Cop::Lint::AmbiguousBlockAssociation - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousBlockAssociation -end - -class RuboCop::Cop::Lint::AmbiguousOperator - include ::RuboCop::Cop::ParserDiagnostic - def autocorrect(node); end - AMBIGUITIES = ::T.let(nil, ::T.untyped) - MSG_FORMAT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousOperator -end - -class RuboCop::Cop::Lint::AmbiguousRegexpLiteral - include ::RuboCop::Cop::ParserDiagnostic - def autocorrect(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousRegexpLiteral -end - -class RuboCop::Cop::Lint::AssignmentInCondition - include ::RuboCop::Cop::SafeAssignment - def on_if(node); end - - def on_until(node); end - - def on_while(node); end - ASGN_TYPES = ::T.let(nil, ::T.untyped) - MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) - MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AssignmentInCondition -end - -class RuboCop::Cop::Lint::BigDecimalNew - def autocorrect(node); end - - def big_decimal_new(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::BigDecimalNew -end - -class RuboCop::Cop::Lint::BooleanSymbol - def autocorrect(node); end - - def boolean_symbol?(node=T.unsafe(nil)); end - - def on_sym(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::BooleanSymbol -end - -class RuboCop::Cop::Lint::CircularArgumentReference - def on_kwoptarg(node); end - - def on_optarg(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::CircularArgumentReference -end - -class RuboCop::Cop::Lint::Debugger - def binding_irb_call?(node=T.unsafe(nil)); end - - def debugger_call?(node=T.unsafe(nil)); end - - def kernel?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Debugger -end - -class RuboCop::Cop::Lint::DeprecatedClassMethods - def autocorrect(node); end - - def on_send(node); end - DEPRECATED_METHODS_OBJECT = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod - include ::RuboCop::AST::Sexp - def class_constant(); end - - def class_nodes(); end - - def deprecated_method(); end - - def initialize(deprecated:, replacement:, class_constant: T.unsafe(nil)); end - - def replacement_method(); end -end - -class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod -end - -class RuboCop::Cop::Lint::DeprecatedClassMethods -end - -class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant - include ::RuboCop::Cop::RangeHelp - def algorithm_const(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant -end - -class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor -end - -class RuboCop::Cop::Lint::DuplicateCaseCondition - def on_case(case_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateCaseCondition -end - -class RuboCop::Cop::Lint::DuplicateHashKey - include ::RuboCop::Cop::Duplication - def on_hash(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateHashKey -end - -class RuboCop::Cop::Lint::DuplicateMethods - def alias_method?(node=T.unsafe(nil)); end - - def method_alias?(node=T.unsafe(nil)); end - - def on_alias(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end - - def sym_name(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateMethods -end - -class RuboCop::Cop::Lint::EachWithObjectArgument - def each_with_object?(node=T.unsafe(nil)); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EachWithObjectArgument -end - -class RuboCop::Cop::Lint::ElseLayout - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ElseLayout -end - -class RuboCop::Cop::Lint::EmptyEnsure - def autocorrect(node); end - - def on_ensure(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyEnsure -end - -class RuboCop::Cop::Lint::EmptyExpression - def on_begin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyExpression -end - -class RuboCop::Cop::Lint::EmptyInterpolation - include ::RuboCop::Cop::Interpolation - def autocorrect(node); end - - def on_interpolation(begin_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyInterpolation -end - -class RuboCop::Cop::Lint::EmptyWhen - def on_case(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyWhen -end - -class RuboCop::Cop::Lint::EnsureReturn - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_ensure(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EnsureReturn -end - -class RuboCop::Cop::Lint::ErbNewArguments - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def erb_new_with_non_keyword_arguments(node=T.unsafe(nil)); end - - def on_send(node); end - MESSAGES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ErbNewArguments - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Lint::FlipFlop - def on_eflipflop(node); end - - def on_iflipflop(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FlipFlop -end - -class RuboCop::Cop::Lint::FloatOutOfRange - def on_float(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FloatOutOfRange -end - -class RuboCop::Cop::Lint::FormatParameterMismatch - def called_on_string?(node=T.unsafe(nil)); end - - def on_send(node); end - KERNEL = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - MSG_INVALID = ::T.let(nil, ::T.untyped) - SHOVEL = ::T.let(nil, ::T.untyped) - STRING_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FormatParameterMismatch -end - -class RuboCop::Cop::Lint::HeredocMethodCallPosition - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::HeredocMethodCallPosition -end - -class RuboCop::Cop::Lint::ImplicitStringConcatenation - def on_dstr(node); end - FOR_ARRAY = ::T.let(nil, ::T.untyped) - FOR_METHOD = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ImplicitStringConcatenation -end - -class RuboCop::Cop::Lint::IneffectiveAccessModifier - def on_class(node); end - - def on_module(node); end - - def private_class_methods(node0); end - ALTERNATIVE_PRIVATE = ::T.let(nil, ::T.untyped) - ALTERNATIVE_PROTECTED = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::IneffectiveAccessModifier -end - -class RuboCop::Cop::Lint::InheritException - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def class_new_call?(node=T.unsafe(nil)); end - - def on_class(node); end - - def on_send(node); end - ILLEGAL_CLASSES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_BASE_CLASS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::InheritException -end - -class RuboCop::Cop::Lint::InterpolationCheck - def heredoc?(node); end - - def on_str(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::InterpolationCheck -end - -class RuboCop::Cop::Lint::LiteralAsCondition - def message(node); end - - def on_case(case_node); end - - def on_if(node); end - - def on_send(node); end - - def on_until(node); end - - def on_until_post(node); end - - def on_while(node); end - - def on_while_post(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::LiteralAsCondition -end - -class RuboCop::Cop::Lint::LiteralInInterpolation - include ::RuboCop::Cop::Interpolation - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_interpolation(begin_node); end - COMPOSITE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::LiteralInInterpolation -end - -class RuboCop::Cop::Lint::Loop - def on_until_post(node); end - - def on_while_post(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Loop -end - -class RuboCop::Cop::Lint::MissingCopEnableDirective - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) - MSG_BOUND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MissingCopEnableDirective -end - -class RuboCop::Cop::Lint::MixedRegexpCaptureTypes - def on_regexp(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MixedRegexpCaptureTypes -end - -class RuboCop::Cop::Lint::MultipleComparison - def autocorrect(node); end - - def multiple_compare?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MultipleComparison -end - -class RuboCop::Cop::Lint::NestedMethodDefinition - def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end - - def eval_call?(node=T.unsafe(nil)); end - - def exec_call?(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NestedMethodDefinition -end - -class RuboCop::Cop::Lint::NestedPercentLiteral - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def on_array(node); end - - def on_percent_literal(node); end - MSG = ::T.let(nil, ::T.untyped) - PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) - REGEXES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NestedPercentLiteral -end - -class RuboCop::Cop::Lint::NextWithoutAccumulator - def on_block(node); end - - def on_body_of_reduce(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NextWithoutAccumulator -end - -class RuboCop::Cop::Lint::NonDeterministicRequireOrder - def autocorrect(node); end - - def loop_variable(node=T.unsafe(nil)); end - - def on_block(node); end - - def unsorted_dir_block?(node=T.unsafe(nil)); end - - def unsorted_dir_each?(node=T.unsafe(nil)); end - - def var_is_required?(node0, param1); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NonDeterministicRequireOrder -end - -class RuboCop::Cop::Lint::NonLocalExitFromIterator - def chained_send?(node=T.unsafe(nil)); end - - def define_method?(node=T.unsafe(nil)); end - - def on_return(return_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NonLocalExitFromIterator -end - -class RuboCop::Cop::Lint::NumberConversion - def autocorrect(node); end - - def datetime?(node=T.unsafe(nil)); end - - def on_send(node); end - - def to_method(node=T.unsafe(nil)); end - CONVERSION_METHOD_CLASS_MAPPING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NumberConversion -end - -class RuboCop::Cop::Lint::OrderedMagicComments - include ::RuboCop::Cop::FrozenStringLiteral - def autocorrect(_node); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::OrderedMagicComments -end - -class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression -end - -class RuboCop::Cop::Lint::PercentStringArray - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_array(node); end - - def on_percent_literal(node); end - LEADING_QUOTE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - QUOTES_AND_COMMAS = ::T.let(nil, ::T.untyped) - TRAILING_QUOTE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::PercentStringArray -end - -class RuboCop::Cop::Lint::PercentSymbolArray - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_array(node); end - - def on_percent_literal(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::PercentSymbolArray -end - -class RuboCop::Cop::Lint::RaiseException - def exception?(node=T.unsafe(nil)); end - - def exception_new_with_message?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RaiseException -end - -class RuboCop::Cop::Lint::RandOne - def on_send(node); end - - def rand_one?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RandOne -end - -class RuboCop::Cop::Lint::RedundantCopDisableDirective - include ::RuboCop::Cop::RangeHelp - def autocorrect(args); end - - def check(offenses, cop_disabled_line_ranges, comments); end - COP_NAME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantCopDisableDirective -end - -class RuboCop::Cop::Lint::RedundantCopEnableDirective - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(comment_and_name); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantCopEnableDirective -end - -class RuboCop::Cop::Lint::RedundantRequireStatement - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def unnecessary_require_statement?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantRequireStatement -end - -class RuboCop::Cop::Lint::RedundantSplatExpansion - def array_new?(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def literal_expansion(node=T.unsafe(nil)); end - - def on_splat(node); end - ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped) - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped) - PERCENT_I = ::T.let(nil, ::T.untyped) - PERCENT_W = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantSplatExpansion -end - -class RuboCop::Cop::Lint::RedundantStringCoercion - include ::RuboCop::Cop::Interpolation - def autocorrect(node); end - - def on_interpolation(begin_node); end - - def to_s_without_args?(node=T.unsafe(nil)); end - MSG_DEFAULT = ::T.let(nil, ::T.untyped) - MSG_SELF = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantStringCoercion -end - -class RuboCop::Cop::Lint::RedundantWithIndex - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def redundant_with_index?(node=T.unsafe(nil)); end - MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped) - MSG_WITH_INDEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantWithIndex -end - -class RuboCop::Cop::Lint::RedundantWithObject - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def redundant_with_object?(node=T.unsafe(nil)); end - MSG_EACH_WITH_OBJECT = ::T.let(nil, ::T.untyped) - MSG_WITH_OBJECT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantWithObject -end - -class RuboCop::Cop::Lint::RegexpAsCondition - def on_match_current_line(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RegexpAsCondition -end - -class RuboCop::Cop::Lint::RequireParentheses - include ::RuboCop::Cop::RangeHelp - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RequireParentheses -end - -class RuboCop::Cop::Lint::RescueException - def on_resbody(node); end - - def targets_exception?(rescue_arg_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RescueException -end - -class RuboCop::Cop::Lint::RescueType - include ::RuboCop::Cop::RescueNode - def autocorrect(node); end - - def on_resbody(node); end - INVALID_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RescueType -end - -class RuboCop::Cop::Lint::ReturnInVoidContext - def on_return(return_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ReturnInVoidContext -end - -class RuboCop::Cop::Lint::SafeNavigationChain - include ::RuboCop::Cop::NilMethods - def bad_method?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationChain -end - -class RuboCop::Cop::Lint::SafeNavigationConsistency - include ::RuboCop::Cop::NilMethods - def autocorrect(node); end - - def check(node); end - - def on_csend(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationConsistency -end - -class RuboCop::Cop::Lint::SafeNavigationWithEmpty - def on_if(node); end - - def safe_navigation_empty_in_conditional?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationWithEmpty -end - -class RuboCop::Cop::Lint::ScriptPermission - def autocorrect(node); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ScriptPermission -end - -class RuboCop::Cop::Lint::SendWithMixinArgument - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def send_with_mixin_argument?(node=T.unsafe(nil)); end - MIXIN_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SendWithMixinArgument -end - -class RuboCop::Cop::Lint::ShadowedArgument - def after_leaving_scope(scope, _variable_table); end - - def join_force?(force_class); end - - def uses_var?(node0, param1); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowedArgument -end - -class RuboCop::Cop::Lint::ShadowedException - include ::RuboCop::Cop::RescueNode - include ::RuboCop::Cop::RangeHelp - def on_rescue(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowedException -end - -class RuboCop::Cop::Lint::ShadowingOuterLocalVariable - def before_declaring_variable(variable, variable_table); end - - def join_force?(force_class); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowingOuterLocalVariable -end - -class RuboCop::Cop::Lint::StructNewOverride - def on_send(node); end - - def struct_new(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - STRUCT_MEMBER_NAME_TYPES = ::T.let(nil, ::T.untyped) - STRUCT_METHOD_NAMES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::StructNewOverride -end - -class RuboCop::Cop::Lint::SuppressedException - def on_resbody(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SuppressedException -end - -class RuboCop::Cop::Lint::Syntax - def add_offense_from_diagnostic(diagnostic, ruby_version); end - - def add_offense_from_error(error); end - ERROR_SOURCE_RANGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Syntax::PseudoSourceRange - def begin_pos(); end - - def begin_pos=(_); end - - def column(); end - - def column=(_); end - - def end_pos(); end - - def end_pos=(_); end - - def line(); end - - def line=(_); end - - def source_line(); end - - def source_line=(_); end -end - -class RuboCop::Cop::Lint::Syntax::PseudoSourceRange - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Cop::Lint::Syntax - def self.offenses_from_processed_source(processed_source, config, options); end -end - -class RuboCop::Cop::Lint::ToJSON - def autocorrect(node); end - - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ToJSON -end - -class RuboCop::Cop::Lint::UnderscorePrefixedVariableName - def after_leaving_scope(scope, _variable_table); end - - def check_variable(variable); end - - def join_force?(force_class); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnderscorePrefixedVariableName -end - -class RuboCop::Cop::Lint::UnifiedInteger - def autocorrect(node); end - - def fixnum_or_bignum_const(node=T.unsafe(nil)); end - - def on_const(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnifiedInteger -end - -class RuboCop::Cop::Lint::UnreachableCode - def flow_command?(node=T.unsafe(nil)); end - - def on_begin(node); end - - def on_kwbegin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnreachableCode -end - -module RuboCop::Cop::Lint::UnusedArgument - def after_leaving_scope(scope, _variable_table); end - - def join_force?(force_class); end -end - -module RuboCop::Cop::Lint::UnusedArgument - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::Lint::UnusedBlockArgument - include ::RuboCop::Cop::Lint::UnusedArgument - def autocorrect(node); end -end - -class RuboCop::Cop::Lint::UnusedBlockArgument -end - -class RuboCop::Cop::Lint::UnusedMethodArgument - include ::RuboCop::Cop::Lint::UnusedArgument - def autocorrect(node); end - - def not_implemented?(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Lint::UnusedMethodArgument -end - -class RuboCop::Cop::Lint::UriEscapeUnescape - def on_send(node); end - - def uri_escape_unescape?(node=T.unsafe(nil)); end - ALTERNATE_METHODS_OF_URI_ESCAPE = ::T.let(nil, ::T.untyped) - ALTERNATE_METHODS_OF_URI_UNESCAPE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UriEscapeUnescape -end - -class RuboCop::Cop::Lint::UriRegexp - def autocorrect(node); end - - def on_send(node); end - - def uri_regexp_with_argument?(node=T.unsafe(nil)); end - - def uri_regexp_without_argument?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UriRegexp -end - -class RuboCop::Cop::Lint::UselessAccessModifier - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def class_or_instance_eval?(node=T.unsafe(nil)); end - - def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end - - def dynamic_method_definition?(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_class(node); end - - def on_module(node); end - - def on_sclass(node); end - - def static_method_definition?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessAccessModifier -end - -class RuboCop::Cop::Lint::UselessAssignment - def after_leaving_scope(scope, _variable_table); end - - def check_for_unused_assignments(variable); end - - def collect_variable_like_names(scope); end - - def join_force?(force_class); end - - def message_for_useless_assignment(assignment); end - - def message_specification(assignment, variable); end - - def multiple_assignment_message(variable_name); end - - def operator_assignment_message(scope, assignment); end - - def return_value_node_of_scope(scope); end - - def similar_name_message(variable); end - - def variable_like_method_invocation?(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessAssignment -end - -class RuboCop::Cop::Lint::UselessComparison - def on_send(node); end - - def useless_comparison?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - OPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessComparison -end - -class RuboCop::Cop::Lint::UselessElseWithoutRescue - include ::RuboCop::Cop::ParserDiagnostic - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessElseWithoutRescue -end - -class RuboCop::Cop::Lint::UselessSetterCall - def on_def(node); end - - def on_defs(node); end - - def setter_call_to_local_variable?(node=T.unsafe(nil)); end - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker - def constructor?(node); end - - def contain_local_object?(variable_name); end - - def initialize(body_node); end - - def process_assignment(asgn_node, rhs_node); end - - def process_assignment_node(node); end - - def process_binary_operator_assignment(op_asgn_node); end - - def process_logical_operator_assignment(asgn_node); end - - def process_multiple_assignment(masgn_node); end - - def scan(node, &block); end -end - -class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker -end - -class RuboCop::Cop::Lint::UselessSetterCall -end - -class RuboCop::Cop::Lint::Void - def on_begin(node); end - - def on_block(node); end - - def on_kwbegin(node); end - BINARY_OPERATORS = ::T.let(nil, ::T.untyped) - DEFINED_MSG = ::T.let(nil, ::T.untyped) - LIT_MSG = ::T.let(nil, ::T.untyped) - NONMUTATING_METHODS = ::T.let(nil, ::T.untyped) - NONMUTATING_MSG = ::T.let(nil, ::T.untyped) - OPERATORS = ::T.let(nil, ::T.untyped) - OP_MSG = ::T.let(nil, ::T.untyped) - SELF_MSG = ::T.let(nil, ::T.untyped) - UNARY_OPERATORS = ::T.let(nil, ::T.untyped) - VAR_MSG = ::T.let(nil, ::T.untyped) - VOID_CONTEXT_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Void -end - -module RuboCop::Cop::Lint -end - -module RuboCop::Cop::MatchRange - include ::RuboCop::Cop::RangeHelp -end - -module RuboCop::Cop::MatchRange -end - -class RuboCop::Cop::MessageAnnotator - def annotate(message); end - - def config(); end - - def cop_config(); end - - def cop_name(); end - - def initialize(config, cop_name, cop_config, options); end - - def options(); end - - def urls(); end -end - -class RuboCop::Cop::MessageAnnotator - def self.style_guide_urls(); end -end - -module RuboCop::Cop::MethodComplexity - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IgnoredMethods - def define_method?(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_def(node); end - - def on_defs(node); end -end - -module RuboCop::Cop::MethodComplexity - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::MethodPreference -end - -module RuboCop::Cop::MethodPreference -end - -module RuboCop::Cop::Metrics -end - -class RuboCop::Cop::Metrics::AbcSize - include ::RuboCop::Cop::MethodComplexity - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IgnoredMethods - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::AbcSize -end - -class RuboCop::Cop::Metrics::BlockLength - include ::RuboCop::Cop::TooManyLines - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - def on_block(node); end - LABEL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::BlockLength -end - -class RuboCop::Cop::Metrics::BlockNesting - include ::RuboCop::Cop::ConfigurableMax - def investigate(processed_source); end - NESTING_BLOCKS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::BlockNesting -end - -class RuboCop::Cop::Metrics::ClassLength - include ::RuboCop::Cop::ClassishLength - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - def class_definition?(node=T.unsafe(nil)); end - - def on_casgn(node); end - - def on_class(node); end -end - -class RuboCop::Cop::Metrics::ClassLength -end - -class RuboCop::Cop::Metrics::CyclomaticComplexity - include ::RuboCop::Cop::MethodComplexity - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IgnoredMethods - COUNTED_NODES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::CyclomaticComplexity -end - -class RuboCop::Cop::Metrics::MethodLength - include ::RuboCop::Cop::TooManyLines - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - def on_block(node); end - - def on_def(node); end - - def on_defs(node); end - LABEL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::MethodLength -end - -class RuboCop::Cop::Metrics::ModuleLength - include ::RuboCop::Cop::ClassishLength - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - def module_definition?(node=T.unsafe(nil)); end - - def on_casgn(node); end - - def on_module(node); end -end - -class RuboCop::Cop::Metrics::ModuleLength -end - -class RuboCop::Cop::Metrics::ParameterLists - include ::RuboCop::Cop::ConfigurableMax - def argument_to_lambda_or_proc?(node=T.unsafe(nil)); end - - def on_args(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::ParameterLists -end - -class RuboCop::Cop::Metrics::PerceivedComplexity - include ::RuboCop::Cop::MethodComplexity - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IgnoredMethods - COUNTED_NODES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::PerceivedComplexity -end - -module RuboCop::Cop::Metrics::Utils -end - -class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator - def calculate(); end - - def else_branch?(node); end - - def evaluate_branch_nodes(node); end - - def evaluate_condition_node(node); end - - def initialize(node); end - BRANCH_NODES = ::T.let(nil, ::T.untyped) - CONDITION_NODES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator - def self.calculate(node); end -end - -module RuboCop::Cop::Metrics::Utils -end - -module RuboCop::Cop::Metrics -end - -module RuboCop::Cop::Migration -end - -class RuboCop::Cop::Migration::DepartmentName - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped) - DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Migration::DepartmentName -end - -module RuboCop::Cop::Migration -end - -module RuboCop::Cop::MinBodyLength -end - -module RuboCop::Cop::MinBodyLength -end - -module RuboCop::Cop::MultilineElementIndentation -end - -module RuboCop::Cop::MultilineElementIndentation -end - -module RuboCop::Cop::MultilineElementLineBreaks -end - -module RuboCop::Cop::MultilineElementLineBreaks -end - -module RuboCop::Cop::MultilineExpressionIndentation - def on_send(node); end - ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - DEFAULT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - KEYWORD_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) - KEYWORD_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - UNALIGNED_RHS_TYPES = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::MultilineExpressionIndentation -end - -class RuboCop::Cop::MultilineLiteralBraceCorrector - include ::RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def call(corrector); end - - def initialize(node, processed_source); end -end - -class RuboCop::Cop::MultilineLiteralBraceCorrector -end - -module RuboCop::Cop::MultilineLiteralBraceLayout - include ::RuboCop::Cop::ConfigurableEnforcedStyle -end - -module RuboCop::Cop::MultilineLiteralBraceLayout -end - -module RuboCop::Cop::Naming -end - -class RuboCop::Cop::Naming::AccessorMethodName - def on_def(node); end - - def on_defs(node); end - MSG_READER = ::T.let(nil, ::T.untyped) - MSG_WRITER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::AccessorMethodName -end - -class RuboCop::Cop::Naming::AsciiIdentifiers - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::AsciiIdentifiers -end - -class RuboCop::Cop::Naming::BinaryOperatorParameterName - def on_def(node); end - - def op_method_candidate?(node=T.unsafe(nil)); end - BLACKLISTED = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - OP_LIKE_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::BinaryOperatorParameterName -end - -class RuboCop::Cop::Naming::BlockParameterName - include ::RuboCop::Cop::UncommunicativeName - def on_block(node); end -end - -class RuboCop::Cop::Naming::BlockParameterName -end - -class RuboCop::Cop::Naming::ClassAndModuleCamelCase - def on_class(node); end - - def on_module(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::ClassAndModuleCamelCase -end - -class RuboCop::Cop::Naming::ConstantName - def class_or_struct_return_method?(node=T.unsafe(nil)); end - - def literal_receiver?(node=T.unsafe(nil)); end - - def on_casgn(node); end - MSG = ::T.let(nil, ::T.untyped) - SNAKE_CASE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::ConstantName -end - -class RuboCop::Cop::Naming::FileName - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - MSG_NO_DEFINITION = ::T.let(nil, ::T.untyped) - MSG_REGEX = ::T.let(nil, ::T.untyped) - MSG_SNAKE_CASE = ::T.let(nil, ::T.untyped) - SNAKE_CASE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::FileName -end - -class RuboCop::Cop::Naming::HeredocDelimiterCase - include ::RuboCop::Cop::Heredoc - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def on_heredoc(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::HeredocDelimiterCase -end - -class RuboCop::Cop::Naming::HeredocDelimiterNaming - include ::RuboCop::Cop::Heredoc - def on_heredoc(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::HeredocDelimiterNaming -end - -class RuboCop::Cop::Naming::MemoizedInstanceVariableName - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def memoized?(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE_REQUIRED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::MemoizedInstanceVariableName -end - -class RuboCop::Cop::Naming::MethodName - include ::RuboCop::Cop::ConfigurableNaming - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::IgnoredPattern - include ::RuboCop::Cop::RangeHelp - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end - - def str_name(node=T.unsafe(nil)); end - - def sym_name(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::MethodName -end - -class RuboCop::Cop::Naming::MethodParameterName - include ::RuboCop::Cop::UncommunicativeName - def on_def(node); end - - def on_defs(node); end -end - -class RuboCop::Cop::Naming::MethodParameterName -end - -class RuboCop::Cop::Naming::PredicateName - def dynamic_method_define(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end -end - -class RuboCop::Cop::Naming::PredicateName -end - -class RuboCop::Cop::Naming::RescuedExceptionsVariableName - def autocorrect(node); end - - def on_resbody(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::RescuedExceptionsVariableName -end - -class RuboCop::Cop::Naming::VariableName - include ::RuboCop::Cop::ConfigurableNaming - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def on_arg(node); end - - def on_blockarg(node); end - - def on_cvasgn(node); end - - def on_ivasgn(node); end - - def on_kwarg(node); end - - def on_kwoptarg(node); end - - def on_kwrestarg(node); end - - def on_lvar(node); end - - def on_lvasgn(node); end - - def on_optarg(node); end - - def on_restarg(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::VariableName -end - -class RuboCop::Cop::Naming::VariableNumber - include ::RuboCop::Cop::ConfigurableNumbering - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def on_arg(node); end - - def on_cvasgn(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::VariableNumber -end - -module RuboCop::Cop::Naming -end - -module RuboCop::Cop::NegativeConditional - def empty_condition?(node=T.unsafe(nil)); end - - def single_negative?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::NegativeConditional - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::NilMethods -end - -module RuboCop::Cop::NilMethods -end - -class RuboCop::Cop::Offense - include ::Comparable - def ==(other); end - - def column(); end - - def column_length(); end - - def column_range(); end - - def cop_name(); end - - def correctable?(); end - - def corrected?(); end - - def corrected_with_todo?(); end - - def disabled?(); end - - def eql?(other); end - - def first_line(); end - - def highlighted_area(); end - - def initialize(severity, location, message, cop_name, status=T.unsafe(nil)); end - - def last_column(); end - - def last_line(); end - - def line(); end - - def location(); end - - def message(); end - - def real_column(); end - - def severity(); end - - def source_line(); end - - def status(); end - COMPARISON_ATTRIBUTES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Offense -end - -module RuboCop::Cop::OnNormalIfUnless - def on_if(node); end -end - -module RuboCop::Cop::OnNormalIfUnless -end - -class RuboCop::Cop::OrderedGemCorrector -end - -class RuboCop::Cop::OrderedGemCorrector - extend ::RuboCop::Cop::OrderedGemNode - def self.comments_as_separators(); end - - def self.correct(processed_source, node, previous_declaration, comments_as_separators); end - - def self.processed_source(); end -end - -module RuboCop::Cop::OrderedGemNode -end - -module RuboCop::Cop::OrderedGemNode -end - -module RuboCop::Cop::Parentheses -end - -module RuboCop::Cop::Parentheses -end - -class RuboCop::Cop::ParenthesesCorrector -end - -class RuboCop::Cop::ParenthesesCorrector - def self.correct(node); end -end - -module RuboCop::Cop::ParserDiagnostic - def investigate(processed_source); end -end - -module RuboCop::Cop::ParserDiagnostic -end - -module RuboCop::Cop::PercentArray -end - -module RuboCop::Cop::PercentArray -end - -module RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp -end - -module RuboCop::Cop::PercentLiteral -end - -class RuboCop::Cop::PercentLiteralCorrector - include ::RuboCop::Cop::Util - include ::RuboCop::PathUtil - def config(); end - - def correct(node, char); end - - def initialize(config, preferred_delimiters); end - - def preferred_delimiters(); end -end - -class RuboCop::Cop::PercentLiteralCorrector -end - -module RuboCop::Cop::Performance -end - -class RuboCop::Cop::Performance::BindCall - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def bind_with_call_method?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::BindCall - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Performance::Caller - def caller_with_scope_method?(node=T.unsafe(nil)); end - - def on_send(node); end - - def slow_caller?(node=T.unsafe(nil)); end - MSG_BRACE = ::T.let(nil, ::T.untyped) - MSG_FIRST = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Caller -end - -class RuboCop::Cop::Performance::CaseWhenSplat - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::RangeHelp - def autocorrect(when_node); end - - def on_case(case_node); end - ARRAY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::CaseWhenSplat -end - -class RuboCop::Cop::Performance::Casecmp - def autocorrect(node); end - - def downcase_downcase(node=T.unsafe(nil)); end - - def downcase_eq(node=T.unsafe(nil)); end - - def eq_downcase(node=T.unsafe(nil)); end - - def on_send(node); end - CASE_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Casecmp -end - -class RuboCop::Cop::Performance::ChainArrayAllocation - include ::RuboCop::Cop::RangeHelp - def flat_map_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - ALWAYS_RETURNS_NEW_ARRAY = ::T.let(nil, ::T.untyped) - HAS_MUTATION_ALTERNATIVE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ::T.let(nil, ::T.untyped) - RETURN_NEW_ARRAY_WHEN_ARGS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ChainArrayAllocation -end - -class RuboCop::Cop::Performance::CompareWithBlock - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def compare?(node=T.unsafe(nil)); end - - def on_block(node); end - - def replaceable_body?(node=T.unsafe(nil), param1, param2); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::CompareWithBlock -end - -class RuboCop::Cop::Performance::Count - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def count_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Count -end - -class RuboCop::Cop::Performance::DeletePrefix - include ::RuboCop::Cop::RegexpMetacharacter - def autocorrect(node); end - - def delete_prefix_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeletePrefix - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Performance::DeleteSuffix - include ::RuboCop::Cop::RegexpMetacharacter - def autocorrect(node); end - - def delete_suffix_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeleteSuffix - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Performance::Detect - def autocorrect(node); end - - def detect_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - REVERSE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Detect -end - -class RuboCop::Cop::Performance::DoubleStartEndWith - def autocorrect(node); end - - def check_with_active_support_aliases(node=T.unsafe(nil)); end - - def on_or(node); end - - def two_start_end_with_calls(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DoubleStartEndWith -end - -class RuboCop::Cop::Performance::EndWith - include ::RuboCop::Cop::RegexpMetacharacter - def autocorrect(node); end - - def on_match_with_lvasgn(node); end - - def on_send(node); end - - def redundant_regex?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::EndWith -end - -class RuboCop::Cop::Performance::FixedSize - def counter(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FixedSize -end - -class RuboCop::Cop::Performance::FlatMap - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def flat_map_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - FLATTEN_MULTIPLE_LEVELS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FlatMap -end - -class RuboCop::Cop::Performance::InefficientHashSearch - def autocorrect(node); end - - def inefficient_include?(node=T.unsafe(nil)); end - - def on_send(node); end -end - -class RuboCop::Cop::Performance::InefficientHashSearch -end - -class RuboCop::Cop::Performance::OpenStruct - def on_send(node); end - - def open_struct(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::OpenStruct -end - -class RuboCop::Cop::Performance::RangeInclude - def autocorrect(node); end - - def on_send(node); end - - def range_include(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RangeInclude -end - -class RuboCop::Cop::Performance::RedundantBlockCall - def autocorrect(node); end - - def blockarg_assigned?(node0, param1); end - - def blockarg_calls(node0, param1); end - - def blockarg_def(node=T.unsafe(nil)); end - - def on_def(node); end - CLOSE_PAREN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - OPEN_PAREN = ::T.let(nil, ::T.untyped) - SPACE = ::T.let(nil, ::T.untyped) - YIELD = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantBlockCall -end - -class RuboCop::Cop::Performance::RedundantMatch - def autocorrect(node); end - - def match_call?(node=T.unsafe(nil)); end - - def on_send(node); end - - def only_truthiness_matters?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMatch -end - -class RuboCop::Cop::Performance::RedundantMerge - def autocorrect(node); end - - def modifier_flow_control?(node=T.unsafe(nil)); end - - def on_send(node); end - - def redundant_merge_candidate(node=T.unsafe(nil)); end - AREF_ASGN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - WITH_MODIFIER_CORRECTION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector - def each_with_object_node(node=T.unsafe(nil)); end - - def initialize(node, receiver); end - - def value_used?(); end -end - -class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::Performance::RedundantMerge -end - -class RuboCop::Cop::Performance::RegexpMatch - def autocorrect(node); end - - def last_matches(node0); end - - def match_method?(node=T.unsafe(nil)); end - - def match_node?(node=T.unsafe(nil)); end - - def match_operator?(node=T.unsafe(nil)); end - - def match_threequals?(node=T.unsafe(nil)); end - - def match_with_int_arg_method?(node=T.unsafe(nil)); end - - def match_with_lvasgn?(node); end - - def on_case(node); end - - def on_if(node); end - - def search_match_nodes(node0); end - MATCH_NODE_PATTERN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TYPES_IMPLEMENTING_MATCH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RegexpMatch -end - -class RuboCop::Cop::Performance::ReverseEach - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def reverse_each?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ReverseEach -end - -class RuboCop::Cop::Performance::Size - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Size -end - -class RuboCop::Cop::Performance::StartWith - include ::RuboCop::Cop::RegexpMetacharacter - def autocorrect(node); end - - def on_match_with_lvasgn(node); end - - def on_send(node); end - - def redundant_regex?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StartWith -end - -class RuboCop::Cop::Performance::StringReplacement - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def replace_method(node, first, second, first_param, replacement); end - - def string_replacement?(node=T.unsafe(nil)); end - BANG = ::T.let(nil, ::T.untyped) - DELETE = ::T.let(nil, ::T.untyped) - DETERMINISTIC_REGEX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StringReplacement -end - -class RuboCop::Cop::Performance::TimesMap - def autocorrect(node); end - - def on_block(node); end - - def on_send(node); end - - def times_map_call(node=T.unsafe(nil)); end - MESSAGE = ::T.let(nil, ::T.untyped) - MESSAGE_ONLY_IF = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::TimesMap -end - -class RuboCop::Cop::Performance::UnfreezeString - def dup_string?(node=T.unsafe(nil)); end - - def on_send(node); end - - def string_new?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UnfreezeString -end - -class RuboCop::Cop::Performance::UriDefaultParser - def autocorrect(node); end - - def on_send(node); end - - def uri_parser_new?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UriDefaultParser -end - -module RuboCop::Cop::Performance -end - -module RuboCop::Cop::PrecedingFollowingAlignment -end - -module RuboCop::Cop::PrecedingFollowingAlignment -end - -class RuboCop::Cop::PreferredDelimiters - def config(); end - - def delimiters(); end - - def initialize(type, config, preferred_delimiters); end - - def type(); end - PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::PreferredDelimiters -end - -class RuboCop::Cop::PunctuationCorrector -end - -class RuboCop::Cop::PunctuationCorrector - def self.add_space(token); end - - def self.remove_space(space_before); end - - def self.swap_comma(range); end -end - -module RuboCop::Cop::RSpec -end - -class RuboCop::Cop::RSpec::AlignLeftLetBrace - def autocorrect(let); end - - def investigate(_processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AlignLeftLetBrace -end - -class RuboCop::Cop::RSpec::AlignRightLetBrace - def autocorrect(let); end - - def investigate(_processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AlignRightLetBrace -end - -class RuboCop::Cop::RSpec::AnyInstance - def disallowed_stub(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AnyInstance -end - -class RuboCop::Cop::RSpec::AroundBlock - def find_arg_usage(node0); end - - def hook(node=T.unsafe(nil)); end - - def on_block(node); end - MSG_NO_ARG = ::T.let(nil, ::T.untyped) - MSG_UNUSED_ARG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AroundBlock -end - -class RuboCop::Cop::RSpec::Be - def be_without_args(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Be -end - -class RuboCop::Cop::RSpec::BeEql - def autocorrect(node); end - - def eql_type_with_identity(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeEql -end - -class RuboCop::Cop::RSpec::BeforeAfterAll - def before_or_after_all(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeforeAfterAll -end - -module RuboCop::Cop::RSpec::Capybara -end - -class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation - def as_is_matcher(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def expectation_set_on_current_path(node=T.unsafe(nil)); end - - def on_send(node); end - - def regexp_str_matcher(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation -end - -class RuboCop::Cop::RSpec::Capybara::FeatureMethods - def autocorrect(node); end - - def feature_method(node=T.unsafe(nil)); end - - def on_block(node); end - - def spec?(node=T.unsafe(nil)); end - MAP = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::FeatureMethods -end - -class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher - def on_send(node); end - - def visible_false?(node=T.unsafe(nil)); end - - def visible_true?(node=T.unsafe(nil)); end - CAPYBARA_MATCHER_METHODS = ::T.let(nil, ::T.untyped) - MSG_FALSE = ::T.let(nil, ::T.untyped) - MSG_TRUE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher -end - -module RuboCop::Cop::RSpec::Capybara -end - -class RuboCop::Cop::RSpec::ContextMethod - def autocorrect(node); end - - def context_method(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ContextMethod -end - -class RuboCop::Cop::RSpec::ContextWording - def context_wording(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ContextWording -end - -class RuboCop::Cop::RSpec::Cop - include ::RuboCop::RSpec::Language - include ::RuboCop::RSpec::Language::NodePattern - DEFAULT_CONFIGURATION = ::T.let(nil, ::T.untyped) - DEFAULT_PATTERN_RE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Cop -end - -class RuboCop::Cop::RSpec::DescribeClass - include ::RuboCop::RSpec::TopLevelDescribe - def describe_with_rails_metadata?(node=T.unsafe(nil)); end - - def on_top_level_describe(node, _); end - - def rails_metadata?(node=T.unsafe(nil)); end - - def shared_group?(node=T.unsafe(nil)); end - - def valid_describe?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeClass -end - -class RuboCop::Cop::RSpec::DescribeMethod - include ::RuboCop::RSpec::TopLevelDescribe - def on_top_level_describe(_node, _); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeMethod -end - -class RuboCop::Cop::RSpec::DescribeSymbol - def describe_symbol?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeSymbol -end - -class RuboCop::Cop::RSpec::DescribedClass - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def common_instance_exec_closure?(node=T.unsafe(nil)); end - - def contains_described_class?(node0); end - - def described_constant(node=T.unsafe(nil)); end - - def on_block(node); end - - def rspec_block?(node=T.unsafe(nil)); end - - def scope_changing_syntax?(node=T.unsafe(nil)); end - DESCRIBED_CLASS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribedClass -end - -class RuboCop::Cop::RSpec::DescribedClassModuleWrapping - def find_rspec_blocks(node0); end - - def on_module(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribedClassModuleWrapping -end - -class RuboCop::Cop::RSpec::Dialect - include ::RuboCop::Cop::MethodPreference - def autocorrect(node); end - - def on_send(node); end - - def rspec_method?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Dialect -end - -class RuboCop::Cop::RSpec::EmptyExampleGroup - def contains_example?(node0); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyExampleGroup -end - -class RuboCop::Cop::RSpec::EmptyHook - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def empty_hook?(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyHook -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExample - include ::RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def allow_consecutive_one_liners?(); end - - def allowed_one_liner?(node); end - - def consecutive_one_liner?(node); end - - def next_one_line_example?(node); end - - def next_sibling(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExample -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup - include ::RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup -end - -class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet - include ::RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet -end - -class RuboCop::Cop::RSpec::EmptyLineAfterHook - include ::RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterHook -end - -class RuboCop::Cop::RSpec::EmptyLineAfterSubject - include ::RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterSubject -end - -class RuboCop::Cop::RSpec::ExampleLength - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleLength -end - -class RuboCop::Cop::RSpec::ExampleWithoutDescription - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def example_description(node=T.unsafe(nil)); end - - def on_block(node); end - MSG_ADD_DESCRIPTION = ::T.let(nil, ::T.untyped) - MSG_DEFAULT_ARGUMENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleWithoutDescription -end - -class RuboCop::Cop::RSpec::ExampleWording - def autocorrect(node); end - - def it_description(node=T.unsafe(nil)); end - - def on_block(node); end - IT_PREFIX = ::T.let(nil, ::T.untyped) - MSG_IT = ::T.let(nil, ::T.untyped) - MSG_SHOULD = ::T.let(nil, ::T.untyped) - SHOULD_PREFIX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleWording -end - -class RuboCop::Cop::RSpec::ExpectActual - def autocorrect(node); end - - def expect_literal(node=T.unsafe(nil)); end - - def on_send(node); end - COMPLEX_LITERALS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SIMPLE_LITERALS = ::T.let(nil, ::T.untyped) - SUPPORTED_MATCHERS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectActual -end - -class RuboCop::Cop::RSpec::ExpectChange - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def expect_change_with_arguments(node=T.unsafe(nil)); end - - def expect_change_with_block(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_send(node); end - MSG_BLOCK = ::T.let(nil, ::T.untyped) - MSG_CALL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectChange -end - -class RuboCop::Cop::RSpec::ExpectInHook - def expectation(node0); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectInHook -end - -class RuboCop::Cop::RSpec::ExpectOutput - def on_gvasgn(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectOutput -end - -module RuboCop::Cop::RSpec::ExplicitHelper - include ::RuboCop::RSpec::Language - def predicate_matcher?(node=T.unsafe(nil)); end - - def predicate_matcher_block?(node=T.unsafe(nil)); end - BUILT_IN_MATCHERS = ::T.let(nil, ::T.untyped) - MSG_EXPLICIT = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RSpec::ExplicitHelper - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::RSpec::FactoryBot -end - -class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically - def association?(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def factory_attributes(node0); end - - def on_block(node); end - - def value_matcher(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def factory_call(node=T.unsafe(nil)); end - - def factory_list_call(node=T.unsafe(nil)); end - - def n_times_block_without_arg?(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_send(node); end - MSG_CREATE_LIST = ::T.let(nil, ::T.untyped) - MSG_N_TIMES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector - def call(corrector); end - - def initialize(node); end -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector - def call(corrector); end - - def initialize(node); end -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList -end - -class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName - def autocorrect(node); end - - def class_name(node=T.unsafe(nil)); end - - def on_send(node); end - ALLOWED_CONSTANTS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName -end - -module RuboCop::Cop::RSpec::FactoryBot -end - -class RuboCop::Cop::RSpec::FilePath - include ::RuboCop::RSpec::TopLevelDescribe - def const_described?(node0); end - - def on_top_level_describe(node, args); end - - def routing_metadata?(node0); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FilePath -end - -class RuboCop::Cop::RSpec::Focus - def focused_block?(node=T.unsafe(nil)); end - - def metadata(node=T.unsafe(nil)); end - - def on_send(node); end - FOCUSABLE_SELECTORS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Focus -end - -class RuboCop::Cop::RSpec::HookArgument - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_block(node); end - - def scoped_hook(node=T.unsafe(nil)); end - - def unscoped_hook(node=T.unsafe(nil)); end - EXPLICIT_MSG = ::T.let(nil, ::T.untyped) - HOOKS = ::T.let(nil, ::T.untyped) - IMPLICIT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::HookArgument -end - -class RuboCop::Cop::RSpec::HooksBeforeExamples - def autocorrect(node); end - - def example_or_group?(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::HooksBeforeExamples -end - -class RuboCop::Cop::RSpec::ImplicitBlockExpectation - def implicit_expect(node=T.unsafe(nil)); end - - def lambda?(node=T.unsafe(nil)); end - - def lambda_subject?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitBlockExpectation -end - -class RuboCop::Cop::RSpec::ImplicitExpect - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def implicit_expect(node=T.unsafe(nil)); end - - def on_send(node); end - ENFORCED_REPLACEMENTS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitExpect -end - -class RuboCop::Cop::RSpec::ImplicitSubject - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def implicit_subject?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitSubject -end - -module RuboCop::Cop::RSpec::InflectedHelper - include ::RuboCop::RSpec::Language - def be_bool?(node=T.unsafe(nil)); end - - def be_boolthy?(node=T.unsafe(nil)); end - - def predicate_in_actual?(node=T.unsafe(nil)); end - MSG_INFLECTED = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RSpec::InflectedHelper - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::RSpec::InstanceSpy - def autocorrect(node); end - - def have_received_usage(node0); end - - def null_double(node0); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::InstanceSpy -end - -class RuboCop::Cop::RSpec::InstanceVariable - def custom_matcher?(node=T.unsafe(nil)); end - - def dynamic_class?(node=T.unsafe(nil)); end - - def ivar_assigned?(node0, param1); end - - def ivar_usage(node0); end - - def on_block(node); end - - def spec_group?(node=T.unsafe(nil)); end - EXAMPLE_GROUP_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::InstanceVariable -end - -class RuboCop::Cop::RSpec::InvalidPredicateMatcher - def invalid_predicate_matcher?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::InvalidPredicateMatcher -end - -class RuboCop::Cop::RSpec::ItBehavesLike - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def example_inclusion_offense(node=T.unsafe(nil), param1); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ItBehavesLike -end - -class RuboCop::Cop::RSpec::IteratedExpectation - def each?(node=T.unsafe(nil)); end - - def expectation?(node=T.unsafe(nil), param1); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::IteratedExpectation -end - -class RuboCop::Cop::RSpec::LeadingSubject - def autocorrect(node); end - - def check_previous_nodes(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LeadingSubject -end - -class RuboCop::Cop::RSpec::LeakyConstantDeclaration - def in_example_or_shared_group?(node=T.unsafe(nil)); end - - def on_casgn(node); end - - def on_class(node); end - - def on_module(node); end - MSG_CLASS = ::T.let(nil, ::T.untyped) - MSG_CONST = ::T.let(nil, ::T.untyped) - MSG_MODULE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LeakyConstantDeclaration -end - -class RuboCop::Cop::RSpec::LetBeforeExamples - def autocorrect(node); end - - def example_or_group?(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LetBeforeExamples -end - -class RuboCop::Cop::RSpec::LetSetup - def let_bang(node0); end - - def method_called?(node0, param1); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LetSetup -end - -class RuboCop::Cop::RSpec::MessageChain - def message(node); end - - def message_chain(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageChain -end - -class RuboCop::Cop::RSpec::MessageExpectation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def message_expectation(node=T.unsafe(nil)); end - - def on_send(node); end - - def receive_message?(node0); end - MSG = ::T.let(nil, ::T.untyped) - SUPPORTED_STYLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageExpectation -end - -class RuboCop::Cop::RSpec::MessageSpies - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def message_expectation(node=T.unsafe(nil)); end - - def on_send(node); end - - def receive_message(node0); end - MSG_HAVE_RECEIVED = ::T.let(nil, ::T.untyped) - MSG_RECEIVE = ::T.let(nil, ::T.untyped) - SUPPORTED_STYLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageSpies -end - -class RuboCop::Cop::RSpec::MissingExampleGroupArgument - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MissingExampleGroupArgument -end - -class RuboCop::Cop::RSpec::MultipleDescribes - include ::RuboCop::RSpec::TopLevelDescribe - def on_top_level_describe(node, _args); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleDescribes -end - -class RuboCop::Cop::RSpec::MultipleExpectations - include ::RuboCop::Cop::ConfigurableMax - def aggregate_failures?(node=T.unsafe(nil)); end - - def aggregate_failures_block?(node=T.unsafe(nil)); end - - def aggregate_failures_present?(node=T.unsafe(nil)); end - - def expect?(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleExpectations -end - -class RuboCop::Cop::RSpec::MultipleSubjects - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleSubjects -end - -class RuboCop::Cop::RSpec::NamedSubject - def ignored_shared_example?(node); end - - def on_block(node); end - - def rspec_block?(node=T.unsafe(nil)); end - - def shared_example?(node=T.unsafe(nil)); end - - def subject_usage(node0); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NamedSubject -end - -class RuboCop::Cop::RSpec::NestedGroups - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::RSpec::TopLevelDescribe - def find_contexts(node0); end - - def on_top_level_describe(node, _args); end - DEPRECATED_MAX_KEY = ::T.let(nil, ::T.untyped) - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NestedGroups -end - -class RuboCop::Cop::RSpec::NotToNot - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def not_to_not_offense(node=T.unsafe(nil), param1); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NotToNot -end - -class RuboCop::Cop::RSpec::OverwritingSetup - def first_argument_name(node=T.unsafe(nil)); end - - def on_block(node); end - - def setup?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::OverwritingSetup -end - -class RuboCop::Cop::RSpec::Pending - def on_send(node); end - - def pending_block?(node=T.unsafe(nil)); end - - def skip_or_pending?(node=T.unsafe(nil)); end - - def skippable?(node=T.unsafe(nil)); end - - def skipped_in_metadata?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - PENDING = ::T.let(nil, ::T.untyped) - SKIPPABLE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Pending -end - -class RuboCop::Cop::RSpec::PredicateMatcher - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RSpec::InflectedHelper - include ::RuboCop::Cop::RSpec::ExplicitHelper - def autocorrect(node); end - - def on_block(node); end - - def on_send(node); end -end - -class RuboCop::Cop::RSpec::PredicateMatcher -end - -class RuboCop::Cop::RSpec::ReceiveCounts - def autocorrect(node); end - - def on_send(node); end - - def receive_counts(node=T.unsafe(nil)); end - - def stub?(node0); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReceiveCounts -end - -class RuboCop::Cop::RSpec::ReceiveNever - def autocorrect(node); end - - def method_on_stub?(node0); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReceiveNever -end - -class RuboCop::Cop::RSpec::RepeatedDescription - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedDescription -end - -class RuboCop::Cop::RSpec::RepeatedExample - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExample -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupBody - def body(node=T.unsafe(nil)); end - - def const_arg(node=T.unsafe(nil)); end - - def metadata(node=T.unsafe(nil)); end - - def on_begin(node); end - - def several_example_groups?(node=T.unsafe(nil)); end - - def skip_or_pending?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupBody -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription - def doc_string_and_metadata(node=T.unsafe(nil)); end - - def empty_description?(node=T.unsafe(nil)); end - - def on_begin(node); end - - def several_example_groups?(node=T.unsafe(nil)); end - - def skip_or_pending?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription -end - -class RuboCop::Cop::RSpec::ReturnFromStub - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def and_return_value(node0); end - - def autocorrect(node); end - - def contains_stub?(node0); end - - def on_block(node); end - - def on_send(node); end - MSG_AND_RETURN = ::T.let(nil, ::T.untyped) - MSG_BLOCK = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector - def call(corrector); end - - def initialize(node); end -end - -class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector -end - -class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector - def call(corrector); end - - def initialize(block); end - NULL_BLOCK_BODY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector -end - -class RuboCop::Cop::RSpec::ReturnFromStub -end - -class RuboCop::Cop::RSpec::ScatteredLet - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ScatteredLet -end - -class RuboCop::Cop::RSpec::ScatteredSetup - def lines_msg(numbers); end - - def on_block(node); end - - def repeated_hooks(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ScatteredSetup -end - -class RuboCop::Cop::RSpec::SharedContext - def autocorrect(node); end - - def context?(node0); end - - def examples?(node0); end - - def on_block(node); end - - def shared_context(node=T.unsafe(nil)); end - - def shared_example(node=T.unsafe(nil)); end - MSG_CONTEXT = ::T.let(nil, ::T.untyped) - MSG_EXAMPLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SharedContext -end - -class RuboCop::Cop::RSpec::SharedExamples - def autocorrect(node); end - - def on_send(node); end - - def shared_examples(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::RSpec::SharedExamples::Checker - def initialize(node); end - - def message(); end - - def node(); end - - def preferred_style(); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SharedExamples::Checker -end - -class RuboCop::Cop::RSpec::SharedExamples -end - -class RuboCop::Cop::RSpec::SingleArgumentMessageChain - def autocorrect(node); end - - def message_chain(node=T.unsafe(nil)); end - - def on_send(node); end - - def single_key_hash?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SingleArgumentMessageChain -end - -class RuboCop::Cop::RSpec::SubjectStub - def message_expectation?(node=T.unsafe(nil), param1); end - - def message_expectation_matcher?(node0); end - - def on_block(node); end - - def subject(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SubjectStub -end - -class RuboCop::Cop::RSpec::UnspecifiedException - def block_with_args?(node); end - - def empty_exception_matcher?(node); end - - def empty_raise_error_or_exception(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::UnspecifiedException -end - -class RuboCop::Cop::RSpec::VariableDefinition - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::RSpec::Variable - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VariableDefinition -end - -class RuboCop::Cop::RSpec::VariableName - include ::RuboCop::Cop::ConfigurableNaming - include ::RuboCop::Cop::ConfigurableFormatting - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::RSpec::Variable - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VariableName -end - -class RuboCop::Cop::RSpec::VerifiedDoubles - def on_send(node); end - - def unverified_double(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VerifiedDoubles -end - -class RuboCop::Cop::RSpec::VoidExpect - def expect?(node=T.unsafe(nil)); end - - def expect_block?(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VoidExpect -end - -class RuboCop::Cop::RSpec::Yield - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def block_arg(node=T.unsafe(nil)); end - - def block_call?(node=T.unsafe(nil), param1); end - - def method_on_stub?(node0); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Yield -end - -module RuboCop::Cop::RSpec -end - -module RuboCop::Cop::RangeHelp - BYTE_ORDER_MARK = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RangeHelp -end - -module RuboCop::Cop::RationalLiteral - def rational_literal?(node=T.unsafe(nil)); end -end - -module RuboCop::Cop::RationalLiteral - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::RegexpLiteralHelp -end - -module RuboCop::Cop::RegexpLiteralHelp -end - -module RuboCop::Cop::RegexpMetacharacter -end - -module RuboCop::Cop::RegexpMetacharacter -end - -class RuboCop::Cop::Registry - include ::Enumerable - def ==(other); end - - def contains_cop_matching?(names); end - - def cops(); end - - def department_missing?(badge, name); end - - def departments(); end - - def dismiss(cop); end - - def each(&block); end - - def enabled(config, only=T.unsafe(nil), only_safe=T.unsafe(nil)); end - - def enabled?(cop, config, only_safe); end - - def enabled_pending_cop?(cop_cfg, config); end - - def enlist(cop); end - - def find_by_cop_name(cop_name); end - - def initialize(cops=T.unsafe(nil), options=T.unsafe(nil)); end - - def length(); end - - def names(); end - - def options(); end - - def print_warning(name, path); end - - def qualified_cop_name(name, path, shall_warn=T.unsafe(nil)); end - - def select(&block); end - - def sort!(); end - - def to_h(); end - - def unqualified_cop_names(); end - - def with_department(department); end - - def without_department(department); end -end - -class RuboCop::Cop::Registry - def self.all(); end - - def self.global(); end - - def self.qualified_cop_name(name, origin); end - - def self.with_temporary_global(temp_global=T.unsafe(nil)); end -end - -module RuboCop::Cop::RescueNode - def investigate(processed_source); end -end - -module RuboCop::Cop::RescueNode -end - -module RuboCop::Cop::SafeAssignment - def empty_condition?(node=T.unsafe(nil)); end - - def safe_assignment?(node=T.unsafe(nil)); end - - def setter_method?(node=T.unsafe(nil)); end -end - -module RuboCop::Cop::SafeAssignment - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::Security -end - -class RuboCop::Cop::Security::Eval - def eval?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::Eval -end - -class RuboCop::Cop::Security::JSONLoad - def autocorrect(node); end - - def json_load(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::JSONLoad -end - -class RuboCop::Cop::Security::MarshalLoad - def marshal_load(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::MarshalLoad -end - -class RuboCop::Cop::Security::Open - def on_send(node); end - - def open?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::Open -end - -class RuboCop::Cop::Security::YAMLLoad - def autocorrect(node); end - - def on_send(node); end - - def yaml_load(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::YAMLLoad -end - -module RuboCop::Cop::Security -end - -class RuboCop::Cop::Severity - include ::Comparable - def ==(other); end - - def code(); end - - def initialize(name_or_code); end - - def level(); end - - def name(); end - CODE_TABLE = ::T.let(nil, ::T.untyped) - NAMES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Severity - def self.name_from_code(code); end -end - -module RuboCop::Cop::SpaceAfterPunctuation - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SpaceAfterPunctuation -end - -module RuboCop::Cop::SpaceBeforePunctuation - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SpaceBeforePunctuation -end - -class RuboCop::Cop::SpaceCorrector -end - -class RuboCop::Cop::SpaceCorrector - extend ::RuboCop::Cop::SurroundingSpace - extend ::RuboCop::Cop::RangeHelp - def self.add_space(processed_source, corrector, left_token, right_token); end - - def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end - - def self.processed_source(); end - - def self.remove_space(processed_source, corrector, left_token, right_token); end -end - -module RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp -end - -module RuboCop::Cop::StatementModifier -end - -module RuboCop::Cop::StringHelp - def on_regexp(node); end - - def on_str(node); end -end - -module RuboCop::Cop::StringHelp -end - -class RuboCop::Cop::StringLiteralCorrector -end - -class RuboCop::Cop::StringLiteralCorrector - extend ::RuboCop::Cop::Util - extend ::RuboCop::PathUtil - def self.correct(node, style); end -end - -module RuboCop::Cop::StringLiteralsHelp - include ::RuboCop::Cop::StringHelp -end - -module RuboCop::Cop::StringLiteralsHelp -end - -module RuboCop::Cop::Style -end - -class RuboCop::Cop::Style::AccessModifierDeclarations - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def access_modifier_with_symbol?(node=T.unsafe(nil)); end - - def on_send(node); end - GROUP_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) - INLINE_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AccessModifierDeclarations -end - -class RuboCop::Cop::Style::Alias - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def identifier(node=T.unsafe(nil)); end - - def on_alias(node); end - - def on_send(node); end - MSG_ALIAS = ::T.let(nil, ::T.untyped) - MSG_ALIAS_METHOD = ::T.let(nil, ::T.untyped) - MSG_SYMBOL_ARGS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Alias -end - -class RuboCop::Cop::Style::AndOr - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_and(node); end - - def on_if(node); end - - def on_or(node); end - - def on_until(node); end - - def on_until_post(node); end - - def on_while(node); end - - def on_while_post(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AndOr -end - -module RuboCop::Cop::Style::AnnotationComment -end - -module RuboCop::Cop::Style::AnnotationComment -end - -class RuboCop::Cop::Style::ArrayJoin - def autocorrect(node); end - - def join_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ArrayJoin -end - -class RuboCop::Cop::Style::AsciiComments - include ::RuboCop::Cop::RangeHelp - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AsciiComments -end - -class RuboCop::Cop::Style::Attr - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def class_eval?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Attr -end - -class RuboCop::Cop::Style::AutoResourceCleanup - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - TARGET_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AutoResourceCleanup -end - -class RuboCop::Cop::Style::BarePercentLiterals - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_dstr(node); end - - def on_str(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BarePercentLiterals -end - -class RuboCop::Cop::Style::BeginBlock - def on_preexe(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BeginBlock -end - -class RuboCop::Cop::Style::BlockComments - include ::RuboCop::Cop::RangeHelp - def autocorrect(comment); end - - def investigate(processed_source); end - BEGIN_LENGTH = ::T.let(nil, ::T.untyped) - END_LENGTH = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BlockComments -end - -class RuboCop::Cop::Style::BlockDelimiters - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::IgnoredMethods - def autocorrect(node); end - - def on_block(node); end - - def on_send(node); end - ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped) - BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BlockDelimiters -end - -class RuboCop::Cop::Style::CaseCorrector -end - -class RuboCop::Cop::Style::CaseCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper - def self.correct(cop, node); end - - def self.move_assignment_inside_condition(node); end -end - -class RuboCop::Cop::Style::CaseEquality - def case_equality?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CaseEquality -end - -class RuboCop::Cop::Style::CharacterLiteral - include ::RuboCop::Cop::StringHelp - def autocorrect(node); end - - def correct_style_detected(); end - - def offense?(node); end - - def opposite_style_detected(); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CharacterLiteral -end - -class RuboCop::Cop::Style::ClassAndModuleChildren - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_class(node); end - - def on_module(node); end - COMPACT_MSG = ::T.let(nil, ::T.untyped) - NESTED_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassAndModuleChildren -end - -class RuboCop::Cop::Style::ClassCheck - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def class_check?(node=T.unsafe(nil)); end - - def message(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassCheck -end - -class RuboCop::Cop::Style::ClassMethods - def autocorrect(node); end - - def on_class(node); end - - def on_module(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassMethods -end - -class RuboCop::Cop::Style::ClassVars - def message(node); end - - def on_cvasgn(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassVars -end - -class RuboCop::Cop::Style::CollectionMethods - include ::RuboCop::Cop::MethodPreference - def autocorrect(node); end - - def on_block(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CollectionMethods -end - -class RuboCop::Cop::Style::ColonMethodCall - def autocorrect(node); end - - def java_type_node?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ColonMethodCall -end - -class RuboCop::Cop::Style::ColonMethodDefinition - def autocorrect(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ColonMethodDefinition -end - -class RuboCop::Cop::Style::CommandLiteral - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_xstr(node); end - MSG_USE_BACKTICKS = ::T.let(nil, ::T.untyped) - MSG_USE_PERCENT_X = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommandLiteral -end - -class RuboCop::Cop::Style::CommentAnnotation - include ::RuboCop::Cop::Style::AnnotationComment - include ::RuboCop::Cop::RangeHelp - def autocorrect(comment); end - - def investigate(processed_source); end - MISSING_NOTE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommentAnnotation -end - -class RuboCop::Cop::Style::CommentedKeyword - def investigate(processed_source); end - ALLOWED_COMMENTS = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommentedKeyword -end - -class RuboCop::Cop::Style::ConditionalAssignment - include ::RuboCop::Cop::Style::ConditionalAssignmentHelper - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def assignment_type?(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def candidate_condition?(node=T.unsafe(nil)); end - - def on_and_asgn(node); end - - def on_case(node); end - - def on_casgn(node); end - - def on_cvasgn(node); end - - def on_gvasgn(node); end - - def on_if(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_op_asgn(node); end - - def on_or_asgn(node); end - - def on_send(node); end - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - ASSIGN_TO_CONDITION_MSG = ::T.let(nil, ::T.untyped) - ENABLED = ::T.let(nil, ::T.untyped) - INDENTATION_WIDTH = ::T.let(nil, ::T.untyped) - LINE_LENGTH = ::T.let(nil, ::T.untyped) - MAX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SINGLE_LINE_CONDITIONS_ONLY = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - WIDTH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ConditionalAssignment -end - -module RuboCop::Cop::Style::ConditionalAssignmentHelper - def end_with_eq?(sym); end - - def expand_elses(branch); end - - def expand_when_branches(when_branches); end - - def indent(cop, source); end - - def lhs(node); end - - def tail(branch); end - ALIGN_WITH = ::T.let(nil, ::T.untyped) - END_ALIGNMENT = ::T.let(nil, ::T.untyped) - EQUAL = ::T.let(nil, ::T.untyped) - KEYWORD = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::Cop::Style::ConditionalCorrectorHelper - def assignment(node); end - - def correct_branches(corrector, branches); end - - def correct_if_branches(corrector, cop, node); end - - def remove_whitespace_in_branches(corrector, branch, condition, column); end - - def replace_branch_assignment(corrector, branch); end - - def white_space_range(node, column); end -end - -module RuboCop::Cop::Style::ConditionalCorrectorHelper -end - -class RuboCop::Cop::Style::ConstantVisibility - def on_casgn(node); end - - def visibility_declaration_for?(node=T.unsafe(nil), param1); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ConstantVisibility -end - -class RuboCop::Cop::Style::Copyright - include ::RuboCop::Cop::RangeHelp - def autocorrect(token); end - - def investigate(processed_source); end - AUTOCORRECT_EMPTY_WARNING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Copyright -end - -class RuboCop::Cop::Style::DateTime - def date_time?(node=T.unsafe(nil)); end - - def historic_date?(node=T.unsafe(nil)); end - - def on_send(node); end - - def to_datetime?(node=T.unsafe(nil)); end - CLASS_MSG = ::T.let(nil, ::T.untyped) - COERCION_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DateTime -end - -class RuboCop::Cop::Style::DefWithParentheses - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DefWithParentheses -end - -class RuboCop::Cop::Style::Dir - def autocorrect(node); end - - def dir_replacement?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Dir -end - -class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective - def autocorrect(comment); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective -end - -class RuboCop::Cop::Style::Documentation - include ::RuboCop::Cop::DocumentationComment - include ::RuboCop::Cop::Style::AnnotationComment - def constant_definition?(node=T.unsafe(nil)); end - - def constant_visibility_declaration?(node=T.unsafe(nil)); end - - def on_class(node); end - - def on_module(node); end - - def outer_module(node0); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Documentation -end - -class RuboCop::Cop::Style::DocumentationMethod - include ::RuboCop::Cop::DocumentationComment - include ::RuboCop::Cop::Style::AnnotationComment - include ::RuboCop::Cop::DefNode - def module_function_node?(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DocumentationMethod -end - -class RuboCop::Cop::Style::DoubleCopDisableDirective - def autocorrect(comment); end - - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DoubleCopDisableDirective -end - -class RuboCop::Cop::Style::DoubleNegation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def double_negative?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DoubleNegation -end - -class RuboCop::Cop::Style::EachForSimpleLoop - def autocorrect(node); end - - def offending_each_range(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EachForSimpleLoop -end - -class RuboCop::Cop::Style::EachWithObject - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def each_with_object_candidate?(node=T.unsafe(nil)); end - - def on_block(node); end - METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EachWithObject -end - -class RuboCop::Cop::Style::EmptyBlockParameter - include ::RuboCop::Cop::EmptyParameter - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyBlockParameter -end - -class RuboCop::Cop::Style::EmptyCaseCondition - include ::RuboCop::Cop::RangeHelp - def autocorrect(case_node); end - - def on_case(case_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyCaseCondition -end - -class RuboCop::Cop::Style::EmptyElse - include ::RuboCop::Cop::OnNormalIfUnless - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_case(node); end - - def on_normal_if_unless(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyElse -end - -class RuboCop::Cop::Style::EmptyLambdaParameter - include ::RuboCop::Cop::EmptyParameter - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyLambdaParameter -end - -class RuboCop::Cop::Style::EmptyLiteral - include ::RuboCop::Cop::FrozenStringLiteral - include ::RuboCop::Cop::RangeHelp - def array_node(node=T.unsafe(nil)); end - - def array_with_block(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def hash_node(node=T.unsafe(nil)); end - - def hash_with_block(node=T.unsafe(nil)); end - - def on_send(node); end - - def str_node(node=T.unsafe(nil)); end - ARR_MSG = ::T.let(nil, ::T.untyped) - HASH_MSG = ::T.let(nil, ::T.untyped) - STR_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyLiteral -end - -class RuboCop::Cop::Style::EmptyMethod - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG_COMPACT = ::T.let(nil, ::T.untyped) - MSG_EXPANDED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyMethod -end - -class RuboCop::Cop::Style::Encoding - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - ENCODING_PATTERN = ::T.let(nil, ::T.untyped) - MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Encoding -end - -class RuboCop::Cop::Style::EndBlock - def autocorrect(node); end - - def on_postexe(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EndBlock -end - -class RuboCop::Cop::Style::EvalWithLocation - def eval_without_location?(node=T.unsafe(nil)); end - - def line_with_offset?(node=T.unsafe(nil), param1, param2); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - MSG_INCORRECT_LINE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EvalWithLocation -end - -class RuboCop::Cop::Style::EvenOdd - def autocorrect(node); end - - def even_odd_candidate?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EvenOdd -end - -class RuboCop::Cop::Style::ExpandPathArguments - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def file_expand_path(node=T.unsafe(nil)); end - - def on_send(node); end - - def pathname_new_parent_expand_path(node=T.unsafe(nil)); end - - def pathname_parent_expand_path(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - PATHNAME_MSG = ::T.let(nil, ::T.untyped) - PATHNAME_NEW_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ExpandPathArguments -end - -class RuboCop::Cop::Style::ExponentialNotation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def on_float(node); end -end - -class RuboCop::Cop::Style::ExponentialNotation -end - -class RuboCop::Cop::Style::FloatDivision - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def any_coerce?(node=T.unsafe(nil)); end - - def both_coerce?(node=T.unsafe(nil)); end - - def left_coerce?(node=T.unsafe(nil)); end - - def on_send(node); end - - def right_coerce?(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::FloatDivision -end - -class RuboCop::Cop::Style::For - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def on_for(node); end - EACH_LENGTH = ::T.let(nil, ::T.untyped) - PREFER_EACH = ::T.let(nil, ::T.untyped) - PREFER_FOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::For -end - -class RuboCop::Cop::Style::FormatString - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def formatter(node=T.unsafe(nil)); end - - def message(detected_style); end - - def method_name(style_name); end - - def on_send(node); end - - def variable_argument?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FormatString -end - -class RuboCop::Cop::Style::FormatStringToken - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def format_string_in_typical_context?(node=T.unsafe(nil)); end - - def on_str(node); end -end - -class RuboCop::Cop::Style::FormatStringToken -end - -class RuboCop::Cop::Style::FrozenStringLiteralComment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::FrozenStringLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def investigate(processed_source); end - MSG_DISABLED = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) - MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped) - MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FrozenStringLiteralComment -end - -class RuboCop::Cop::Style::GlobalVars - def allowed_var?(global_var); end - - def check(node); end - - def on_gvar(node); end - - def on_gvasgn(node); end - - def user_vars(); end - BUILT_IN_VARS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::GlobalVars -end - -class RuboCop::Cop::Style::GuardClause - include ::RuboCop::Cop::MinBodyLength - include ::RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp - def on_def(node); end - - def on_defs(node); end - - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::GuardClause -end - -class RuboCop::Cop::Style::HashEachMethods - include ::RuboCop::Cop::Lint::UnusedArgument - def autocorrect(node); end - - def kv_each(node=T.unsafe(nil)); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashEachMethods -end - -class RuboCop::Cop::Style::HashSyntax - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def hash_rockets_check(pairs); end - - def no_mixed_keys_check(pairs); end - - def on_hash(node); end - - def ruby19_check(pairs); end - - def ruby19_no_mixed_keys_check(pairs); end - MSG_19 = ::T.let(nil, ::T.untyped) - MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped) - MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashSyntax -end - -class RuboCop::Cop::Style::HashTransformKeys - include ::RuboCop::Cop::HashTransformMethod - def on_bad_each_with_object(node=T.unsafe(nil)); end - - def on_bad_hash_brackets_map(node=T.unsafe(nil)); end - - def on_bad_map_to_h(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::HashTransformKeys - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Style::HashTransformValues - include ::RuboCop::Cop::HashTransformMethod - def on_bad_each_with_object(node=T.unsafe(nil)); end - - def on_bad_hash_brackets_map(node=T.unsafe(nil)); end - - def on_bad_map_to_h(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::HashTransformValues -end - -class RuboCop::Cop::Style::IdenticalConditionalBranches - def on_case(node); end - - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IdenticalConditionalBranches -end - -class RuboCop::Cop::Style::IfCorrector -end - -class RuboCop::Cop::Style::IfCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper - def self.correct(cop, node); end - - def self.move_assignment_inside_condition(node); end -end - -class RuboCop::Cop::Style::IfInsideElse - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfInsideElse -end - -class RuboCop::Cop::Style::IfUnlessModifier - include ::RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp - include ::RuboCop::Cop::IgnoredPattern - def autocorrect(node); end - - def on_if(node); end - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - MSG_USE_MODIFIER = ::T.let(nil, ::T.untyped) - MSG_USE_NORMAL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfUnlessModifier -end - -class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless - include ::RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless -end - -class RuboCop::Cop::Style::IfWithSemicolon - include ::RuboCop::Cop::OnNormalIfUnless - def autocorrect(node); end - - def on_normal_if_unless(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfWithSemicolon -end - -class RuboCop::Cop::Style::ImplicitRuntimeError - def implicit_runtime_error_raise_or_fail(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ImplicitRuntimeError -end - -class RuboCop::Cop::Style::InfiniteLoop - def after_leaving_scope(scope, _variable_table); end - - def autocorrect(node); end - - def join_force?(force_class); end - - def on_until(node); end - - def on_until_post(node); end - - def on_while(node); end - - def on_while_post(node); end - LEADING_SPACE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InfiniteLoop -end - -class RuboCop::Cop::Style::InlineComment - def investigate(processed_source); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InlineComment -end - -class RuboCop::Cop::Style::InverseMethods - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def correct_inverse_block(node); end - - def correct_inverse_method(node); end - - def correct_inverse_selector(block, corrector); end - - def inverse_block?(node=T.unsafe(nil)); end - - def inverse_candidate?(node=T.unsafe(nil)); end - - def on_block(node); end - - def on_send(node); end - CAMEL_CASE = ::T.let(nil, ::T.untyped) - CLASS_COMPARISON_METHODS = ::T.let(nil, ::T.untyped) - EQUALITY_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InverseMethods -end - -class RuboCop::Cop::Style::IpAddresses - include ::RuboCop::Cop::StringHelp - def correct_style_detected(); end - - def offense?(node); end - - def opposite_style_detected(); end - IPV6_MAX_SIZE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IpAddresses -end - -class RuboCop::Cop::Style::Lambda - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_block(node); end - - def on_numblock(node); end - LITERAL_MESSAGE = ::T.let(nil, ::T.untyped) - METHOD_MESSAGE = ::T.let(nil, ::T.untyped) - OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Lambda -end - -class RuboCop::Cop::Style::LambdaCall - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_send(node); end -end - -class RuboCop::Cop::Style::LambdaCall -end - -class RuboCop::Cop::Style::LineEndConcatenation - include ::RuboCop::Cop::RangeHelp - def autocorrect(operator_range); end - - def investigate(processed_source); end - COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped) - COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped) - CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped) - HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped) - SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::LineEndConcatenation -end - -class RuboCop::Cop::Style::MethodCallWithArgsParentheses - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::IgnoredMethods - include ::RuboCop::Cop::IgnoredPattern - def autocorrect(_node); end - - def initialize(*_); end -end - -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses - def autocorrect(node); end - - def message(_node=T.unsafe(nil)); end - - def on_csend(node); end - - def on_send(node); end - - def on_super(node); end - - def on_yield(node); end - TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses -end - -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses - def autocorrect(node); end - - def message(_node=T.unsafe(nil)); end - - def on_csend(node); end - - def on_send(node); end - - def on_super(node); end - - def on_yield(node); end -end - -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses -end - -class RuboCop::Cop::Style::MethodCallWithArgsParentheses -end - -class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses - include ::RuboCop::Cop::IgnoredMethods - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses -end - -class RuboCop::Cop::Style::MethodCalledOnDoEndBlock - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodCalledOnDoEndBlock -end - -class RuboCop::Cop::Style::MethodDefParentheses - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG_MISSING = ::T.let(nil, ::T.untyped) - MSG_PRESENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodDefParentheses -end - -class RuboCop::Cop::Style::MethodMissingSuper - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodMissingSuper -end - -class RuboCop::Cop::Style::MinMax - def autocorrect(node); end - - def min_max_candidate(node=T.unsafe(nil)); end - - def on_array(node); end - - def on_return(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MinMax -end - -class RuboCop::Cop::Style::MissingElse - include ::RuboCop::Cop::OnNormalIfUnless - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def on_case(node); end - - def on_normal_if_unless(node); end - MSG = ::T.let(nil, ::T.untyped) - MSG_EMPTY = ::T.let(nil, ::T.untyped) - MSG_NIL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MissingElse -end - -class RuboCop::Cop::Style::MissingRespondToMissing - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MissingRespondToMissing -end - -class RuboCop::Cop::Style::MixinGrouping - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_class(node); end - - def on_module(node); end - MIXIN_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MixinGrouping -end - -class RuboCop::Cop::Style::MixinUsage - def include_statement(node=T.unsafe(nil)); end - - def on_send(node); end - - def wrapped_macro_scope?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MixinUsage -end - -class RuboCop::Cop::Style::ModuleFunction - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def extend_self_node?(node=T.unsafe(nil)); end - - def module_function_node?(node=T.unsafe(nil)); end - - def on_module(node); end - - def private_directive?(node=T.unsafe(nil)); end - EXTEND_SELF_MSG = ::T.let(nil, ::T.untyped) - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - MODULE_FUNCTION_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ModuleFunction -end - -class RuboCop::Cop::Style::MultilineBlockChain - include ::RuboCop::Cop::RangeHelp - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineBlockChain -end - -class RuboCop::Cop::Style::MultilineIfModifier - include ::RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineIfModifier -end - -class RuboCop::Cop::Style::MultilineIfThen - include ::RuboCop::Cop::OnNormalIfUnless - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_normal_if_unless(node); end - MSG = ::T.let(nil, ::T.untyped) - NON_MODIFIER_THEN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineIfThen -end - -class RuboCop::Cop::Style::MultilineMemoization - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_or_asgn(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineMemoization -end - -class RuboCop::Cop::Style::MultilineMethodSignature - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineMethodSignature -end - -class RuboCop::Cop::Style::MultilineTernaryOperator - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineTernaryOperator -end - -class RuboCop::Cop::Style::MultilineWhenThen - include ::RuboCop::Cop::RangeHelp - def accept_node_type?(node); end - - def autocorrect(node); end - - def on_when(node); end - - def require_then?(when_node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineWhenThen -end - -class RuboCop::Cop::Style::MultipleComparison - def on_or(node); end - - def simple_comparison?(node=T.unsafe(nil)); end - - def simple_double_comparison?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultipleComparison -end - -class RuboCop::Cop::Style::MutableConstant - include ::RuboCop::Cop::FrozenStringLiteral - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_casgn(node); end - - def on_or_asgn(node); end - - def operation_produces_immutable_object?(node=T.unsafe(nil)); end - - def range_enclosed_in_parentheses?(node=T.unsafe(nil)); end - - def splat_value(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MutableConstant -end - -class RuboCop::Cop::Style::NegatedIf - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::NegativeConditional - def autocorrect(node); end - - def on_if(node); end -end - -class RuboCop::Cop::Style::NegatedIf -end - -class RuboCop::Cop::Style::NegatedUnless - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::NegativeConditional - def autocorrect(node); end - - def on_if(node); end -end - -class RuboCop::Cop::Style::NegatedUnless -end - -class RuboCop::Cop::Style::NegatedWhile - include ::RuboCop::Cop::NegativeConditional - def autocorrect(node); end - - def on_until(node); end - - def on_while(node); end -end - -class RuboCop::Cop::Style::NegatedWhile -end - -class RuboCop::Cop::Style::NestedModifier - include ::RuboCop::Cop::RangeHelp - def add_parentheses_to_method_arguments(send_node); end - - def autocorrect(node); end - - def check(node); end - - def left_hand_operand(node, operator); end - - def modifier?(node); end - - def new_expression(inner_node); end - - def on_if(node); end - - def on_until(node); end - - def on_while(node); end - - def replacement_operator(keyword); end - - def requires_parens?(node); end - - def right_hand_operand(node, left_hand_keyword); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedModifier -end - -class RuboCop::Cop::Style::NestedParenthesizedCalls - include ::RuboCop::Cop::RangeHelp - def autocorrect(nested); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedParenthesizedCalls -end - -class RuboCop::Cop::Style::NestedTernaryOperator - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedTernaryOperator -end - -class RuboCop::Cop::Style::Next - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::MinBodyLength - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def investigate(_processed_source); end - - def on_block(node); end - - def on_for(node); end - - def on_until(node); end - - def on_while(node); end - EXIT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Next -end - -class RuboCop::Cop::Style::NilComparison - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def nil_check?(node=T.unsafe(nil)); end - - def nil_comparison?(node=T.unsafe(nil)); end - - def on_send(node); end - EXPLICIT_MSG = ::T.let(nil, ::T.untyped) - PREDICATE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NilComparison -end - -class RuboCop::Cop::Style::NonNilCheck - def autocorrect(node); end - - def nil_check?(node=T.unsafe(nil)); end - - def not_and_nil_check?(node=T.unsafe(nil)); end - - def not_equal_to_nil?(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - - def on_send(node); end - - def unless_check?(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::NonNilCheck -end - -class RuboCop::Cop::Style::Not - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - OPPOSITE_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Not -end - -class RuboCop::Cop::Style::NumericLiteralPrefix - include ::RuboCop::Cop::IntegerNode - def autocorrect(node); end - - def on_int(node); end - BINARY_MSG = ::T.let(nil, ::T.untyped) - BINARY_REGEX = ::T.let(nil, ::T.untyped) - DECIMAL_MSG = ::T.let(nil, ::T.untyped) - DECIMAL_REGEX = ::T.let(nil, ::T.untyped) - HEX_MSG = ::T.let(nil, ::T.untyped) - HEX_REGEX = ::T.let(nil, ::T.untyped) - OCTAL_MSG = ::T.let(nil, ::T.untyped) - OCTAL_REGEX = ::T.let(nil, ::T.untyped) - OCTAL_ZERO_ONLY_MSG = ::T.let(nil, ::T.untyped) - OCTAL_ZERO_ONLY_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericLiteralPrefix -end - -class RuboCop::Cop::Style::NumericLiterals - include ::RuboCop::Cop::ConfigurableMax - include ::RuboCop::Cop::IntegerNode - def autocorrect(node); end - - def on_float(node); end - - def on_int(node); end - DELIMITER_REGEXP = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericLiterals -end - -class RuboCop::Cop::Style::NumericPredicate - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::IgnoredMethods - def autocorrect(node); end - - def comparison(node=T.unsafe(nil)); end - - def inverted_comparison(node=T.unsafe(nil)); end - - def on_send(node); end - - def predicate(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - REPLACEMENTS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericPredicate -end - -class RuboCop::Cop::Style::OneLineConditional - include ::RuboCop::Cop::OnNormalIfUnless - def autocorrect(node); end - - def on_normal_if_unless(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OneLineConditional -end - -class RuboCop::Cop::Style::OptionHash - def on_args(node); end - - def option_hash(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OptionHash -end - -class RuboCop::Cop::Style::OptionalArguments - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OptionalArguments -end - -class RuboCop::Cop::Style::OrAssignment - def autocorrect(node); end - - def on_cvasgn(node); end - - def on_gvasgn(node); end - - def on_if(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - - def ternary_assignment?(node=T.unsafe(nil)); end - - def unless_assignment?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OrAssignment -end - -class RuboCop::Cop::Style::ParallelAssignment - include ::RuboCop::Cop::RescueNode - def autocorrect(node); end - - def implicit_self_getter?(node=T.unsafe(nil)); end - - def on_masgn(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter - include ::TSort - def accesses?(rhs, lhs); end - - def dependency?(lhs, rhs); end - - def initialize(assignments); end - - def matching_calls(node0, param1, param2); end - - def tsort_each_child(assignment); end - - def uses_var?(node0, param1); end - - def var_name(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter - extend ::RuboCop::AST::NodePattern::Macros -end - -class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - include ::RuboCop::Cop::Alignment - def assignment(); end - - def config(); end - - def correction(); end - - def correction_range(); end - - def initialize(node, config, new_elements); end - - def node(); end -end - -class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector -end - -class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector -end - -class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector -end - -class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector -end - -class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector -end - -class RuboCop::Cop::Style::ParallelAssignment -end - -class RuboCop::Cop::Style::ParenthesesAroundCondition - include ::RuboCop::Cop::SafeAssignment - include ::RuboCop::Cop::Parentheses - def autocorrect(node); end - - def control_op_condition(node=T.unsafe(nil)); end - - def on_if(node); end - - def on_until(node); end - - def on_while(node); end -end - -class RuboCop::Cop::Style::ParenthesesAroundCondition -end - -class RuboCop::Cop::Style::PercentLiteralDelimiters - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def message(node); end - - def on_array(node); end - - def on_dstr(node); end - - def on_regexp(node); end - - def on_str(node); end - - def on_sym(node); end - - def on_xstr(node); end -end - -class RuboCop::Cop::Style::PercentLiteralDelimiters -end - -class RuboCop::Cop::Style::PercentQLiterals - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_str(node); end - LOWER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) - UPPER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PercentQLiterals -end - -class RuboCop::Cop::Style::PerlBackrefs - def autocorrect(node); end - - def on_nth_ref(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PerlBackrefs -end - -class RuboCop::Cop::Style::PreferredHashMethods - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) - OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PreferredHashMethods -end - -class RuboCop::Cop::Style::Proc - def autocorrect(node); end - - def on_block(node); end - - def proc_new?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Proc -end - -class RuboCop::Cop::Style::RaiseArgs - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_send(node); end - COMPACT_MSG = ::T.let(nil, ::T.untyped) - EXPLODED_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RaiseArgs -end - -class RuboCop::Cop::Style::RandomWithOffset - def autocorrect(node); end - - def integer_op_rand?(node=T.unsafe(nil)); end - - def namespace(node=T.unsafe(nil)); end - - def on_send(node); end - - def rand_modified?(node=T.unsafe(nil)); end - - def rand_op_integer?(node=T.unsafe(nil)); end - - def random_call(node=T.unsafe(nil)); end - - def to_int(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RandomWithOffset -end - -class RuboCop::Cop::Style::RedundantBegin - def autocorrect(node); end - - def on_block(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantBegin -end - -class RuboCop::Cop::Style::RedundantCapitalW - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_array(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantCapitalW -end - -class RuboCop::Cop::Style::RedundantCondition - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_if(node); end - MSG = ::T.let(nil, ::T.untyped) - REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantCondition -end - -class RuboCop::Cop::Style::RedundantConditional - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_if(node); end - - def redundant_condition?(node=T.unsafe(nil)); end - - def redundant_condition_inverted?(node=T.unsafe(nil)); end - COMPARISON_OPERATOR_MATCHER = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantConditional -end - -class RuboCop::Cop::Style::RedundantException - def autocorrect(node); end - - def compact?(node=T.unsafe(nil)); end - - def exploded?(node=T.unsafe(nil)); end - - def on_send(node); end - MSG_1 = ::T.let(nil, ::T.untyped) - MSG_2 = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantException -end - -class RuboCop::Cop::Style::RedundantFreeze - include ::RuboCop::Cop::FrozenStringLiteral - def autocorrect(node); end - - def on_send(node); end - - def operation_produces_immutable_object?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantFreeze -end - -class RuboCop::Cop::Style::RedundantInterpolation - include ::RuboCop::Cop::PercentLiteral - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_dstr(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantInterpolation -end - -class RuboCop::Cop::Style::RedundantParentheses - include ::RuboCop::Cop::Parentheses - def arg_in_call_with_block?(node=T.unsafe(nil)); end - - def autocorrect(node); end - - def first_send_argument?(node=T.unsafe(nil)); end - - def first_super_argument?(node=T.unsafe(nil)); end - - def method_node_and_args(node=T.unsafe(nil)); end - - def on_begin(node); end - - def range_end?(node=T.unsafe(nil)); end - - def rescue?(node=T.unsafe(nil)); end - - def square_brackets?(node=T.unsafe(nil)); end -end - -class RuboCop::Cop::Style::RedundantParentheses -end - -class RuboCop::Cop::Style::RedundantPercentQ - def autocorrect(node); end - - def on_dstr(node); end - - def on_str(node); end - DYNAMIC_MSG = ::T.let(nil, ::T.untyped) - EMPTY = ::T.let(nil, ::T.untyped) - ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped) - PERCENT_Q = ::T.let(nil, ::T.untyped) - QUOTE = ::T.let(nil, ::T.untyped) - SINGLE_QUOTE = ::T.let(nil, ::T.untyped) - STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantPercentQ -end - -class RuboCop::Cop::Style::RedundantRegexpCharacterClass - include ::RuboCop::Cop::MatchRange - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::RegexpLiteralHelp - def autocorrect(node); end - - def each_redundant_character_class(node); end - - def on_regexp(node); end - MSG_REDUNDANT_CHARACTER_CLASS = ::T.let(nil, ::T.untyped) - PATTERN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantRegexpCharacterClass -end - -class RuboCop::Cop::Style::RedundantRegexpEscape - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::RegexpLiteralHelp - def autocorrect(node); end - - def on_regexp(node); end - ALLOWED_ALWAYS_ESCAPES = ::T.let(nil, ::T.untyped) - ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = ::T.let(nil, ::T.untyped) - ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = ::T.let(nil, ::T.untyped) - MSG_REDUNDANT_ESCAPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantRegexpEscape -end - -class RuboCop::Cop::Style::RedundantReturn - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) - MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantReturn -end - -class RuboCop::Cop::Style::RedundantSelf - def autocorrect(node); end - - def on_and_asgn(node); end - - def on_args(node); end - - def on_block(node); end - - def on_blockarg(node); end - - def on_def(node); end - - def on_defs(node); end - - def on_lvasgn(node); end - - def on_masgn(node); end - - def on_op_asgn(node); end - - def on_or_asgn(node); end - - def on_send(node); end - KERNEL_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSelf -end - -class RuboCop::Cop::Style::RedundantSort - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def redundant_sort?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSort -end - -class RuboCop::Cop::Style::RedundantSortBy - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_block(node); end - - def redundant_sort_by(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSortBy -end - -class RuboCop::Cop::Style::RegexpLiteral - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_regexp(node); end - MSG_USE_PERCENT_R = ::T.let(nil, ::T.untyped) - MSG_USE_SLASHES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RegexpLiteral -end - -class RuboCop::Cop::Style::RescueModifier - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::RescueNode - def autocorrect(node); end - - def on_resbody(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RescueModifier -end - -class RuboCop::Cop::Style::RescueStandardError - include ::RuboCop::Cop::RescueNode - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_resbody(node); end - - def rescue_standard_error?(node=T.unsafe(nil)); end - - def rescue_without_error_class?(node=T.unsafe(nil)); end - MSG_EXPLICIT = ::T.let(nil, ::T.untyped) - MSG_IMPLICIT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RescueStandardError -end - -class RuboCop::Cop::Style::ReturnNil - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def chained_send?(node=T.unsafe(nil)); end - - def define_method?(node=T.unsafe(nil)); end - - def on_return(node); end - - def return_nil_node?(node=T.unsafe(nil)); end - - def return_node?(node=T.unsafe(nil)); end - RETURN_MSG = ::T.let(nil, ::T.untyped) - RETURN_NIL_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ReturnNil -end - -class RuboCop::Cop::Style::SafeNavigation - include ::RuboCop::Cop::NilMethods - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def check_node(node); end - - def modifier_if_safe_navigation_candidate(node=T.unsafe(nil)); end - - def not_nil_check?(node=T.unsafe(nil)); end - - def on_and(node); end - - def on_if(node); end - - def use_var_only_in_unless_modifier?(node, variable); end - LOGIC_JUMP_KEYWORDS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SafeNavigation -end - -class RuboCop::Cop::Style::Sample - def autocorrect(node); end - - def on_send(node); end - - def sample_candidate?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Sample -end - -class RuboCop::Cop::Style::SelfAssignment - def autocorrect(node); end - - def on_cvasgn(node); end - - def on_ivasgn(node); end - - def on_lvasgn(node); end - MSG = ::T.let(nil, ::T.untyped) - OPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SelfAssignment -end - -class RuboCop::Cop::Style::Semicolon - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def investigate(processed_source); end - - def on_begin(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Semicolon -end - -class RuboCop::Cop::Style::Send - def on_csend(node); end - - def on_send(node); end - - def sending?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Send -end - -class RuboCop::Cop::Style::SignalException - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def custom_fail_methods(node0); end - - def investigate(processed_source); end - - def kernel_call?(node=T.unsafe(nil), param1); end - - def on_rescue(node); end - - def on_send(node); end - FAIL_MSG = ::T.let(nil, ::T.untyped) - RAISE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SignalException -end - -class RuboCop::Cop::Style::SingleLineBlockParams - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SingleLineBlockParams -end - -class RuboCop::Cop::Style::SingleLineMethods - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SingleLineMethods -end - -class RuboCop::Cop::Style::SlicingWithRange - def autocorrect(node); end - - def on_send(node); end - - def range_till_minus_one?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SlicingWithRange - extend ::RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Style::SpecialGlobalVars - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def message(node); end - - def on_gvar(node); end - ENGLISH_VARS = ::T.let(nil, ::T.untyped) - MSG_BOTH = ::T.let(nil, ::T.untyped) - MSG_ENGLISH = ::T.let(nil, ::T.untyped) - MSG_REGULAR = ::T.let(nil, ::T.untyped) - NON_ENGLISH_VARS = ::T.let(nil, ::T.untyped) - PERL_VARS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SpecialGlobalVars -end - -class RuboCop::Cop::Style::StabbyLambdaParentheses - include ::RuboCop::Cop::ConfigurableEnforcedStyle - def autocorrect(node); end - - def on_send(node); end - MSG_NO_REQUIRE = ::T.let(nil, ::T.untyped) - MSG_REQUIRE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StabbyLambdaParentheses -end - -class RuboCop::Cop::Style::StderrPuts - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_send(node); end - - def stderr_puts?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StderrPuts -end - -class RuboCop::Cop::Style::StringHashKeys - def autocorrect(node); end - - def on_pair(node); end - - def receive_environments_method?(node=T.unsafe(nil)); end - - def string_hash_key?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringHashKeys -end - -class RuboCop::Cop::Style::StringLiterals - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::StringLiteralsHelp - include ::RuboCop::Cop::StringHelp - def autocorrect(node); end - - def on_dstr(node); end - MSG_INCONSISTENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringLiterals -end - -class RuboCop::Cop::Style::StringLiteralsInInterpolation - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::StringLiteralsHelp - include ::RuboCop::Cop::StringHelp - def autocorrect(node); end -end - -class RuboCop::Cop::Style::StringLiteralsInInterpolation -end - -class RuboCop::Cop::Style::StringMethods - include ::RuboCop::Cop::MethodPreference - def autocorrect(node); end - - def on_csend(node); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringMethods -end - -class RuboCop::Cop::Style::Strip - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def lstrip_rstrip(node=T.unsafe(nil)); end - - def on_send(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Strip -end - -class RuboCop::Cop::Style::StructInheritance - def on_class(node); end - - def struct_constructor?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StructInheritance -end - -class RuboCop::Cop::Style::SymbolArray - include ::RuboCop::Cop::ArrayMinSize - include ::RuboCop::Cop::ArraySyntax - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::PercentArray - def autocorrect(node); end - - def on_array(node); end - ARRAY_MSG = ::T.let(nil, ::T.untyped) - PERCENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolArray - def self.largest_brackets(); end - - def self.largest_brackets=(largest_brackets); end -end - -class RuboCop::Cop::Style::SymbolLiteral - def autocorrect(node); end - - def on_sym(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolLiteral -end - -class RuboCop::Cop::Style::SymbolProc - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::Cop::IgnoredMethods - def autocorrect(node); end - - def destructuring_block_argument?(argument_node); end - - def on_block(node); end - - def proc_node?(node=T.unsafe(nil)); end - - def symbol_proc?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) - SUPER_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolProc -end - -class RuboCop::Cop::Style::TernaryCorrector -end - -class RuboCop::Cop::Style::TernaryCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper - def self.correct(node); end - - def self.move_assignment_inside_condition(node); end -end - -class RuboCop::Cop::Style::TernaryParentheses - include ::RuboCop::Cop::SafeAssignment - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def method_name(node=T.unsafe(nil)); end - - def on_if(node); end - - def only_closing_parenthesis_is_last_line?(condition); end - MSG = ::T.let(nil, ::T.untyped) - MSG_COMPLEX = ::T.let(nil, ::T.untyped) - NON_COMPLEX_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TernaryParentheses -end - -class RuboCop::Cop::Style::TrailingBodyOnClass - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::TrailingBody - def autocorrect(node); end - - def on_class(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnClass -end - -class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::TrailingBody - def autocorrect(node); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition -end - -class RuboCop::Cop::Style::TrailingBodyOnModule - include ::RuboCop::Cop::Alignment - include ::RuboCop::Cop::TrailingBody - def autocorrect(node); end - - def on_module(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnModule -end - -class RuboCop::Cop::Style::TrailingCommaInArguments - include ::RuboCop::Cop::TrailingComma - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_csend(node); end - - def on_send(node); end -end - -class RuboCop::Cop::Style::TrailingCommaInArguments -end - -class RuboCop::Cop::Style::TrailingCommaInArrayLiteral - include ::RuboCop::Cop::TrailingComma - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_array(node); end -end - -class RuboCop::Cop::Style::TrailingCommaInArrayLiteral -end - -class RuboCop::Cop::Style::TrailingCommaInBlockArgs - def autocorrect(node); end - - def on_block(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingCommaInBlockArgs -end - -class RuboCop::Cop::Style::TrailingCommaInHashLiteral - include ::RuboCop::Cop::TrailingComma - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(range); end - - def on_hash(node); end -end - -class RuboCop::Cop::Style::TrailingCommaInHashLiteral -end - -class RuboCop::Cop::Style::TrailingMethodEndStatement - include ::RuboCop::Cop::Alignment - def autocorrect(node); end - - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingMethodEndStatement -end - -class RuboCop::Cop::Style::TrailingUnderscoreVariable - include ::RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_masgn(node); end - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingUnderscoreVariable -end - -class RuboCop::Cop::Style::TrivialAccessors - def autocorrect(node); end - - def looks_like_trivial_writer?(node=T.unsafe(nil)); end - - def on_def(node); end - - def on_defs(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrivialAccessors -end - -class RuboCop::Cop::Style::UnlessElse - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def on_if(node); end - - def range_between_condition_and_else(node, condition); end - - def range_between_else_and_end(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::UnlessElse -end - -class RuboCop::Cop::Style::UnpackFirst - def autocorrect(node); end - - def on_send(node); end - - def unpack_and_first_element?(node=T.unsafe(nil)); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::UnpackFirst -end - -class RuboCop::Cop::Style::VariableInterpolation - include ::RuboCop::Cop::Interpolation - def autocorrect(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::VariableInterpolation -end - -class RuboCop::Cop::Style::WhenThen - def autocorrect(node); end - - def on_when(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhenThen -end - -class RuboCop::Cop::Style::WhileUntilDo - def autocorrect(node); end - - def handle(node); end - - def on_until(node); end - - def on_while(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhileUntilDo -end - -class RuboCop::Cop::Style::WhileUntilModifier - include ::RuboCop::Cop::StatementModifier - include ::RuboCop::Cop::LineLengthHelp - def autocorrect(node); end - - def on_until(node); end - - def on_while(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhileUntilModifier -end - -class RuboCop::Cop::Style::WordArray - include ::RuboCop::Cop::ArrayMinSize - include ::RuboCop::Cop::ArraySyntax - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::PercentArray - def autocorrect(node); end - - def on_array(node); end - ARRAY_MSG = ::T.let(nil, ::T.untyped) - PERCENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WordArray - def self.largest_brackets(); end - - def self.largest_brackets=(largest_brackets); end -end - -class RuboCop::Cop::Style::YodaCondition - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def file_constant_equal_program_name?(node=T.unsafe(nil)); end - - def on_send(node); end - EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped) - PROGRAM_NAMES = ::T.let(nil, ::T.untyped) - REVERSE_COMPARISON = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::YodaCondition -end - -class RuboCop::Cop::Style::ZeroLengthPredicate - def autocorrect(node); end - - def non_polymorphic_collection?(node=T.unsafe(nil)); end - - def nonzero_length_predicate(node=T.unsafe(nil)); end - - def on_send(node); end - - def other_receiver(node=T.unsafe(nil)); end - - def zero_length_predicate(node=T.unsafe(nil)); end - - def zero_length_receiver(node=T.unsafe(nil)); end - NONZERO_MSG = ::T.let(nil, ::T.untyped) - ZERO_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ZeroLengthPredicate -end - -module RuboCop::Cop::Style -end - -module RuboCop::Cop::SurroundingSpace - include ::RuboCop::Cop::RangeHelp - NO_SPACE_COMMAND = ::T.let(nil, ::T.untyped) - SINGLE_SPACE_REGEXP = ::T.let(nil, ::T.untyped) - SPACE_COMMAND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SurroundingSpace -end - -module RuboCop::Cop::TargetRubyVersion - def minimum_target_ruby_version(version); end - - def required_minimum_ruby_version(); end - - def support_target_ruby_version?(version); end -end - -module RuboCop::Cop::TargetRubyVersion -end - -class RuboCop::Cop::Team - def autocorrect(buffer, cops); end - - def autocorrect?(); end - - def cops(); end - - def debug?(); end - - def errors(); end - - def external_dependency_checksum(); end - - def forces(); end - - def forces_for(cops); end - - def initialize(cops, config=T.unsafe(nil), options=T.unsafe(nil)); end - - def inspect_file(processed_source); end - - def updated_source_file(); end - - def updated_source_file?(); end - - def warnings(); end - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Team::Investigation - def errors(); end - - def errors=(_); end - - def offenses(); end - - def offenses=(_); end -end - -class RuboCop::Cop::Team::Investigation - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Cop::Team - def self.mobilize(cop_classes, config, options=T.unsafe(nil)); end - - def self.mobilize_cops(cop_classes, config, options=T.unsafe(nil)); end - - def self.new(cop_or_classes, config, options=T.unsafe(nil)); end -end - -module RuboCop::Cop::TooManyLines - include ::RuboCop::Cop::CodeLength - include ::RuboCop::Cop::ConfigurableMax - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::TooManyLines -end - -module RuboCop::Cop::TrailingBody - def body_on_first_line?(node, body); end - - def first_part_of(body); end - - def trailing_body?(node); end -end - -module RuboCop::Cop::TrailingBody -end - -module RuboCop::Cop::TrailingComma - include ::RuboCop::Cop::ConfigurableEnforcedStyle - include ::RuboCop::Cop::RangeHelp - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::TrailingComma -end - -module RuboCop::Cop::UncommunicativeName - def check(node, args); end - CASE_MSG = ::T.let(nil, ::T.untyped) - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - LENGTH_MSG = ::T.let(nil, ::T.untyped) - NUM_MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::UncommunicativeName -end - -class RuboCop::Cop::UnusedArgCorrector -end - -class RuboCop::Cop::UnusedArgCorrector - extend ::RuboCop::Cop::RangeHelp - def self.correct(processed_source, node); end - - def self.correct_for_blockarg_type(node); end - - def self.processed_source(); end -end - -module RuboCop::Cop::Util - include ::RuboCop::PathUtil - LITERAL_REGEX = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Util - def self.add_parentheses(node, corrector); end - - def self.args_begin(node); end - - def self.args_end(node); end - - def self.begins_its_line?(range); end - - def self.comment_line?(line_source); end - - def self.comment_lines?(node); end - - def self.double_quotes_required?(string); end - - def self.escape_string(string); end - - def self.first_part_of_call_chain(node); end - - def self.interpret_string_escapes(string); end - - def self.line_range(node); end - - def self.needs_escaping?(string); end - - def self.on_node(syms, sexp, excludes=T.unsafe(nil), &block); end - - def self.parentheses?(node); end - - def self.same_line?(node1, node2); end - - def self.to_string_literal(string); end - - def self.to_supported_styles(enforced_style); end - - def self.tokens(node); end - - def self.trim_string_interporation_escape_character(str); end -end - -module RuboCop::Cop::Utils -end - -class RuboCop::Cop::Utils::FormatString - def format_sequences(); end - - def initialize(string); end - - def max_digit_dollar_num(); end - - def named_interpolation?(); end - - def valid?(); end - DIGIT_DOLLAR = ::T.let(nil, ::T.untyped) - FLAG = ::T.let(nil, ::T.untyped) - NAME = ::T.let(nil, ::T.untyped) - NUMBER = ::T.let(nil, ::T.untyped) - NUMBER_ARG = ::T.let(nil, ::T.untyped) - PRECISION = ::T.let(nil, ::T.untyped) - SEQUENCE = ::T.let(nil, ::T.untyped) - TEMPLATE_NAME = ::T.let(nil, ::T.untyped) - TYPE = ::T.let(nil, ::T.untyped) - WIDTH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Utils::FormatString::FormatSequence - def annotated?(); end - - def arity(); end - - def begin_pos(); end - - def end_pos(); end - - def flags(); end - - def initialize(match); end - - def max_digit_dollar_num(); end - - def name(); end - - def percent?(); end - - def precision(); end - - def style(); end - - def template?(); end - - def type(); end - - def width(); end -end - -class RuboCop::Cop::Utils::FormatString::FormatSequence -end - -class RuboCop::Cop::Utils::FormatString -end - -module RuboCop::Cop::Utils -end - -class RuboCop::Cop::VariableForce - def investigate(processed_source); end - - def process_node(node); end - - def variable_table(); end - ARGUMENT_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) - LOGICAL_OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - LOOP_TYPES = ::T.let(nil, ::T.untyped) - MULTIPLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) - OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped) - REGEXP_NAMED_CAPTURE_TYPE = ::T.let(nil, ::T.untyped) - RESCUE_TYPE = ::T.let(nil, ::T.untyped) - SCOPE_TYPES = ::T.let(nil, ::T.untyped) - SEND_TYPE = ::T.let(nil, ::T.untyped) - TWISTED_SCOPE_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_REFERENCE_TYPE = ::T.let(nil, ::T.untyped) - ZERO_ARITY_SUPER_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Assignment - include ::RuboCop::Cop::VariableForce::Branchable - def initialize(node, variable); end - - def meta_assignment_node(); end - - def multiple_assignment?(); end - - def name(); end - - def node(); end - - def operator(); end - - def operator_assignment?(); end - - def reference!(node); end - - def referenced(); end - - def referenced?(); end - - def references(); end - - def regexp_named_capture?(); end - - def scope(); end - - def used?(); end - - def variable(); end - MULTIPLE_LEFT_HAND_SIDE_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Assignment -end - -class RuboCop::Cop::VariableForce::AssignmentReference - def assignment?(); end - - def node(); end - - def node=(_); end -end - -class RuboCop::Cop::VariableForce::AssignmentReference - def self.[](*_); end - - def self.members(); end -end - -module RuboCop::Cop::VariableForce::Branch - CLASSES_BY_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Branch::And - include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator - def left_body?(); end - - def right_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::And -end - -class RuboCop::Cop::VariableForce::Branch::Base - def ==(other); end - - def always_run?(); end - - def branched?(); end - - def child_node(); end - - def child_node=(_); end - - def control_node(); end - - def each_ancestor(include_self: T.unsafe(nil), &block); end - - def eql?(other); end - - def exclusive_with?(other); end - - def may_jump_to_other_branch?(); end - - def may_run_incompletely?(); end - - def parent(); end - - def scope(); end - - def scope=(_); end -end - -class RuboCop::Cop::VariableForce::Branch::Base - def self.[](*_); end - - def self.classes(); end - - def self.define_predicate(name, child_index: T.unsafe(nil)); end - - def self.inherited(subclass); end - - def self.members(); end - - def self.type(); end -end - -class RuboCop::Cop::VariableForce::Branch::Case - def else_body?(); end - - def target?(); end - - def when_clause?(); end -end - -class RuboCop::Cop::VariableForce::Branch::Case -end - -class RuboCop::Cop::VariableForce::Branch::Ensure - include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler - def ensure_body?(); end - - def main_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::Ensure -end - -module RuboCop::Cop::VariableForce::Branch::ExceptionHandler - def may_jump_to_other_branch?(); end - - def may_run_incompletely?(); end -end - -module RuboCop::Cop::VariableForce::Branch::ExceptionHandler -end - -class RuboCop::Cop::VariableForce::Branch::For - def collection?(); end - - def element?(); end - - def loop_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::For -end - -class RuboCop::Cop::VariableForce::Branch::If - include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional - def falsey_body?(); end - - def truthy_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::If -end - -module RuboCop::Cop::VariableForce::Branch::LogicalOperator - def always_run?(); end -end - -module RuboCop::Cop::VariableForce::Branch::LogicalOperator -end - -class RuboCop::Cop::VariableForce::Branch::Or - include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator - def left_body?(); end - - def right_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::Or -end - -class RuboCop::Cop::VariableForce::Branch::Rescue - include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler - def else_body?(); end - - def main_body?(); end - - def rescue_clause?(); end -end - -class RuboCop::Cop::VariableForce::Branch::Rescue -end - -module RuboCop::Cop::VariableForce::Branch::SimpleConditional - def always_run?(); end - - def conditional_clause?(); end -end - -module RuboCop::Cop::VariableForce::Branch::SimpleConditional -end - -class RuboCop::Cop::VariableForce::Branch::Until - include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional - def loop_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::Until -end - -class RuboCop::Cop::VariableForce::Branch::UntilPost - include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional - def loop_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::UntilPost -end - -class RuboCop::Cop::VariableForce::Branch::While - include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional - def loop_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::While -end - -class RuboCop::Cop::VariableForce::Branch::WhilePost - include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional - def loop_body?(); end -end - -class RuboCop::Cop::VariableForce::Branch::WhilePost -end - -module RuboCop::Cop::VariableForce::Branch - def self.of(target_node, scope: T.unsafe(nil)); end -end - -module RuboCop::Cop::VariableForce::Branchable - def branch(); end - - def run_exclusively_with?(other); end -end - -module RuboCop::Cop::VariableForce::Branchable -end - -class RuboCop::Cop::VariableForce::Reference - include ::RuboCop::Cop::VariableForce::Branchable - def explicit?(); end - - def initialize(node, scope); end - - def node(); end - - def scope(); end - VARIABLE_REFERENCE_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Reference -end - -class RuboCop::Cop::VariableForce::Scope - def ==(other); end - - def body_node(); end - - def each_node(&block); end - - def include?(target_node); end - - def initialize(node); end - - def naked_top_level(); end - - def naked_top_level?(); end - - def name(); end - - def node(); end - - def variables(); end - OUTER_SCOPE_CHILD_INDICES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Scope -end - -class RuboCop::Cop::VariableForce::Variable - def argument?(); end - - def assign(node); end - - def assignments(); end - - def block_argument?(); end - - def capture_with_block!(); end - - def captured_by_block(); end - - def captured_by_block?(); end - - def declaration_node(); end - - def explicit_block_local_variable?(); end - - def in_modifier_if?(assignment); end - - def initialize(name, declaration_node, scope); end - - def keyword_argument?(); end - - def method_argument?(); end - - def name(); end - - def reference!(node); end - - def referenced?(); end - - def references(); end - - def scope(); end - - def should_be_unused?(); end - - def used?(); end - VARIABLE_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Variable -end - -class RuboCop::Cop::VariableForce::VariableReference - def assignment?(); end - - def name(); end - - def name=(_); end -end - -class RuboCop::Cop::VariableForce::VariableReference - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Cop::VariableForce::VariableTable - def accessible_variables(); end - - def assign_to_variable(name, node); end - - def current_scope(); end - - def current_scope_level(); end - - def declare_variable(name, node); end - - def find_variable(name); end - - def initialize(hook_receiver=T.unsafe(nil)); end - - def invoke_hook(hook_name, *args); end - - def pop_scope(); end - - def push_scope(scope_node); end - - def reference_variable(name, node); end - - def scope_stack(); end - - def variable_exist?(name); end -end - -class RuboCop::Cop::VariableForce::VariableTable -end - -class RuboCop::Cop::VariableForce -end - -class RuboCop::Error -end - -class RuboCop::Error -end - -class RuboCop::ErrorWithAnalyzedFileLocation - def column(); end - - def cop(); end - - def initialize(cause:, node:, cop:); end - - def line(); end -end - -class RuboCop::ErrorWithAnalyzedFileLocation -end - -module RuboCop::Ext -end - -module RuboCop::Ext::ProcessedSource - def comment_config(); end - - def disabled_line_ranges(); end -end - -module RuboCop::Ext::ProcessedSource -end - -module RuboCop::Ext -end - -module RuboCop::FileFinder - def find_file_upwards(filename, start_dir); end - - def find_files_upwards(filename, start_dir); end -end - -module RuboCop::FileFinder - def self.root_level=(level); end - - def self.root_level?(path); end -end - -module RuboCop::Formatter -end - -class RuboCop::Formatter::AutoGenConfigFormatter -end - -class RuboCop::Formatter::AutoGenConfigFormatter -end - -class RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - - def file_started(file, options); end - - def finished(inspected_files); end - - def initialize(output, options=T.unsafe(nil)); end - - def options(); end - - def output(); end - - def started(target_files); end -end - -class RuboCop::Formatter::BaseFormatter -end - -class RuboCop::Formatter::ClangStyleFormatter - ELLIPSES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::ClangStyleFormatter -end - -module RuboCop::Formatter::Colorizable - def black(string); end - - def blue(string); end - - def colorize(string, *args); end - - def cyan(string); end - - def green(string); end - - def magenta(string); end - - def rainbow(); end - - def red(string); end - - def white(string); end - - def yellow(string); end -end - -module RuboCop::Formatter::Colorizable -end - -class RuboCop::Formatter::DisabledConfigFormatter - def file_started(_file, _file_info); end - - def finished(_inspected_files); end - HEADING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::DisabledConfigFormatter - def self.config_to_allow_offenses(); end - - def self.config_to_allow_offenses=(config_to_allow_offenses); end - - def self.detected_styles(); end - - def self.detected_styles=(detected_styles); end -end - -class RuboCop::Formatter::EmacsStyleFormatter -end - -class RuboCop::Formatter::EmacsStyleFormatter -end - -class RuboCop::Formatter::FileListFormatter -end - -class RuboCop::Formatter::FileListFormatter -end - -class RuboCop::Formatter::FormatterSet - def add_formatter(formatter_type, output_path=T.unsafe(nil)); end - - def close_output_files(); end - - def file_finished(file, offenses); end - - def file_started(file, options); end - - def finished(*args); end - - def initialize(options=T.unsafe(nil)); end - - def started(*args); end - BUILTIN_FORMATTERS_FOR_KEYS = ::T.let(nil, ::T.untyped) - FORMATTER_APIS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::FormatterSet -end - -class RuboCop::Formatter::FuubarStyleFormatter - def initialize(*output); end - - def progressbar_color(); end - - def started(target_files); end - - def with_color(); end - RESET_SEQUENCE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::FuubarStyleFormatter -end - -class RuboCop::Formatter::HTMLFormatter - def files(); end - - def render_html(); end - - def summary(); end - ELLIPSES = ::T.let(nil, ::T.untyped) - TEMPLATE_PATH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::HTMLFormatter::Color - def alpha(); end - - def alpha=(_); end - - def blue(); end - - def blue=(_); end - - def fade_out(amount); end - - def green(); end - - def green=(_); end - - def red(); end - - def red=(_); end -end - -class RuboCop::Formatter::HTMLFormatter::Color - def self.[](*_); end - - def self.members(); end -end - -class RuboCop::Formatter::HTMLFormatter::ERBContext - include ::RuboCop::PathUtil - include ::RuboCop::Formatter::TextUtil - def base64_encoded_logo_image(); end - - def decorated_message(offense); end - - def escape(string); end - - def files(); end - - def highlighted_source_line(offense); end - - def hightlight_source_tag(offense); end - - def initialize(files, summary); end - - def possible_ellipses(location); end - - def source_after_highlight(offense); end - - def source_before_highlight(offense); end - - def summary(); end - LOGO_IMAGE_PATH = ::T.let(nil, ::T.untyped) - SEVERITY_COLORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::HTMLFormatter::ERBContext -end - -class RuboCop::Formatter::HTMLFormatter -end - -class RuboCop::Formatter::JSONFormatter - include ::RuboCop::PathUtil - def hash_for_file(file, offenses); end - - def hash_for_location(offense); end - - def hash_for_offense(offense); end - - def metadata_hash(); end - - def output_hash(); end -end - -class RuboCop::Formatter::JSONFormatter -end - -class RuboCop::Formatter::JUnitFormatter - def classname_attribute_value(file); end - - def finished(_inspected_files); end - - def offenses_for_cop(all_offenses, cop); end - - def relevant_for_output?(options, target_offenses); end -end - -class RuboCop::Formatter::JUnitFormatter -end - -class RuboCop::Formatter::OffenseCountFormatter - def file_finished(_file, offenses); end - - def finished(_inspected_files); end - - def offense_counts(); end - - def ordered_offense_counts(offense_counts); end - - def report_summary(offense_counts); end - - def total_offense_count(offense_counts); end -end - -class RuboCop::Formatter::OffenseCountFormatter -end - -class RuboCop::Formatter::PacmanFormatter - include ::RuboCop::Formatter::TextUtil - def cols(); end - - def file_started(_file, _options); end - - def next_step(offenses); end - - def pacdots(number); end - - def progress_line(); end - - def progress_line=(progress_line); end - - def started(target_files); end - - def step(character); end - - def update_progress_line(); end - FALLBACK_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) - GHOST = ::T.let(nil, ::T.untyped) - PACDOT = ::T.let(nil, ::T.untyped) - PACMAN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::PacmanFormatter -end - -class RuboCop::Formatter::ProgressFormatter - include ::RuboCop::Formatter::TextUtil - def report_file_as_mark(offenses); end - - def started(target_files); end - DOT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::ProgressFormatter -end - -class RuboCop::Formatter::QuietFormatter -end - -class RuboCop::Formatter::QuietFormatter -end - -class RuboCop::Formatter::SimpleTextFormatter - include ::RuboCop::Formatter::Colorizable - include ::RuboCop::PathUtil - def report_file(file, offenses); end - - def report_summary(file_count, offense_count, correction_count); end - - def started(_target_files); end - COLOR_FOR_SEVERITY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::SimpleTextFormatter::Report - include ::RuboCop::Formatter::Colorizable - include ::RuboCop::Formatter::TextUtil - def initialize(file_count, offense_count, correction_count, rainbow); end - - def summary(); end -end - -class RuboCop::Formatter::SimpleTextFormatter::Report -end - -class RuboCop::Formatter::SimpleTextFormatter -end - -class RuboCop::Formatter::TapFormatter - def started(target_files); end -end - -class RuboCop::Formatter::TapFormatter -end - -module RuboCop::Formatter::TextUtil -end - -module RuboCop::Formatter::TextUtil - def self.pluralize(number, thing, options=T.unsafe(nil)); end -end - -class RuboCop::Formatter::WorstOffendersFormatter - def finished(_inspected_files); end - - def offense_counts(); end - - def ordered_offense_counts(offense_counts); end - - def report_summary(offense_counts); end - - def total_offense_count(offense_counts); end -end - -class RuboCop::Formatter::WorstOffendersFormatter -end - -module RuboCop::Formatter -end - -class RuboCop::IncorrectCopNameError -end - -class RuboCop::IncorrectCopNameError -end - -class RuboCop::MagicComment - def any?(); end - - def encoding_specified?(); end - - def frozen_string_literal(); end - - def frozen_string_literal?(); end - - def frozen_string_literal_specified?(); end - - def initialize(comment); end - - def valid_literal_value?(); end - TOKEN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment::EditorComment -end - -class RuboCop::MagicComment::EditorComment -end - -class RuboCop::MagicComment::EmacsComment - def encoding(); end - FORMAT = ::T.let(nil, ::T.untyped) - OPERATOR = ::T.let(nil, ::T.untyped) - SEPARATOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment::EmacsComment -end - -class RuboCop::MagicComment::SimpleComment - def encoding(); end -end - -class RuboCop::MagicComment::SimpleComment -end - -class RuboCop::MagicComment::VimComment - def encoding(); end - FORMAT = ::T.let(nil, ::T.untyped) - OPERATOR = ::T.let(nil, ::T.untyped) - SEPARATOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment::VimComment -end - -class RuboCop::MagicComment - def self.parse(comment); end -end - -module RuboCop::NameSimilarity -end - -module RuboCop::NameSimilarity - def self.find_similar_name(target_name, names); end - - def self.find_similar_names(target_name, names); end -end - -RuboCop::NodePattern = RuboCop::AST::NodePattern - -class RuboCop::OptionArgumentError -end - -class RuboCop::OptionArgumentError -end - -class RuboCop::Options - def parse(command_line_args); end - DEFAULT_MAXIMUM_EXCLUSION_ITEMS = ::T.let(nil, ::T.untyped) - EXITING_OPTIONS = ::T.let(nil, ::T.untyped) - E_STDIN_NO_PATH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Options -end - -module RuboCop::OptionsHelp - FORMATTER_OPTION_LIST = ::T.let(nil, ::T.untyped) - MAX_EXCL = ::T.let(nil, ::T.untyped) - TEXT = ::T.let(nil, ::T.untyped) -end - -module RuboCop::OptionsHelp -end - -class RuboCop::OptionsValidator - def boolean_or_empty_cache?(); end - - def display_only_fail_level_offenses_with_autocorrect?(); end - - def except_syntax?(); end - - def incompatible_options(); end - - def initialize(options); end - - def only_includes_redundant_disable?(); end - - def validate_auto_correct(); end - - def validate_auto_gen_config(); end - - def validate_compatibility(); end - - def validate_cop_options(); end - - def validate_display_only_failed(); end - - def validate_exclude_limit_option(); end - - def validate_parallel(); end - - def validate_parallel_with_combo_option(); end -end - -class RuboCop::OptionsValidator - def self.validate_cop_list(names); end -end - -module RuboCop::PathUtil -end - -module RuboCop::PathUtil - def self.absolute?(path); end - - def self.chdir(dir, &block); end - - def self.hidden_dir?(path); end - - def self.hidden_file_in_not_hidden_dir?(pattern, path); end - - def self.match_path?(pattern, path); end - - def self.pwd(); end - - def self.relative_path(path, base_dir=T.unsafe(nil)); end - - def self.reset_pwd(); end - - def self.smart_path(path); end -end - -module RuboCop::Performance - CONFIG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Performance::Inject -end - -module RuboCop::Performance::Inject - def self.defaults!(); end -end - -module RuboCop::Performance::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Performance::Version -end - -module RuboCop::Performance -end - -module RuboCop::Platform -end - -module RuboCop::Platform - def self.windows?(); end -end - -RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource - -module RuboCop::RSpec - CONFIG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::RSpec::AlignLetBrace - include ::RuboCop::RSpec::Language::NodePattern - def indent_for(node); end - - def initialize(root, token); end - - def offending_tokens(); end -end - -class RuboCop::RSpec::AlignLetBrace -end - -module RuboCop::RSpec::BlankLineSeparation - include ::RuboCop::RSpec::FinalEndLocation - include ::RuboCop::Cop::RangeHelp - def autocorrect(node); end - - def last_child?(node); end - - def missing_separating_line(node); end - - def offending_loc(last_line); end -end - -module RuboCop::RSpec::BlankLineSeparation -end - -class RuboCop::RSpec::Concept - include ::RuboCop::RSpec::Language - include ::RuboCop::RSpec::Language::NodePattern - def ==(other); end - - def eql?(other); end - - def initialize(node); end - - def node(); end - - def to_node(); end -end - -class RuboCop::RSpec::Concept - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::RSpec::Corrector -end - -class RuboCop::RSpec::Corrector::MoveNode - include ::RuboCop::Cop::RangeHelp - include ::RuboCop::RSpec::FinalEndLocation - def corrector(); end - - def initialize(node, corrector, processed_source); end - - def move_after(other); end - - def move_before(other); end - - def original(); end - - def processed_source(); end -end - -class RuboCop::RSpec::Corrector::MoveNode -end - -module RuboCop::RSpec::Corrector -end - -class RuboCop::RSpec::Example - def definition(); end - - def doc_string(); end - - def extract_doc_string(node=T.unsafe(nil)); end - - def extract_implementation(node=T.unsafe(nil)); end - - def extract_metadata(node=T.unsafe(nil)); end - - def implementation(); end - - def metadata(); end -end - -class RuboCop::RSpec::Example -end - -class RuboCop::RSpec::ExampleGroup - def examples(); end - - def hooks(); end - - def scope_change?(node=T.unsafe(nil)); end - - def subjects(); end -end - -class RuboCop::RSpec::ExampleGroup -end - module RuboCop::RSpec::ExpectOffense def expect_correction(correction, loop: T.unsafe(nil)); end @@ -50196,324 +19629,6 @@ end module RuboCop::RSpec::ExpectOffense end -module RuboCop::RSpec::FactoryBot -end - -module RuboCop::RSpec::FactoryBot - def self.attribute_defining_methods(); end - - def self.reserved_methods(); end -end - -module RuboCop::RSpec::FinalEndLocation - def final_end_location(start_node); end -end - -module RuboCop::RSpec::FinalEndLocation -end - -class RuboCop::RSpec::Hook - def example?(); end - - def extract_metadata(node=T.unsafe(nil)); end - - def knowable_scope?(); end - - def metadata(); end - - def name(); end - - def scope(); end -end - -class RuboCop::RSpec::Hook -end - -module RuboCop::RSpec::Inject -end - -module RuboCop::RSpec::Inject - def self.defaults!(); end -end - -module RuboCop::RSpec::Language - ALL = ::T.let(nil, ::T.untyped) - RSPEC = ::T.let(nil, ::T.untyped) -end - -module RuboCop::RSpec::Language::NodePattern - def example?(node=T.unsafe(nil)); end - - def example_group?(node=T.unsafe(nil)); end - - def example_group_with_body?(node=T.unsafe(nil)); end - - def hook?(node=T.unsafe(nil)); end - - def let?(node=T.unsafe(nil)); end - - def subject?(node=T.unsafe(nil)); end -end - -module RuboCop::RSpec::Language::NodePattern - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::RSpec::Language -end - -module RuboCop::RSpec::Node - def recursive_literal_or_const?(); end -end - -module RuboCop::RSpec::Node -end - -module RuboCop::RSpec::TopLevelDescribe - def on_send(node); end -end - -module RuboCop::RSpec::TopLevelDescribe - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::RSpec::Variable - include ::RuboCop::RSpec::Language - def variable_definition?(node=T.unsafe(nil)); end -end - -module RuboCop::RSpec::Variable - extend ::RuboCop::AST::NodePattern::Macros -end - -module RuboCop::RSpec::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::RSpec::Version -end - -class RuboCop::RSpec::Wording - def initialize(text, ignore:, replace:); end - - def rewrite(); end -end - -class RuboCop::RSpec::Wording -end - -module RuboCop::RSpec -end - -class RuboCop::RemoteConfig - def file(); end - - def inherit_from_remote(file, path); end - - def initialize(url, base_dir); end - - def uri(); end - CACHE_LIFETIME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::RemoteConfig -end - -class RuboCop::ResultCache - def initialize(file, team, options, config_store, cache_root=T.unsafe(nil)); end - - def load(); end - - def save(offenses); end - - def valid?(); end - NON_CHANGING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ResultCache - def self.allow_symlinks_in_cache_location?(config_store); end - - def self.cache_root(config_store); end - - def self.cleanup(config_store, verbose, cache_root=T.unsafe(nil)); end - - def self.inhibit_cleanup(); end - - def self.inhibit_cleanup=(inhibit_cleanup); end - - def self.source_checksum(); end - - def self.source_checksum=(source_checksum); end -end - -class RuboCop::Runner - def aborting=(aborting); end - - def aborting?(); end - - def errors(); end - - def initialize(options, config_store); end - - def run(paths); end - - def warnings(); end - MAX_ITERATIONS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Runner::InfiniteCorrectionLoop - def initialize(path, offenses); end - - def offenses(); end -end - -class RuboCop::Runner::InfiniteCorrectionLoop -end - -class RuboCop::Runner -end - -class RuboCop::StringInterpreter - STRING_ESCAPES = ::T.let(nil, ::T.untyped) - STRING_ESCAPE_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::StringInterpreter - def self.interpret(string); end -end - -class RuboCop::TargetFinder - def all_cops_include(); end - - def configured_include?(file); end - - def debug?(); end - - def excluded_dirs(base_dir); end - - def fail_fast?(); end - - def find(args, mode); end - - def find_files(base_dir, flags); end - - def force_exclusion?(); end - - def included_file?(file); end - - def initialize(config_store, options=T.unsafe(nil)); end - - def process_explicit_path(path, mode); end - - def ruby_executable?(file); end - - def ruby_extension?(file); end - - def ruby_extensions(); end - - def ruby_file?(file); end - - def ruby_filename?(file); end - - def ruby_filenames(); end - - def ruby_interpreters(file); end - - def stdin?(); end - - def target_files_in_dir(base_dir=T.unsafe(nil)); end - - def to_inspect?(file, hidden_files, base_dir_config); end - - def toplevel_dirs(base_dir, flags); end -end - -class RuboCop::TargetFinder -end - -class RuboCop::TargetRuby - def initialize(config); end - - def rubocop_version_with_support(); end - - def source(); end - - def supported?(); end - - def version(); end - DEFAULT_VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby::BundlerLockFile -end - -class RuboCop::TargetRuby::BundlerLockFile -end - -class RuboCop::TargetRuby::Default -end - -class RuboCop::TargetRuby::Default -end - -class RuboCop::TargetRuby::RuboCopConfig -end - -class RuboCop::TargetRuby::RuboCopConfig -end - -class RuboCop::TargetRuby::RubyVersionFile - FILENAME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby::RubyVersionFile -end - -class RuboCop::TargetRuby::Source - def initialize(config); end - - def name(); end - - def version(); end -end - -class RuboCop::TargetRuby::Source -end - -class RuboCop::TargetRuby - def self.supported_versions(); end -end - -RuboCop::Token = RuboCop::AST::Token - -class RuboCop::ValidationError -end - -class RuboCop::ValidationError -end - -module RuboCop::Version - MSG = ::T.let(nil, ::T.untyped) - STRING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Version - def self.version(debug=T.unsafe(nil)); end -end - -class RuboCop::Warning -end - -class RuboCop::Warning -end - -module RuboCop::YAMLDuplicationChecker -end - -module RuboCop::YAMLDuplicationChecker - def self.check(yaml_string, filename, &on_duplicated); end -end - class RubyLex include ::RubyToken def Fail(err=T.unsafe(nil), *rest); end @@ -52212,7 +21327,6 @@ module Stdenv end class String - include ::JSON::Ext::Generator::GeneratorMethods::String include ::String::Compat def acts_like_string?(); end @@ -53837,765 +22951,19 @@ end module Term end -class Thor - include ::Thor::Base - include ::Thor::Invocation - include ::Thor::Shell - def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end - Correctable = ::T.let(nil, ::T.untyped) - HELP_MAPPINGS = ::T.let(nil, ::T.untyped) - TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped) - THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module Thor::Actions - def _cleanup_options_and_set(options, key); end - - def _shared_configuration(); end - - def action(instance); end - - def add_file(destination, *args, &block); end - - def add_link(destination, *args); end - - def append_file(path, *args, &block); end - - def append_to_file(path, *args, &block); end - - def apply(path, config=T.unsafe(nil)); end - - def behavior(); end - - def behavior=(behavior); end - - def chmod(path, mode, config=T.unsafe(nil)); end - - def comment_lines(path, flag, *args); end - - def copy_file(source, *args, &block); end - - def create_file(destination, *args, &block); end - - def create_link(destination, *args); end - - def destination_root(); end - - def destination_root=(root); end - - def directory(source, *args, &block); end - - def empty_directory(destination, config=T.unsafe(nil)); end - - def find_in_source_paths(file); end - - def get(source, *args, &block); end - - def gsub_file(path, flag, *args, &block); end - - def in_root(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def inject_into_class(path, klass, *args, &block); end - - def inject_into_file(destination, *args, &block); end - - def inject_into_module(path, module_name, *args, &block); end - - def insert_into_file(destination, *args, &block); end - - def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def link_file(source, *args); end - - def prepend_file(path, *args, &block); end - - def prepend_to_file(path, *args, &block); end - - def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end - - def remove_dir(path, config=T.unsafe(nil)); end - - def remove_file(path, config=T.unsafe(nil)); end - - def run(command, config=T.unsafe(nil)); end - - def run_ruby_script(command, config=T.unsafe(nil)); end - - def source_paths(); end - - def template(source, *args, &block); end - - def thor(command, *args); end - - def uncomment_lines(path, flag, *args); end - WARNINGS = ::T.let(nil, ::T.untyped) -end - -module Thor::Actions - def self.included(base); end -end - -class Thor::AmbiguousCommandError -end - -class Thor::AmbiguousCommandError -end - -Thor::AmbiguousTaskError = Thor::AmbiguousCommandError - -class Thor::Argument - def banner(); end - - def default(); end - - def default_banner(); end - - def description(); end - - def enum(); end - - def human_name(); end - - def initialize(name, options=T.unsafe(nil)); end - - def name(); end - - def required(); end - - def required?(); end - - def show_default?(); end - - def type(); end - - def usage(); end - - def valid_type?(type); end - - def validate!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Thor::Argument -end - -class Thor::Arguments - def initialize(arguments=T.unsafe(nil)); end - - def parse(args); end - - def remaining(); end - NUMERIC = ::T.let(nil, ::T.untyped) -end - -class Thor::Arguments - def self.parse(*args); end - - def self.split(args); end -end - -module Thor::Base - def args(); end - - def args=(args); end - - def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def parent_options(); end - - def parent_options=(parent_options); end -end - -module Thor::Base - def self.included(base); end - - def self.register_klass_file(klass); end - - def self.shell(); end - - def self.shell=(shell); end - - def self.subclass_files(); end - - def self.subclasses(); end -end - -class Thor::Command - def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def handle_argument_error?(instance, error, caller); end - - def handle_no_method_error?(instance, error, caller); end - - def hidden?(); end - - def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end - - def local_method?(instance, name); end - - def not_debugging?(instance); end - - def private_method?(instance); end - - def public_method?(instance); end - - def required_arguments_for(klass, usage); end - - def required_options(); end - - def run(instance, args=T.unsafe(nil)); end - - def sans_backtrace(backtrace, caller); end - FILE_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Thor::Command -end - -module Thor::CoreExt -end - -class Thor::CoreExt::HashWithIndifferentAccess - def [](key); end - - def []=(key, value); end - - def convert_key(key); end - - def delete(key); end - - def fetch(key, *args); end - - def initialize(hash=T.unsafe(nil)); end - - def key?(key); end - - def merge(other); end - - def merge!(other); end - - def method_missing(method, *args); end - - def replace(other_hash); end - - def reverse_merge(other); end - - def reverse_merge!(other_hash); end - - def values_at(*indices); end -end - -class Thor::CoreExt::HashWithIndifferentAccess -end - -module Thor::CoreExt -end - -class Thor::DynamicCommand - def initialize(name, options=T.unsafe(nil)); end -end - -class Thor::DynamicCommand -end - -Thor::DynamicTask = Thor::DynamicCommand - -class Thor::Error -end - -class Thor::Error -end - -class Thor::Group - include ::Thor::Base - include ::Thor::Invocation - include ::Thor::Shell - def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end -end - class Thor::Group def self.banner(); end - def self.desc(description=T.unsafe(nil)); end - - def self.get_options_from_invocations(group_options, base_options); end - - def self.handle_argument_error(command, error, _args, arity); end - - def self.help(shell); end - - def self.invocation_blocks(); end - - def self.invocations(); end - - def self.invoke(*names, &block); end - - def self.invoke_from_option(*names, &block); end - - def self.printable_commands(*_); end - - def self.printable_tasks(*_); end - - def self.remove_invocation(*names); end - def self.self_command(); end def self.self_task(); end end -class Thor::HiddenCommand -end - -class Thor::HiddenCommand -end - -Thor::HiddenTask = Thor::HiddenCommand - -module Thor::Invocation - def _parse_initialization_options(args, opts, config); end - - def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end - - def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end - - def _shared_configuration(); end - - def current_command_chain(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def invoke(name=T.unsafe(nil), *args); end - - def invoke_all(); end - - def invoke_command(command, *args); end - - def invoke_task(command, *args); end - - def invoke_with_padding(*args); end -end - -module Thor::Invocation - def self.included(base); end -end - -class Thor::InvocationError -end - -class Thor::InvocationError -end - -module Thor::LineEditor -end - -class Thor::LineEditor::Basic - def initialize(prompt, options); end - - def options(); end - - def prompt(); end - - def readline(); end -end - -class Thor::LineEditor::Basic - def self.available?(); end -end - -class Thor::LineEditor::Readline -end - -class Thor::LineEditor::Readline::PathCompletion - def initialize(text); end - - def matches(); end -end - -class Thor::LineEditor::Readline::PathCompletion -end - -class Thor::LineEditor::Readline -end - -module Thor::LineEditor - def self.best_available(); end - - def self.readline(prompt, options=T.unsafe(nil)); end -end - -class Thor::MalformattedArgumentError -end - -class Thor::MalformattedArgumentError -end - -class Thor::NestedContext - def enter(); end - - def entered?(); end -end - -class Thor::NestedContext -end - -class Thor::Option - def aliases(); end - - def array?(); end - - def boolean?(); end - - def dasherize(str); end - - def dasherized?(); end - - def group(); end - - def hash?(); end - - def hide(); end - - def lazy_default(); end - - def numeric?(); end - - def repeatable(); end - - def string?(); end - - def switch_name(); end - - def undasherize(str); end - - def usage(padding=T.unsafe(nil)); end - - def validate_default_type!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Thor::Option - def self.parse(key, value); end -end - -class Thor::Options - def assign_result!(option, result); end - - def check_unknown!(); end - - def current_is_switch?(); end - - def current_is_switch_formatted?(); end - - def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end - - def normalize_switch(arg); end - - def parse_boolean(switch); end - - def parse_peek(switch, option); end - - def parsing_options?(); end - - def switch?(arg); end - - def switch_option(arg); end - EQ_RE = ::T.let(nil, ::T.untyped) - LONG_RE = ::T.let(nil, ::T.untyped) - OPTS_END = ::T.let(nil, ::T.untyped) - SHORT_NUM = ::T.let(nil, ::T.untyped) - SHORT_RE = ::T.let(nil, ::T.untyped) - SHORT_SQ_RE = ::T.let(nil, ::T.untyped) -end - -class Thor::Options - def self.to_switches(options); end -end - -class Thor::RequiredArgumentMissingError -end - -class Thor::RequiredArgumentMissingError -end - -module Thor::Sandbox -end - -module Thor::Sandbox -end - -module Thor::Shell - def _shared_configuration(); end - - def ask(*args, &block); end - - def error(*args, &block); end - - def file_collision(*args, &block); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def no?(*args, &block); end - - def print_in_columns(*args, &block); end - - def print_table(*args, &block); end - - def print_wrapped(*args, &block); end - - def say(*args, &block); end - - def say_status(*args, &block); end - - def set_color(*args, &block); end - - def shell(); end - - def shell=(shell); end - - def terminal_width(*args, &block); end - - def with_padding(); end - - def yes?(*args, &block); end - SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Basic - def answer_match(possibilities, answer, case_insensitive); end - - def as_unicode(); end - - def ask(statement, *args); end - - def ask_filtered(statement, color, options); end - - def ask_simply(statement, color, options); end - - def base(); end - - def base=(base); end - - def can_display_colors?(); end - - def dynamic_width(); end - - def dynamic_width_stty(); end - - def dynamic_width_tput(); end - - def error(statement); end - - def file_collision(destination); end - - def file_collision_help(); end - - def git_merge_tool(); end - - def indent(count=T.unsafe(nil)); end - - def is?(value); end - - def lookup_color(color); end - - def merge(destination, content); end - - def merge_tool(); end - - def mute(); end - - def mute?(); end - - def no?(statement, color=T.unsafe(nil)); end - - def padding(); end - - def padding=(value); end - - def prepare_message(message, *color); end - - def print_in_columns(array); end - - def print_table(array, options=T.unsafe(nil)); end - - def print_wrapped(message, options=T.unsafe(nil)); end - - def quiet?(); end - - def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_status(status, message, log_status=T.unsafe(nil)); end - - def set_color(string, *_); end - - def show_diff(destination, content); end - - def stderr(); end - - def stdout(); end - - def terminal_width(); end - - def truncate(string, width); end - - def unix?(); end - - def yes?(statement, color=T.unsafe(nil)); end - DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Basic -end - -class Thor::Shell::Color - def are_colors_disabled?(); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Color -end - -module Thor::Shell -end - -Thor::Task = Thor::Command - -class Thor::UndefinedCommandError - def all_commands(); end - - def command(); end - - def initialize(command, all_commands, namespace); end -end - -class Thor::UndefinedCommandError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Thor::UndefinedCommandError::SpellChecker -end - -class Thor::UndefinedCommandError -end - -Thor::UndefinedTaskError = Thor::UndefinedCommandError - -class Thor::UnknownArgumentError - def initialize(switches, unknown); end - - def switches(); end - - def unknown(); end -end - -class Thor::UnknownArgumentError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Thor::UnknownArgumentError::SpellChecker -end - -class Thor::UnknownArgumentError -end - -module Thor::Util -end - -module Thor::Util - def self.camel_case(str); end - - def self.escape_globs(path); end - - def self.escape_html(string); end - - def self.find_by_namespace(namespace); end - - def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.globs_for(path); end - - def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end - - def self.namespace_from_thor_class(constant); end - - def self.namespaces_in_content(contents, file=T.unsafe(nil)); end - - def self.ruby_command(); end - - def self.snake_case(str); end - - def self.thor_classes_in(klass); end - - def self.thor_root(); end - - def self.thor_root_glob(); end - - def self.user_home(); end -end - class Thor def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - def self.check_unknown_options!(options=T.unsafe(nil)); end - - def self.command_help(shell, command_name); end - - def self.default_command(meth=T.unsafe(nil)); end - - def self.default_task(meth=T.unsafe(nil)); end - - def self.deprecation_warning(message); end - - def self.desc(usage, description, options=T.unsafe(nil)); end - def self.disable_required_check(); end - def self.disable_required_check!(*command_names); end - - def self.disable_required_check?(command); end - def self.dispatch(meth, given_args, given_opts, config); end def self.dynamic_command_class(); end @@ -54604,57 +22972,19 @@ class Thor def self.find_task_possibilities(meth); end - def self.help(shell, subcommand=T.unsafe(nil)); end - - def self.long_desc(long_description, options=T.unsafe(nil)); end - - def self.map(mappings=T.unsafe(nil), **kw); end - - def self.method_option(name, options=T.unsafe(nil)); end - - def self.method_options(options=T.unsafe(nil)); end - def self.normalize_command_name(meth); end def self.normalize_task_name(meth); end - def self.option(name, options=T.unsafe(nil)); end - - def self.options(options=T.unsafe(nil)); end - - def self.package_name(name, _=T.unsafe(nil)); end - - def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end - def self.retrieve_command_name(args); end def self.retrieve_task_name(args); end def self.stop_on_unknown_option(); end - def self.stop_on_unknown_option!(*command_names); end - - def self.stop_on_unknown_option?(command); end - - def self.subcommand(subcommand, subcommand_class); end - - def self.subcommand_classes(); end - def self.subcommand_help(cmd); end - def self.subcommands(); end - - def self.subtask(subcommand, subcommand_class); end - def self.subtask_help(cmd); end - - def self.subtasks(); end - - def self.task_help(shell, command_name); end end module ThreadSafe @@ -56417,25 +24747,6 @@ module Tty def self.yellow(); end end -module UNF - VERSION = ::T.let(nil, ::T.untyped) -end - -class UNF::Normalizer - include ::Singleton - def normalize(_, _1); end -end - -class UNF::Normalizer - extend ::Singleton::SingletonClassMethods - def self.instance(); end - - def self.normalize(string, form); end -end - -module UNF -end - module URI include ::URI::RFC2396_REGEXP end @@ -56558,28 +24869,6 @@ class UnboundMethod include ::MethodSource::MethodExtensions end -module Unicode -end - -module Unicode::DisplayWidth - DATA_DIRECTORY = ::T.let(nil, ::T.untyped) - DEPTHS = ::T.let(nil, ::T.untyped) - INDEX = ::T.let(nil, ::T.untyped) - INDEX_FILENAME = ::T.let(nil, ::T.untyped) - NO_STRING_EXT = ::T.let(nil, ::T.untyped) - UNICODE_VERSION = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module Unicode::DisplayWidth - def self.emoji_extra_width_of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), _=T.unsafe(nil)); end - - def self.of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), options=T.unsafe(nil)); end -end - -module Unicode -end - module UnicodeNormalize end @@ -56606,211 +24895,8 @@ class WeakRef def initialize(orig); end end -class WebRobots - def allowed?(url); end - - def crawl_delay(url); end - - def create_cache(); end - - def disallowed?(url); end - - def error(url); end - - def error!(url); end - - def flush_cache(); end - - def initialize(user_agent, options=T.unsafe(nil)); end - - def option(url, token); end - - def options(url); end - - def reset(url); end - - def sitemaps(url); end - - def user_agent(); end -end - -class WebRobots::Error -end - -class WebRobots::Error -end - -class WebRobots::ParseError - def initialize(message, site); end - - def site(); end -end - -class WebRobots::ParseError -end - -class WebRobots::RobotsTxt - def allow?(request_uri, user_agent=T.unsafe(nil)); end - - def crawl_delay(user_agent=T.unsafe(nil)); end - - def error(); end - - def error!(); end - - def error=(error); end - - def initialize(site, records, options=T.unsafe(nil)); end - - def options(user_agent=T.unsafe(nil)); end - - def site(); end - - def sitemaps(); end - - def timestamp(); end - DISALLOW_ALL = ::T.let(nil, ::T.untyped) -end - -class WebRobots::RobotsTxt::AccessControlLine - def match?(request_uri); end -end - -class WebRobots::RobotsTxt::AccessControlLine -end - -class WebRobots::RobotsTxt::AgentLine - def pattern(); end -end - -class WebRobots::RobotsTxt::AgentLine -end - -class WebRobots::RobotsTxt::AllowLine - def allow?(); end -end - -class WebRobots::RobotsTxt::AllowLine -end - -class WebRobots::RobotsTxt::CrawlDelayLine - def delay(); end -end - -class WebRobots::RobotsTxt::CrawlDelayLine -end - -class WebRobots::RobotsTxt::DisallowLine - def allow?(); end -end - -class WebRobots::RobotsTxt::DisallowLine -end - -class WebRobots::RobotsTxt::ExtentionLine -end - -class WebRobots::RobotsTxt::ExtentionLine -end - -class WebRobots::RobotsTxt::Line - def compile(); end - - def initialize(token, value); end - - def token(); end - - def value(); end -end - -class WebRobots::RobotsTxt::Line -end - class WebRobots::RobotsTxt::Parser - def _reduce_1(val, _values, result); end - - def _reduce_17(val, _values, result); end - - def _reduce_18(val, _values, result); end - - def _reduce_19(val, _values, result); end - - def _reduce_2(val, _values, result); end - - def _reduce_20(val, _values, result); end - - def _reduce_21(val, _values, result); end - - def _reduce_24(val, _values, result); end - - def _reduce_25(val, _values, result); end - - def _reduce_26(val, _values, result); end - - def _reduce_28(val, _values, result); end - - def _reduce_31(val, _values, result); end - - def _reduce_32(val, _values, result); end - - def _reduce_38(val, _values, result); end - - def _reduce_39(val, _values, result); end - - def _reduce_40(val, _values, result); end - - def _reduce_41(val, _values, result); end - - def _reduce_none(val, _values, result); end - - def initialize(target, crawl_delay_handler=T.unsafe(nil)); end - - def on_error(token_id, value, stack); end - - def parse(input, site); end - - def parse!(input, site); end - - def parse_error(message); end - KNOWN_TOKENS = ::T.let(nil, ::T.untyped) - RE_KNOWN_TOKENS = ::T.let(nil, ::T.untyped) - Racc_arg = ::T.let(nil, ::T.untyped) Racc_debug_parser = ::T.let(nil, ::T.untyped) - Racc_token_to_s_table = ::T.let(nil, ::T.untyped) -end - -class WebRobots::RobotsTxt::Parser -end - -class WebRobots::RobotsTxt::Record - def allow?(request_uri); end - - def default?(); end - - def delay(); end - - def initialize(agentlines, rulelines); end - - def match?(user_agent); end - - def options(); end -end - -class WebRobots::RobotsTxt::Record -end - -class WebRobots::RobotsTxt - def self.unfetchable(site, reason, target=T.unsafe(nil)); end -end - -class WebRobots -end - -module Webrobots - VERSION = ::T.let(nil, ::T.untyped) -end - -module Webrobots end module Zeitwerk diff --git a/Library/Homebrew/sorbet/rbi/todo.rbi b/Library/Homebrew/sorbet/rbi/todo.rbi index f59a23049e..cc825a11b2 100644 --- a/Library/Homebrew/sorbet/rbi/todo.rbi +++ b/Library/Homebrew/sorbet/rbi/todo.rbi @@ -1,81 +1,20 @@ # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi todo -# typed: ignore -module ::ActiveSupport::Inflector; end -module ::Coveralls::Output; end -module ::Coveralls::SimpleCov::Formatter; end -module ::I18n; end -module ::ParallelTests; end -module ::RSpec; end -module ::RSpec::Core::Formatters::ProgressFormatter; end -module ::RSpec::Matchers; end -module ::RSpec::Matchers::DSL; end -module ::RSpec::Support::ObjectFormatter; end -module ::SimpleCov; end -module ::SimpleCov::Formatter::HTMLFormatter; end -module ::SimpleCov::Formatter::MultiFormatter; end -module ::Tap; end -module ::Tap::TAP_DIRECTORY; end -module ::User; end -module Cask::Artifact::AbstractUninstall::User; end -module Cask::Artifact::Pkg::Plist::Emit; end -module Cask::Artifact::Pkg::User; end -module Cask::Cask; end -module Cask::CaskLoader::FromTapLoader::Tap; end -module Cask::CaskLoader::FromTapPathLoader::Tap; end -module Cask::CaskLoader::Tap; end -module Cask::Caskroom::User; end -module Cask::Cmd::Doctor::Tap; end -module Cask::Cmd::Style::Tap; end -module Cask::Cmd::Tap; end -module Cask::DSL::ConflictsWith; end -module Cask::DSL::DependsOn; end -module Cask::Staged::User; end -module Cask::Utils::User; end -module Commands::Tap; end -module CurlDownloadStrategy::Mechanize::HTTP::ContentDispositionParser; end +# typed: strong module DependencyCollector::Compat; end -module DependencyCollector::Dependencies; end -module DependencyCollector::Requirements; end -module FormulaCellarChecks::Plist; end -module Formulary::Tap; end -module Formulary::TapLoader::Tap; end -module Homebrew::Diagnostic::Checks::Tap; end module Homebrew::Error; end -module Homebrew::Pry; end -module Homebrew::Search::Tap; end -module Homebrew::SimpleCov; end -module Homebrew::Tap; end -module Homebrew::Tap::TAP_DIRECTORY; end -module Keg::MachO::MachOError; end -module Keg::MachO::Tools; end -module Kernel::Tap; end module MacOS::CLT; end module MacOS::CLT::PKG_PATH; end module MacOS::Version; end +module MacOS::Version::SYMBOLS; end module MacOS::X11; end module MacOS::XQuartz; end module MacOS::Xcode; end -module MachOShim::MachO; end -module MachOShim::MachO::NotAMachOError; end -module MachOShim::MachO::Utils; end -module NoSeedProgressFormatter::RSpec::Core::Formatters; end module OS::Mac::Version::NULL; end -module Reporter::Tap; end -module RuboCop::AST::HashNode; end -module RuboCop::AST::Node::Parser::Source::Map::Heredoc; end -module RuboCop::AST::SendNode; end -module RuboCop::AST::StrNode; end -module RuboCop::Cask::AST::CaskBlock::Parser::Source::Comment; end -module RuboCop::Cop::Cask::StanzaGrouping::RangeHelp; end -module RuboCop::Cop::Cop; end -module RuboCop::Cop::FormulaCop::Parser::CurrentRuby; end -module RuboCop::Cop::FormulaCop::RangeHelp; end -module RuboCop::RSpec::ExpectOffense; end -module SystemCommand::Result::Plist; end -module Tab::Tap; end -module TapDependency::Tap; end -module TapFormulaAmbiguityError::Tap; end +module T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions; end +module T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions; end +module T::Private::Methods::MethodHooks; end +module T::Private::Methods::SingletonMethodHooks; end module Test::Unit::AssertionFailedError; end module Test::Unit::Assertions; end diff --git a/Library/Homebrew/sorbet/tapioca/require.rb b/Library/Homebrew/sorbet/tapioca/require.rb new file mode 100644 index 0000000000..ac84d1d3f0 --- /dev/null +++ b/Library/Homebrew/sorbet/tapioca/require.rb @@ -0,0 +1,4 @@ +# frozen_string_literal: true +# typed: false + +# Add your extra requires here