From b2dc84223852088a22a2575ff39963b146b74545 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Tue, 30 Jan 2024 22:48:36 -0800 Subject: [PATCH 01/15] wip --- Library/Homebrew/Gemfile | 1 + Library/Homebrew/Gemfile.lock | 1 + Library/Homebrew/dev-cmd/typecheck.rb | 1 + .../rubocops/cask/mixin/cask_help.rbi | 1 + .../Homebrew/sorbet/rbi/dsl/.gitattributes | 1 + .../rbi/dsl/rubo_cop/cop/cask/variables.rbi | 10 +++ .../cop/formula_audit/components_order.rbi | 10 +++ .../cop/formula_audit/dependency_order.rbi | 34 ++++++++ .../formula_audit/deprecate_disable_date.rbi | 10 +++ .../deprecate_disable_reason.rbi | 10 +++ .../generate_completions_dsl.rbi | 13 +++ .../rubo_cop/cop/formula_audit/git_urls.rbi | 10 +++ .../rubo_cop/cop/formula_audit/licenses.rbi | 10 +++ .../cop/formula_audit/miscellaneous.rbi | 22 +++++ .../cop/formula_audit/option_declarations.rbi | 10 +++ .../rubo_cop/cop/formula_audit/patches.rbi | 10 +++ .../dsl/rubo_cop/cop/formula_audit/test.rbi | 10 +++ .../dsl/rubo_cop/cop/formula_audit/text.rbi | 10 +++ .../cop/formula_audit_strict/git_urls.rbi | 10 +++ .../cop/formula_audit_strict/text.rbi | 13 +++ .../rbi/dsl/rubo_cop/cop/formula_cop.rbi | 19 +++++ .../rbi/dsl/rubo_cop/cop/homebrew/blank.rbi | 10 +++ .../rubo_cop/cop/homebrew/compact_blank.rbi | 13 +++ .../cop/homebrew/move_to_extend_os.rbi | 10 +++ .../rubo_cop/cop/homebrew/negate_include.rbi | 10 +++ .../dsl/rubo_cop/cop/homebrew/presence.rbi | 13 +++ .../rbi/dsl/rubo_cop/cop/homebrew/present.rbi | 10 +++ .../homebrew/safe_navigation_with_blank.rbi | 10 +++ .../cop/on_system_conditionals_helper.rbi | 28 ++++++ .../sorbet/rbi/hidden-definitions/hidden.rbi | 85 ++++++++++++++----- .../sorbet/tapioca/compilers/rubocop.rb | 81 ++++++++++++++++++ 31 files changed, 465 insertions(+), 21 deletions(-) create mode 100644 Library/Homebrew/sorbet/rbi/dsl/.gitattributes create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi create mode 100644 Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb diff --git a/Library/Homebrew/Gemfile b/Library/Homebrew/Gemfile index 7ea91c4017..01d1fb91c4 100644 --- a/Library/Homebrew/Gemfile +++ b/Library/Homebrew/Gemfile @@ -60,6 +60,7 @@ group :tests, optional: true do gem "simplecov-cobertura", require: false end group :typecheck, optional: true do + gem "method_source", require: false gem "parlour", require: false gem "sorbet-static-and-runtime", require: false gem "spoom", require: false diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 4494dd5ec8..c879651945 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -176,6 +176,7 @@ DEPENDENCIES bootsnap byebug json_schemer + method_source minitest parallel_tests parlour diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb index a105d4ac71..7378baf7c0 100644 --- a/Library/Homebrew/dev-cmd/typecheck.rb +++ b/Library/Homebrew/dev-cmd/typecheck.rb @@ -45,6 +45,7 @@ module Homebrew HOMEBREW_LIBRARY_PATH.cd do if update + safe_system "bundle", "exec", "tapioca", "dsl" excluded_gems = [ "json", # RBI file is already provided by Sorbet ] diff --git a/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi index c3fe624f8e..366d9ac46f 100644 --- a/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi +++ b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi @@ -2,4 +2,5 @@ module RuboCop::Cop::Cask::CaskHelp requires_ancestor { RuboCop::Cop::Base } + # requires_ancestor { RuboCop::Cop::CommentsHelp } end diff --git a/Library/Homebrew/sorbet/rbi/dsl/.gitattributes b/Library/Homebrew/sorbet/rbi/dsl/.gitattributes new file mode 100644 index 0000000000..d9bb82a4de --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/.gitattributes @@ -0,0 +1 @@ +**/*.rbi linguist-generated=true diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi new file mode 100644 index 0000000000..03b3da5b04 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::Variables`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::Variables`. + +class RuboCop::Cop::Cask::Variables + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def variable_assignment(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi new file mode 100644 index 0000000000..470b6df1b8 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ComponentsOrder`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ComponentsOrder`. + +class RuboCop::Cop::FormulaAudit::ComponentsOrder + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def depends_on_node?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi new file mode 100644 index 0000000000..bbb86d9b5b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi @@ -0,0 +1,34 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DependencyOrder`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DependencyOrder`. + +class RuboCop::Cop::FormulaAudit::DependencyOrder + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def build_with_dependency_node(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def buildtime_dependency?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def dependency_name_node(*node, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def depends_on_node?(*node, **kwargs, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def negate_normal_dependency?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def optional_dependency?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def recommended_dependency?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def test_dependency?(*node, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def uses_from_macos_node?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi new file mode 100644 index 0000000000..18b209a2fd --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DeprecateDisableDate`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableDate`. + +class RuboCop::Cop::FormulaAudit::DeprecateDisableDate + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def date(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi new file mode 100644 index 0000000000..f3473654f4 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DeprecateDisableReason`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableReason`. + +class RuboCop::Cop::FormulaAudit::DeprecateDisableReason + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def reason(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi new file mode 100644 index 0000000000..152d2b3456 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi @@ -0,0 +1,13 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL`. + +class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def correctable_shell_completion_node(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def shell_completion_node(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi new file mode 100644 index 0000000000..5b0dd74ad9 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::GitUrls`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::GitUrls`. + +class RuboCop::Cop::FormulaAudit::GitUrls + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def url_has_revision?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi new file mode 100644 index 0000000000..5eab79ac26 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Licenses`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Licenses`. + +class RuboCop::Cop::FormulaAudit::Licenses + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def license_exception?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi new file mode 100644 index 0000000000..aa46db2eb2 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi @@ -0,0 +1,22 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Miscellaneous`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Miscellaneous`. + +class RuboCop::Cop::FormulaAudit::Miscellaneous + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def conditional_dependencies(*node, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def destructure_hash(*node, **kwargs, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def formula_path_strings(*node, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def hash_dep(*node, **kwargs, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def languageNodeModule?(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi new file mode 100644 index 0000000000..eb94588521 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::OptionDeclarations`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::OptionDeclarations`. + +class RuboCop::Cop::FormulaAudit::OptionDeclarations + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def depends_on_build_with(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi new file mode 100644 index 0000000000..81db7b48e2 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Patches`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Patches`. + +class RuboCop::Cop::FormulaAudit::Patches + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def patch_data?(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi new file mode 100644 index 0000000000..0d9fcb3e5a --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Test`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Test`. + +class RuboCop::Cop::FormulaAudit::Test + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def test_calls(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi new file mode 100644 index 0000000000..e45270488b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Text`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Text`. + +class RuboCop::Cop::FormulaAudit::Text + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def prefix_path(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi new file mode 100644 index 0000000000..db8f61d930 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::GitUrls`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::GitUrls`. + +class RuboCop::Cop::FormulaAuditStrict::GitUrls + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def url_has_tag?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi new file mode 100644 index 0000000000..1444a5206e --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi @@ -0,0 +1,13 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::Text`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::Text`. + +class RuboCop::Cop::FormulaAuditStrict::Text + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def interpolated_share_path_starts_with(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def share_path_starts_with(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi new file mode 100644 index 0000000000..aaea44eacc --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi @@ -0,0 +1,19 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaCop`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaCop`. + +class RuboCop::Cop::FormulaCop + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def dependency_name_hash_match?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def dependency_type_hash_match?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def required_dependency?(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } + def required_dependency_name?(*node, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi new file mode 100644 index 0000000000..3973833606 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Blank`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Blank`. + +class RuboCop::Cop::Homebrew::Blank + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def nil_or_empty?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi new file mode 100644 index 0000000000..c3063b7941 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi @@ -0,0 +1,13 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::CompactBlank`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::CompactBlank`. + +class RuboCop::Cop::Homebrew::CompactBlank + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def reject_with_block?(*node, **kwargs, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def reject_with_block_pass?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi new file mode 100644 index 0000000000..fa23bca2c3 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::MoveToExtendOS`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::MoveToExtendOS`. + +class RuboCop::Cop::Homebrew::MoveToExtendOS + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def os_check?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi new file mode 100644 index 0000000000..d254d9f06c --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::NegateInclude`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::NegateInclude`. + +class RuboCop::Cop::Homebrew::NegateInclude + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def negate_include_call?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi new file mode 100644 index 0000000000..45fbcf61f0 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi @@ -0,0 +1,13 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Presence`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Presence`. + +class RuboCop::Cop::Homebrew::Presence + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def redundant_negative_receiver_and_other(*node, **kwargs, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def redundant_receiver_and_other(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi new file mode 100644 index 0000000000..0a02fdf79e --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Present`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Present`. + +class RuboCop::Cop::Homebrew::Present + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def exists_and_not_empty?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi new file mode 100644 index 0000000000..22567eb453 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi @@ -0,0 +1,10 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::SafeNavigationWithBlank`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::SafeNavigationWithBlank`. + +class RuboCop::Cop::Homebrew::SafeNavigationWithBlank + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def safe_navigation_blank_in_conditional?(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi new file mode 100644 index 0000000000..bd34168242 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi @@ -0,0 +1,28 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::OnSystemConditionalsHelper`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::OnSystemConditionalsHelper`. + +module RuboCop::Cop::OnSystemConditionalsHelper + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def hardware_cpu_search(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def if_arch_node_search(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def if_base_os_node_search(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def if_macos_version_node_search(*node, &block); end + + sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } + def macos_version_comparison_search(*node, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def on_macos_version_method_call(*node, **kwargs, &block); end + + sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } + def on_system_method_call(*node, **kwargs, &block); end +end diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi index e0bd137b93..ca3d0b349b 100644 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi @@ -5035,6 +5035,14 @@ end module Homebrew extend ::T::Private::Methods::MethodHooks extend ::T::Private::Methods::SingletonMethodHooks + extend ::FileUtils::StreamUtils_ +end + +module HostEnvironmentSimulatorHelper + def in_its_own_process_with(*files); end +end + +module HostEnvironmentSimulatorHelper end class IO @@ -8431,26 +8439,6 @@ module RuboCop::AST::CollectionNode def to_sentence(*args, **arg, &block); end end -class RuboCop::AST::Node - def arch_variable?(param0=T.unsafe(nil)); end - - def begin_block?(param0=T.unsafe(nil)); end - - def block_args(param0=T.unsafe(nil)); end - - def block_body(param0=T.unsafe(nil)); end - - def cask_block?(param0=T.unsafe(nil)); end - - def key_node(param0=T.unsafe(nil)); end - - def method_node(param0=T.unsafe(nil)); end - - def on_system_block?(param0=T.unsafe(nil)); end - - def val_node(param0=T.unsafe(nil)); end -end - module RuboCop::AST::NodePattern::Sets SET_ARM_INTEL = ::T.let(nil, ::T.untyped) SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped) @@ -8637,7 +8625,12 @@ end class RuboCop::Cop::Cask::Variables include ::RuboCop::Cop::CommentsHelp - def variable_assignment(param0); end +end + +class RuboCop::Cop::Cop + def highlights(); end + + def messages(); end end class RuboCop::Cop::FormulaAudit::ComponentsOrder @@ -8791,6 +8784,56 @@ module RuboCop::Cop::OnSystemConditionalsHelper def on_system_method_call(param0=T.unsafe(nil)); end end +module RuboCop::RSpec::ExpectOffense + def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end + + def expect_no_corrections(); end + + def expect_no_offenses(source, file=T.unsafe(nil)); end + + def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end + + def format_offense(source, **replacements); end + + def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end + + def parse_processed_source(source, file=T.unsafe(nil)); end + + def set_formatter_options(); end +end + +class RuboCop::RSpec::ExpectOffense::AnnotatedSource + def ==(other); end + + def annotations(); end + + def initialize(lines, annotations); end + + def lines(); end + + def match_annotations?(other); end + + def plain_source(); end + + def with_offense_annotations(offenses); end + ABBREV = ::T.let(nil, ::T.untyped) + ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped) +end + +class RuboCop::RSpec::ExpectOffense::AnnotatedSource + def self.parse(annotated_source); end +end + +module RuboCop::RSpec::ExpectOffense +end + +class RuboCop::RSpec::ParallelFormatter + def dump_pending(*arg); end +end + +class RuboCop::RSpec::ParallelFormatter +end + class RubyLex def check_code_block(code, tokens=T.unsafe(nil)); end diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb new file mode 100644 index 0000000000..0135bd6e5f --- /dev/null +++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb @@ -0,0 +1,81 @@ +# typed: strict +# frozen_string_literal: true + +require "method_source" +require "rubocop" +require_relative "../../../rubocops" + +module Tapioca + module Compilers + class Rubocop < Tapioca::Dsl::Compiler + # FIXME: Enable cop again when https://github.com/sorbet/sorbet/issues/3532 is fixed. + # rubocop:disable Style/MutableConstant + ConstantType = type_member { { fixed: T::Class[T.anything] } } + # rubocop:enable Style/MutableConstant + + sig { override.returns(T::Enumerable[Module]) } + def self.gather_constants + [ + RuboCop::Cop::Cask::Variables, + RuboCop::Cop::Homebrew::Blank, + RuboCop::Cop::Homebrew::CompactBlank, + RuboCop::Cop::Homebrew::MoveToExtendOS, + RuboCop::Cop::Homebrew::NegateInclude, + RuboCop::Cop::Homebrew::Presence, + RuboCop::Cop::Homebrew::Present, + RuboCop::Cop::Homebrew::SafeNavigationWithBlank, + RuboCop::Cop::FormulaAudit::ComponentsOrder, + RuboCop::Cop::FormulaAudit::DependencyOrder, + RuboCop::Cop::FormulaAudit::DeprecateDisableDate, + RuboCop::Cop::FormulaAudit::DeprecateDisableReason, + RuboCop::Cop::FormulaAudit::Licenses, + RuboCop::Cop::FormulaAudit::OptionDeclarations, + RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL, + RuboCop::Cop::FormulaAudit::GitUrls, + RuboCop::Cop::FormulaAudit::Miscellaneous, + RuboCop::Cop::FormulaAudit::Patches, + RuboCop::Cop::FormulaAudit::Test, + RuboCop::Cop::FormulaAudit::Text, + RuboCop::Cop::FormulaAuditStrict::GitUrls, + RuboCop::Cop::FormulaAuditStrict::Text, + RuboCop::Cop::FormulaCop, + RuboCop::Cop::OnSystemConditionalsHelper, + ] + end + + sig { override.void } + def decorate + root.create_path(constant) do |klass| + # For each encrypted attribute we find in the class + constant.instance_methods(false).each do |method_name| + source = constant.instance_method(method_name).source.lstrip + # https://www.rubydoc.info/gems/rubocop-ast/RuboCop/AST/NodePattern/Macros + # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb + # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern/method_definer.rb + if source.start_with?("def_node_matcher") + # https://github.com/Shopify/tapioca/blob/3341a9b/lib/tapioca/rbi_ext/model.rb#L89 + klass.create_method( + method_name.to_s, + parameters: [ + create_rest_param("node", type: "RuboCop::AST::Node"), + create_kw_rest_param("kwargs", type: "T.untyped"), + create_block_param("block", type: "T.untyped"), + ], + return_type: "T.untyped", + ) + elsif source.start_with?("def_node_search") + klass.create_method( + method_name.to_s, + parameters: [ + create_rest_param("node", type: "T.untyped"), + create_block_param("block", type: "T.untyped"), + ], + return_type: method_name.to_s.end_with?("?") ? "T::Boolean" : "T.untyped", + ) + end + end + end + end + end + end +end From 09f5a46218ca60db91ec68ec7586825d5c63b13e Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 05:44:33 -0800 Subject: [PATCH 02/15] rm hidden.rbi --- .../sorbet/rbi/hidden-definitions/hidden.rbi | 9623 ----------------- 1 file changed, 9623 deletions(-) delete mode 100644 Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi deleted file mode 100644 index ca3d0b349b..0000000000 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ /dev/null @@ -1,9623 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi hidden-definitions - -# typed: autogenerated - -class AbstractCoreTap - extend ::T::Private::Abstract::Hooks -end - -class Addrinfo - def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end -end - -class Array - include ::JSON::Ext::Generator::GeneratorMethods::Array - def abbrev(pattern=T.unsafe(nil)); end - - def deconstruct(); end - - def to_h(); end -end - -class Array - def self.try_convert(arg); end -end - -module Attrable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class BasicObject - def as_null_object(); end - - def null_object?(); end - - def received_message?(message, *args, &block); end - - def should(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def should_not_receive(message, &block); end - - def should_receive(message, opts=T.unsafe(nil), &block); end - - def stub(message_or_hash, opts=T.unsafe(nil), &block); end - - def stub_chain(*chain, &blk); end - - def unstub(message); end -end - -BasicObject::BasicObject = BasicObject - -class Benchmark::Job - def initialize(width); end -end - -class Benchmark::Report - def initialize(width=T.unsafe(nil), format=T.unsafe(nil)); end -end - -class Benchmark::Tms - def to_a(); end - - def to_h(); end -end - -class BigDecimal - def clone(); end - - def n_significant_digits(); end - - def precision(); end - - def precision_scale(); end - - def scale(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class BigDecimal - def self.interpret_loosely(arg); end -end - -class BinData::Int32be -end - -class BinData::Int32be -end - -class BinData::Int32le -end - -class BinData::Int32le -end - -class BinData::Int64be -end - -class BinData::Int64be -end - -class BinData::Int64le -end - -class BinData::Int64le -end - -class BinData::Uint16be -end - -class BinData::Uint16be -end - -class BinData::Uint16le -end - -class BinData::Uint16le -end - -class BinData::Uint32be -end - -class BinData::Uint32be -end - -class BinData::Uint32le -end - -class BinData::Uint32le -end - -class BinData::Uint64be -end - -class BinData::Uint64be -end - -class BinData::Uint64le -end - -class BinData::Uint64le -end - -class Binding - def clone(); end - - def irb(); end -end - -module BuildEnvironment::DSL - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Bundler::APIResponseInvalidDependenciesError - def status_code(); end -end - -class Bundler::APIResponseInvalidDependenciesError -end - -class Bundler::CurrentRuby - def jruby_30?(); end - - def jruby_31?(); end - - def jruby_32?(); end - - def jruby_33?(); end - - def jruby_3?(); end - - def maglev_30?(); end - - def maglev_31?(); end - - def maglev_32?(); end - - def maglev_33?(); end - - def maglev_3?(); end - - def mingw_30?(); end - - def mingw_31?(); end - - def mingw_32?(); end - - def mingw_33?(); end - - def mingw_3?(); end - - def mri_30?(); end - - def mri_31?(); end - - def mri_32?(); end - - def mri_33?(); end - - def mri_3?(); end - - def mswin64_30?(); end - - def mswin64_31?(); end - - def mswin64_32?(); end - - def mswin64_33?(); end - - def mswin64_3?(); end - - def mswin_30?(); end - - def mswin_31?(); end - - def mswin_32?(); end - - def mswin_33?(); end - - def mswin_3?(); end - - def on_30?(); end - - def on_31?(); end - - def on_32?(); end - - def on_33?(); end - - def on_3?(); end - - def rbx_30?(); end - - def rbx_31?(); end - - def rbx_32?(); end - - def rbx_33?(); end - - def rbx_3?(); end - - def ruby_30?(); end - - def ruby_31?(); end - - def ruby_32?(); end - - def ruby_33?(); end - - def ruby_3?(); end - - def truffleruby_30?(); end - - def truffleruby_31?(); end - - def truffleruby_32?(); end - - def truffleruby_33?(); end - - def truffleruby_3?(); end - - def windows?(); end - - def windows_18?(); end - - def windows_19?(); end - - def windows_1?(); end - - def windows_20?(); end - - def windows_21?(); end - - def windows_22?(); end - - def windows_23?(); end - - def windows_24?(); end - - def windows_25?(); end - - def windows_26?(); end - - def windows_27?(); end - - def windows_2?(); end - - def windows_30?(); end - - def windows_31?(); end - - def windows_32?(); end - - def windows_33?(); end - - def windows_3?(); end - - def x64_mingw_30?(); end - - def x64_mingw_31?(); end - - def x64_mingw_32?(); end - - def x64_mingw_33?(); end - - def x64_mingw_3?(); end -end - -class Bundler::Definition - def bundler_version_to_lock(); end - - def current_locked_dependencies(); end - - def deleted_deps(); end - - def dependencies_for(groups); end - - def filter_relevant(dependencies); end - - def locked_dependencies(); end - - def most_specific_locked_platform(); end - - def new_deps(); end - - def no_resolve_needed?(); end - - def requested_dependencies(); end - - def resolution_mode=(options); end - - def resolve_only_locally!(); end - - def setup_sources_for_resolve(); end -end - -class Bundler::Definition - def self.no_lock(); end - - def self.no_lock=(no_lock); end -end - -class Bundler::Dependency - def branch(); end - - def expanded_platforms(); end - - def git(); end - - def github(); end - - def path(); end - - def ref(); end - ALL_RUBY_VERSIONS = ::T.let(nil, ::T.untyped) -end - -Bundler::Deprecate = Gem::Deprecate - -module Bundler::Digest - SHA1_MASK = ::T.let(nil, ::T.untyped) - SHA1_WORDS = ::T.let(nil, ::T.untyped) -end - -module Bundler::Digest - def self.sha1(string); end -end - -class Bundler::DirectoryRemovalError - def initialize(orig_exception, msg); end - - def status_code(); end -end - -class Bundler::DirectoryRemovalError -end - -class Bundler::Dsl - def check_primary_source_safety(); end - GITHUB_PULL_REQUEST_URL = ::T.let(nil, ::T.untyped) -end - -class Bundler::EndpointSpecification - include ::Bundler::MatchRemoteMetadata - include ::Bundler::FetchMetadata -end - -class Bundler::Env -end - -class Bundler::Env - def self.environment(); end - - def self.report(options=T.unsafe(nil)); end - - def self.write(io); end -end - -class Bundler::EnvironmentPreserver - def replace_with_backup(); end -end - -class Bundler::EnvironmentPreserver - def self.env_to_hash(env); end - - def self.from_env(); end -end - -module Bundler::FetchMetadata - def matches_current_ruby?(); end - - def matches_current_rubygems?(); end -end - -module Bundler::FetchMetadata -end - -class Bundler::Fetcher - def fetch_spec(spec); end - - def fetchers(); end - - def http_proxy(); end - - def initialize(remote); end - - def specs(gem_names, source); end - - def specs_with_retry(gem_names, source); end - - def uri(); end - - def use_api(); end - - def user_agent(); end - FAIL_ERRORS = ::T.let(nil, ::T.untyped) - FETCHERS = ::T.let(nil, ::T.untyped) - HTTP_ERRORS = ::T.let(nil, ::T.untyped) - NET_ERRORS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Fetcher::AuthenticationRequiredError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::BadAuthenticationError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::Base - def api_fetcher?(); end - - def available?(); end - - def display_uri(); end - - def downloader(); end - - def fetch_uri(); end - - def initialize(downloader, remote, display_uri); end - - def remote(); end - - def remote_uri(); end -end - -class Bundler::Fetcher::Base -end - -class Bundler::Fetcher::CertificateFailureError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::CompactIndex - def available?(*args, &blk); end - - def specs(*args, &blk); end - - def specs_for_names(gem_names); end -end - -class Bundler::Fetcher::CompactIndex::ClientFetcher - def call(path, headers); end - - def fetcher(); end - - def fetcher=(_); end - - def ui(); end - - def ui=(_); end -end - -class Bundler::Fetcher::CompactIndex::ClientFetcher - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class Bundler::Fetcher::CompactIndex - def self.compact_index_request(method_name); end -end - -class Bundler::Fetcher::Dependency - def dependency_api_uri(gem_names=T.unsafe(nil)); end - - def dependency_specs(gem_names); end - - def get_formatted_specs_and_deps(gem_list); end - - def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end - - def unmarshalled_dep_gems(gem_names); end -end - -class Bundler::Fetcher::Dependency -end - -class Bundler::Fetcher::Downloader - def connection(); end - - def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end - - def initialize(connection, redirect_limit); end - - def redirect_limit(); end - - def request(uri, headers); end -end - -class Bundler::Fetcher::Downloader -end - -class Bundler::Fetcher::Index - def specs(_gem_names); end -end - -class Bundler::Fetcher::Index -end - -class Bundler::Fetcher::SSLError - def initialize(msg=T.unsafe(nil)); end -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher - def self.api_timeout(); end - - def self.api_timeout=(api_timeout); end - - def self.disable_endpoint(); end - - def self.disable_endpoint=(disable_endpoint); end - - def self.max_retries(); end - - def self.max_retries=(max_retries); end - - def self.redirect_limit(); end - - def self.redirect_limit=(redirect_limit); end -end - -module Bundler::FileUtils - VERSION = ::T.let(nil, ::T.untyped) -end - -class Bundler::FileUtils::Entry_ - def link(dest); end -end - -module Bundler::FileUtils - def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end - - def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end - - def self.ln_sr(src, dest, target_directory: T.unsafe(nil), force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end -end - -module Bundler::ForcePlatform -end - -module Bundler::ForcePlatform -end - -class Bundler::GemHelper - def allowed_push_host(); end - - def already_tagged?(); end - - def base(); end - - def build_checksum(built_gem_path=T.unsafe(nil)); end - - def build_gem(); end - - def built_gem_path(); end - - def clean?(); end - - def committed?(); end - - def current_branch(); end - - def default_remote(); end - - def gem_command(); end - - def gem_key(); end - - def gem_push?(); end - - def gem_push_host(); end - - def gemspec(); end - - def git_push(remote=T.unsafe(nil)); end - - def guard_clean(); end - - def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end - - def install(); end - - def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end - - def name(); end - - def rubygem_push(path); end - - def sh(cmd, &block); end - - def sh_with_input(cmd); end - - def sh_with_status(cmd, &block); end - - def spec_path(); end - - def tag_prefix=(tag_prefix); end - - def tag_version(); end - - def version(); end - - def version_tag(); end -end - -class Bundler::GemHelper - def self.gemspec(&block); end - - def self.install_tasks(opts=T.unsafe(nil)); end - - def self.instance(); end - - def self.instance=(instance); end - - def self.tag_prefix=(prefix); end -end - -class Bundler::GemHelpers::PlatformMatch - def self.specificity_score(spec_platform, user_platform); end -end - -module Bundler::GemHelpers - def self.local_platform(); end - - def self.same_deps(spec, exemplary_spec); end - - def self.same_specificity(platform, spec, exemplary_spec); end - - def self.sort_best_platform_match(matching, platform); end -end - -class Bundler::GemVersionPromoter - def level(); end - - def level=(value); end - - def major?(); end - - def minor?(); end - - def pre(); end - - def pre=(pre); end - - def pre?(); end - - def sort_versions(package, specs); end - - def strict(); end - - def strict=(strict); end -end - -class Bundler::GemVersionPromoter -end - -class Bundler::Graph - def edge_options(); end - - def groups(); end - - def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end - - def node_options(); end - - def output_file(); end - - def output_format(); end - - def relations(); end - - def viz(); end - GRAPH_NAME = ::T.let(nil, ::T.untyped) -end - -class Bundler::Graph::GraphVizClient - def g(); end - - def initialize(graph_instance); end - - def run(); end -end - -class Bundler::Graph::GraphVizClient -end - -class Bundler::Graph -end - -class Bundler::Index - include ::Enumerable -end - -class Bundler::Injector - def initialize(deps, options=T.unsafe(nil)); end - - def inject(gemfile_path, lockfile_path); end - - def remove(gemfile_path, lockfile_path); end - INJECTED_GEMS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Injector - def self.inject(new_deps, options=T.unsafe(nil)); end - - def self.remove(gems, options=T.unsafe(nil)); end -end - -class Bundler::Installer - def definition(); end -end - -class Bundler::LazySpecification - include ::Bundler::ForcePlatform - def eql?(other); end - - def force_ruby_platform(); end - - def force_ruby_platform=(force_ruby_platform); end - - def materialize_for_installation(); end -end - -class Bundler::LockfileParser - def may_include_redundant_platform_specific_gems?(); end -end - -class Bundler::LockfileParser - def self.bundled_with(); end -end - -module Bundler::MatchMetadata - def matches_current_ruby?(); end - - def matches_current_rubygems?(); end -end - -module Bundler::MatchMetadata -end - -module Bundler::MatchRemoteMetadata - include ::Bundler::MatchMetadata - include ::Bundler::FetchMetadata -end - -module Bundler::MatchRemoteMetadata -end - -class Bundler::PermissionError - def parent_folder(); end - - def permission_type(); end -end - -module Bundler::Plugin::API::Source - def ==(other); end - - def add_dependency_names(names); end - - def app_cache_dirname(); end - - def app_cache_path(custom_path=T.unsafe(nil)); end - - def cache(spec, custom_path=T.unsafe(nil)); end - - def cached!(); end - - def can_lock?(spec); end - - def dependency_names(); end - - def dependency_names=(dependency_names); end - - def double_check_for(*arg); end - - def eql?(other); end - - def fetch_gemspec_files(); end - - def gem_install_dir(); end - - def hash(); end - - def identifier(); end - - def include?(other); end - - def initialize(opts); end - - def install(spec, opts); end - - def install_path(); end - - def installed?(); end - - def local!(); end - - def name(); end - - def options(); end - - def options_to_lock(); end - - def post_install(spec, disable_exts=T.unsafe(nil)); end - - def remote!(); end - - def root(); end - - def spec_names(); end - - def specs(); end - - def to_lock(); end - - def to_s(); end - - def unlock!(); end - - def unmet_deps(); end - - def uri(); end - - def uri_hash(); end -end - -module Bundler::Plugin::API::Source -end - -module Bundler::Plugin::Events - GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped) - GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped) -end - -class Bundler::Plugin::Index - def installed_plugins(); end - - def plugin_commands(plugin); end - - def unregister_plugin(name); end -end - -class Bundler::Plugin::Index::CommandConflict - def initialize(plugin, commands); end -end - -class Bundler::Plugin::Index::CommandConflict -end - -class Bundler::Plugin::Index::SourceConflict - def initialize(plugin, sources); end -end - -class Bundler::Plugin::Index::SourceConflict -end - -class Bundler::Plugin::Installer - def install(names, options); end - - def install_definition(definition); end -end - -class Bundler::Plugin::Installer::Git - def generate_bin(spec, disable_extensions=T.unsafe(nil)); end -end - -class Bundler::Plugin::Installer::Git -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer -end - -class Bundler::Plugin::PluginInstallError -end - -class Bundler::Plugin::PluginInstallError -end - -class Bundler::Plugin::SourceList -end - -class Bundler::Plugin::SourceList -end - -module Bundler::Plugin - def self.list(); end - - def self.save_plugin(name, spec, optional_plugin=T.unsafe(nil)); end - - def self.uninstall(names, options); end -end - -class Bundler::ProcessLock -end - -class Bundler::ProcessLock - def self.lock(bundle_path=T.unsafe(nil)); end -end - -class Bundler::PubGrub::Incompatibility - def cause(); end - - def conflict?(); end - - def eql?(other); end - - def external_incompatibilities(); end - - def failure?(); end - - def initialize(terms, cause:, custom_explanation: T.unsafe(nil)); end - - def terms(); end -end - -class Bundler::PubGrub::Incompatibility -end - -class Bundler::RemoteSpecification - include ::Bundler::MatchRemoteMetadata - include ::Bundler::MatchMetadata - include ::Bundler::FetchMetadata -end - -class Bundler::Resolver - include ::Bundler::GemHelpers - def all_versions_for(package); end - - def bundler_pinned_to_current_version?(); end - - def default_bundler_source(); end - - def find_names_to_relax(incompatibility); end - - def incompatibilities_for(package, version); end - - def no_versions_incompatibility_for(package, unsatisfied_term); end - - def parse_dependency(package, dependency); end - - def raise_not_found!(package); end - - def setup_solver(); end - - def solve_versions(root:, logger:); end - - def source_for(name); end - - def versions_for(package, range=T.unsafe(nil)); end -end - -class Bundler::Resolver::Base - def [](name); end - - def base_requirements(); end - - def delete(specs); end - - def get_package(name); end - - def include_prereleases(names); end - - def initialize(source_requirements, dependencies, base, platforms, options); end - - def packages(); end - - def requirements(); end - - def source_requirements(); end - - def unlock_names(names); end -end - -class Bundler::Resolver::Base -end - -class Bundler::Resolver::Candidate - include ::Comparable - def ==(other); end - - def dependencies(); end - - def eql?(other); end - - def generic!(); end - - def initialize(version, specs: T.unsafe(nil)); end - - def platform_specific!(); end - - def prerelease?(); end - - def segments(); end - - def sort_obj(); end - - def to_specs(package); end - - def version(); end -end - -class Bundler::Resolver::Candidate -end - -class Bundler::Resolver::Incompatibility - def extended_explanation(); end - - def initialize(terms, cause:, custom_explanation: T.unsafe(nil), extended_explanation: T.unsafe(nil)); end -end - -class Bundler::Resolver::Incompatibility -end - -class Bundler::Resolver::Package - def ==(other); end - - def consider_prereleases!(); end - - def current_platform?(); end - - def dependency(); end - - def force_ruby_platform?(); end - - def ignores_prereleases?(); end - - def initialize(name, platforms, locked_specs:, unlock:, prerelease: T.unsafe(nil), dependency: T.unsafe(nil)); end - - def locked_version(); end - - def meta?(); end - - def name(); end - - def platforms(); end - - def prerelease_specified?(); end - - def root?(); end - - def unlock?(); end -end - -class Bundler::Resolver::Package -end - -class Bundler::Resolver::Root - def initialize(name); end -end - -class Bundler::Resolver::Root -end - -class Bundler::Resolver::SpecGroup - def dependencies(); end - - def empty?(); end - - def sorted_spec_names(); end -end - -class Bundler::Retry - def attempt(&block); end - - def attempts(&block); end - - def current_run(); end - - def current_run=(current_run); end - - def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def total_runs(); end - - def total_runs=(total_runs); end -end - -class Bundler::Retry - def self.attempts(); end - - def self.default_attempts(); end - - def self.default_retries(); end -end - -class Bundler::RubygemsIntegration - def add_default_gems_to(specs); end - - def add_to_load_path(paths); end - - def all_specs(); end - - def backport_ext_builder_monitor(); end - - def correct_for_windows_path(path); end - - def default_stubs(); end - - def find_bundler(version); end - - def find_name(name); end - - def gem_remote_fetcher(); end - - def load_env_plugins(); end - - def plain_specs(); end - - def plain_specs=(specs); end - - def stub_rubygems(specs); end - - def supports_bundler_trampolining?(); end -end - -module Bundler::SafeMarshal - ALLOWED_CLASSES = ::T.let(nil, ::T.untyped) - ERROR = ::T.let(nil, ::T.untyped) - PROC = ::T.let(nil, ::T.untyped) -end - -module Bundler::SafeMarshal -end - -class Bundler::SelfManager - def install_locked_bundler_and_restart_with_it_if_needed(); end - - def restart_with_locked_bundler_if_needed(); end - - def update_bundler_and_restart_with_it_if_needed(target); end -end - -class Bundler::SelfManager -end - -class Bundler::Settings - def processor_count(); end - STRING_KEYS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Settings::Mirror - def ==(other); end - - def fallback_timeout(); end - - def fallback_timeout=(timeout); end - - def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end - - def uri(); end - - def uri=(uri); end - - def valid?(); end - - def validate!(probe=T.unsafe(nil)); end - DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped) -end - -class Bundler::Settings::Mirror -end - -class Bundler::Settings::Mirrors - def each(&blk); end - - def for(uri); end - - def initialize(prober=T.unsafe(nil)); end - - def parse(key, value); end -end - -class Bundler::Settings::Mirrors -end - -class Bundler::Settings::Path - def self.keyword_init?(); end -end - -class Bundler::Settings::Validator -end - -class Bundler::Settings::Validator::Rule - def description(); end - - def fail!(key, value, *reasons); end - - def initialize(keys, description, &validate); end - - def k(key); end - - def set(settings, key, value, *reasons); end - - def validate!(key, value, settings); end -end - -class Bundler::Settings::Validator::Rule -end - -class Bundler::Settings::Validator - def self.validate!(key, value, settings); end -end - -class Bundler::Settings - def self.key_for(key); end -end - -class Bundler::SolveFailure - def status_code(); end -end - -class Bundler::SolveFailure -end - -class Bundler::Source - def add_dependency_names(names); end - - def cached!(); end - - def identifier(); end - - def local!(); end - - def local_only!(); end - - def remote!(); end - - def spec_names(); end -end - -class Bundler::Source::Git - def current_branch(); end - - def glob(); end - - def local?(); end - - def to_gemfile(); end - - def uri_with_specifiers(specifiers); end -end - -class Bundler::Source::Rubygems - def default_cache_path_for(dir); end - - def dependency_api_available?(); end - - def fetch_gem_if_possible(spec, previous_spec=T.unsafe(nil)); end - - def multiple_remotes?(); end - - def no_remotes?(); end - - def package_path(cache_path, spec); end - - def remote_names(); end - - def to_gemfile(); end -end - -class Bundler::Source::RubygemsAggregate - def identifier(); end - - def initialize(sources, source_map); end - - def source_map(); end - - def sources(); end - - def specs(); end -end - -class Bundler::Source::RubygemsAggregate -end - -class Bundler::SourceList - def add_global_rubygems_remote(uri); end - - def aggregate_global_source?(); end - - def expired_sources?(replacement_sources); end - - def get_with_fallback(source); end - - def global_path_source(); end - - def implicit_global_source?(); end - - def local_only!(); end - - def lock_other_sources(); end - - def lock_rubygems_sources(); end - - def merged_gem_lockfile_sections!(replacement_source); end - - def merged_gem_lockfile_sections?(); end - - def non_default_explicit_sources(); end - - def non_global_rubygems_sources(); end -end - -class Bundler::SourceMap - def all_requirements(); end - - def dependencies(); end - - def direct_requirements(); end - - def initialize(sources, dependencies, locked_specs); end - - def locked_requirements(); end - - def locked_specs(); end - - def pinned_spec_names(skip=T.unsafe(nil)); end - - def sources(); end -end - -class Bundler::SourceMap -end - -class Bundler::SpecSet - include ::Enumerable - include ::Bundler::TSort - def -(other); end - - def delete(specs); end - - def delete_by_name(name); end - - def incomplete_ruby_specs?(deps); end - - def incomplete_specs(); end - - def missing_specs(); end -end - -class Bundler::StubSpecification - def extensions(); end - - def full_gem_path=(path); end - - def gem_build_complete_path(); end - - def manually_installed?(); end -end - -module Bundler::TSort - def each_strongly_connected_component(&block); end - - def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end - - def strongly_connected_components(); end - - def tsort(); end - - def tsort_each(&block); end - - def tsort_each_child(node); end - - def tsort_each_node(); end -end - -class Bundler::TSort::Cyclic -end - -class Bundler::TSort::Cyclic -end - -module Bundler::TSort - def self.each_strongly_connected_component(each_node, each_child); end - - def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end - - def self.strongly_connected_components(each_node, each_child); end - - def self.tsort(each_node, each_child); end - - def self.tsort_each(each_node, each_child); end -end - -class Bundler::Thor - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end - HELP_MAPPINGS = ::T.let(nil, ::T.untyped) - TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped) - THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module Bundler::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 - -class Bundler::Thor::Actions::CapturableERB -end - -class Bundler::Thor::Actions::CapturableERB -end - -module Bundler::Thor::Actions::ClassMethods - def add_runtime_options!(); end - - def source_paths(); end - - def source_paths_for_search(); end - - def source_root(path=T.unsafe(nil)); end -end - -module Bundler::Thor::Actions::ClassMethods -end - -class Bundler::Thor::Actions::CreateFile - def data(); end - - def force_on_collision?(); end - - def force_or_skip_or_conflict(force, skip, &block); end - - def identical?(); end - - def initialize(base, destination, data, config=T.unsafe(nil)); end - - def on_conflict_behavior(&block); end - - def render(); end -end - -class Bundler::Thor::Actions::CreateFile -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::Directory - def execute!(); end - - def file_level_lookup(previous_lookup); end - - def files(lookup); end - - def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def source(); end -end - -class Bundler::Thor::Actions::Directory -end - -class Bundler::Thor::Actions::EmptyDirectory - def base(); end - - def config(); end - - def convert_encoded_instructions(filename); end - - def destination(); end - - def destination=(destination); end - - def exists?(); end - - def given_destination(); end - - def initialize(base, destination, config=T.unsafe(nil)); end - - def invoke!(); end - - def invoke_with_conflict_check(&block); end - - def on_conflict_behavior(); end - - def on_file_clash_behavior(); end - - def pretend?(); end - - def relative_destination(); end - - def revoke!(); end - - def say_status(status, color); end -end - -class Bundler::Thor::Actions::EmptyDirectory -end - -class Bundler::Thor::Actions::InjectIntoFile - def behavior(); end - - def flag(); end - - def initialize(base, destination, data, config); end - - def replace!(regexp, string, force); end - - def replacement(); end - - def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end -end - -class Bundler::Thor::Actions::InjectIntoFile -end - -module Bundler::Thor::Actions - def self.included(base); end -end - -class Bundler::Thor::AmbiguousCommandError -end - -class Bundler::Thor::AmbiguousCommandError -end - -Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError - -class Bundler::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 Bundler::Thor::Argument -end - -class Bundler::Thor::Arguments - def initialize(arguments=T.unsafe(nil)); end - - def parse(args); end - - def remaining(); end - NUMERIC = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Arguments - def self.parse(*args); end - - def self.split(args); end -end - -module Bundler::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 Bundler::Thor::Base::ClassMethods - def all_commands(); end - - def all_tasks(); end - - def allow_incompatible_default_type!(); end - - def argument(name, options=T.unsafe(nil)); end - - def arguments(); end - - def attr_accessor(*arg); end - - def attr_reader(*arg); end - - def attr_writer(*arg); end - - def baseclass(); end - - def basename(); end - - def build_option(name, options, scope); end - - def build_options(options, scope); 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=T.unsafe(nil)); end - - def class_options(options=T.unsafe(nil)); end - - def class_options_help(shell, groups=T.unsafe(nil)); end - - def commands(); end - - def create_command(meth); end - - def create_task(meth); end - - def disable_required_check?(command_name); end - - def dispatch(command, given_args, given_opts, config); end - - def exit_on_failure?(); end - - def find_and_refresh_command(name); end - - def find_and_refresh_task(name); end - - def from_superclass(method, default=T.unsafe(nil)); end - - def group(name=T.unsafe(nil)); end - - def handle_argument_error(command, error, args, arity); end - - def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end - - def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end - - def inherited(klass); end - - def initialize_added(); end - - def is_thor_reserved_word?(word, type); end - - def method_added(meth); end - - def namespace(name=T.unsafe(nil)); end - - def no_commands(&block); end - - def no_commands?(); end - - def no_commands_context(); end - - def no_tasks(&block); end - - def print_options(shell, options, group_name=T.unsafe(nil)); 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=T.unsafe(nil), config=T.unsafe(nil)); 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 -end - -module Bundler::Thor::Base::ClassMethods -end - -module Bundler::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 Bundler::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 Bundler::Thor::Command -end - -module Bundler::Thor::CoreExt -end - -class Bundler::Thor::CoreExt::HashWithIndifferentAccess - def [](key); end - - def []=(key, value); end - - def convert_key(key); end - - def delete(key); end - - def except(*keys); 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 Bundler::Thor::CoreExt::HashWithIndifferentAccess -end - -module Bundler::Thor::CoreExt -end - -Bundler::Thor::Correctable = DidYouMean::Correctable - -class Bundler::Thor::DynamicCommand - def initialize(name, options=T.unsafe(nil)); end -end - -class Bundler::Thor::DynamicCommand -end - -Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand - -class Bundler::Thor::Error -end - -class Bundler::Thor::Error -end - -class Bundler::Thor::Group - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end -end - -class Bundler::Thor::Group - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - 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(*arg); end - - def self.printable_tasks(*arg); end - - def self.remove_invocation(*names); end - - def self.self_command(); end - - def self.self_task(); end -end - -class Bundler::Thor::HiddenCommand -end - -class Bundler::Thor::HiddenCommand -end - -Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand - -module Bundler::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 Bundler::Thor::Invocation::ClassMethods - def prepare_for_invocation(key, name); end -end - -module Bundler::Thor::Invocation::ClassMethods -end - -module Bundler::Thor::Invocation - def self.included(base); end -end - -class Bundler::Thor::InvocationError -end - -class Bundler::Thor::InvocationError -end - -module Bundler::Thor::LineEditor -end - -class Bundler::Thor::LineEditor::Basic - def initialize(prompt, options); end - - def options(); end - - def prompt(); end - - def readline(); end -end - -class Bundler::Thor::LineEditor::Basic - def self.available?(); end -end - -class Bundler::Thor::LineEditor::Readline -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion - def initialize(text); end - - def matches(); end -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion -end - -class Bundler::Thor::LineEditor::Readline -end - -module Bundler::Thor::LineEditor - def self.best_available(); end - - def self.readline(prompt, options=T.unsafe(nil)); end -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::NestedContext - def enter(); end - - def entered?(); end -end - -class Bundler::Thor::NestedContext -end - -class Bundler::Thor::NoKwargSpellChecker - def initialize(dictionary); end -end - -class Bundler::Thor::NoKwargSpellChecker -end - -class Bundler::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 Bundler::Thor::Option - def self.parse(key, value); end -end - -class Bundler::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 - - def unshift(arg, is_value: T.unsafe(nil)); 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 Bundler::Thor::Options - def self.to_switches(options); end -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -module Bundler::Thor::Sandbox -end - -module Bundler::Thor::Sandbox -end - -module Bundler::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_error(*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 Bundler::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_error(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, *arg); 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 Bundler::Thor::Shell::Basic -end - -class Bundler::Thor::Shell::Color - def are_colors_disabled?(); end - - def are_colors_supported?(); 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 Bundler::Thor::Shell::Color -end - -class Bundler::Thor::Shell::HTML - def ask(statement, color=T.unsafe(nil)); 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) - 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 Bundler::Thor::Shell::HTML -end - -module Bundler::Thor::Shell -end - -Bundler::Thor::Task = Bundler::Thor::Command - -class Bundler::Thor::UndefinedCommandError - include ::DidYouMean::Correctable - def all_commands(); end - - def command(); end - - def initialize(command, all_commands, namespace); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker -end - -class Bundler::Thor::UndefinedCommandError -end - -Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError - -class Bundler::Thor::UnknownArgumentError - include ::DidYouMean::Correctable - def initialize(switches, unknown); end - - def switches(); end - - def unknown(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker -end - -class Bundler::Thor::UnknownArgumentError -end - -module Bundler::Thor::Util -end - -module Bundler::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 Bundler::Thor - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - 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 - - def self.find_command_possibilities(meth); end - - 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 - -class Bundler::UI::Shell - def add_color(string, *color); end - - def ask(msg); end - - def confirm(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def confirm?(); end - - def debug(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def debug?(); end - - def error(msg=T.unsafe(nil), newline=T.unsafe(nil), color=T.unsafe(nil)); end - - def error?(); end - - def info(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def info?(); end - - def initialize(options=T.unsafe(nil)); end - - def level(name=T.unsafe(nil)); end - - def level=(level); end - - def no?(); end - - def quiet?(); end - - def shell=(shell); end - - def silence(&blk); end - - def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end - - def unprinted_warnings(); end - - def warn(msg=T.unsafe(nil), newline=T.unsafe(nil), color=T.unsafe(nil)); end - - def warn?(); end - - def yes?(msg); end - LEVELS = ::T.let(nil, ::T.untyped) -end - -class Bundler::UI::Shell -end - -class Bundler::UI::Silent - def confirm?(); end - - def error?(); end - - def info?(); end - - def warn?(); end -end - -module Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ABS_URI_REF = ::T.let(nil, ::T.untyped) - DEFAULT_PARSER = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - OPAQUE = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REGISTRY = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - REL_URI_REF = ::T.let(nil, ::T.untyped) - RFC3986_PARSER = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped) - TBLENCURICOMP_ = ::T.let(nil, ::T.untyped) - TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped) - UNSAFE = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - VERSION_CODE = ::T.let(nil, ::T.untyped) - WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::Error -end - -class Bundler::URI::Error -end - -class Bundler::URI::FTP - def set_typecode(v); end - - def typecode(); end - - def typecode=(typecode); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - TYPECODE = ::T.let(nil, ::T.untyped) - TYPECODE_PREFIX = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::FTP - def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end -end - -class Bundler::URI::File - def check_password(user); end - - def check_user(user); end - - def check_userinfo(user); end - - def set_userinfo(v); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::File -end - -class Bundler::URI::Generic - include ::Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - def +(oth); end - - def -(oth); end - - def ==(oth); end - - def absolute(); end - - def absolute?(); end - - def coerce(oth); end - - def component(); end - - def component_ary(); end - - def decoded_password(); end - - def decoded_user(); end - - def default_port(); end - - def eql?(oth); end - - def find_proxy(env=T.unsafe(nil)); end - - def fragment(); end - - def fragment=(v); end - - def hierarchical?(); end - - def host(); end - - def host=(v); end - - def hostname(); end - - def hostname=(v); end - - def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end - - def merge(oth); end - - def merge!(oth); end - - def normalize(); end - - def normalize!(); end - - def opaque(); end - - def opaque=(v); end - - def parser(); end - - def password(); end - - def password=(password); end - - def path(); end - - def path=(v); end - - def port(); end - - def port=(v); end - - def query(); end - - def query=(v); end - - def registry(); end - - def registry=(v); end - - def relative?(); end - - def route_from(oth); end - - def route_to(oth); end - - def scheme(); end - - def scheme=(v); end - - def select(*components); end - - def set_host(v); end - - def set_opaque(v); end - - def set_password(v); end - - def set_path(v); end - - def set_port(v); end - - def set_registry(v); end - - def set_scheme(v); end - - def set_user(v); end - - def set_userinfo(user, password=T.unsafe(nil)); end - - def user(); end - - def user=(user); end - - def userinfo(); end - - def userinfo=(userinfo); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - USE_REGISTRY = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::Generic - def self.build(args); end - - def self.build2(args); end - - def self.component(); end - - def self.default_port(); end - - def self.use_proxy?(hostname, addr, port, no_proxy); end - - def self.use_registry(); end -end - -class Bundler::URI::HTTP - def authority(); end - - def origin(); end - - def request_uri(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTP -end - -class Bundler::URI::HTTPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTPS -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - SCOPE = ::T.let(nil, ::T.untyped) - SCOPE_BASE = ::T.let(nil, ::T.untyped) - SCOPE_ONE = ::T.let(nil, ::T.untyped) - SCOPE_SUB = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAP -end - -class Bundler::URI::LDAPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAPS -end - -class Bundler::URI::MailTo - def headers(); end - - def headers=(v); end - - def initialize(*arg); end - - def set_headers(v); end - - def set_to(v); end - - def to(); end - - def to=(v); end - - def to_mailtext(); end - - def to_rfc822text(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - EMAIL_REGEXP = ::T.let(nil, ::T.untyped) - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::MailTo -end - -Bundler::URI::Parser = Bundler::URI::RFC2396_Parser - -Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP - -class Bundler::URI::RFC2396_Parser - include ::Bundler::URI::RFC2396_REGEXP - def escape(str, unsafe=T.unsafe(nil)); end - - def extract(str, schemes=T.unsafe(nil)); end - - def initialize(opts=T.unsafe(nil)); end - - def join(*uris); end - - def make_regexp(schemes=T.unsafe(nil)); end - - def parse(uri); end - - def pattern(); end - - def regexp(); end - - def split(uri); end - - def unescape(str, escaped=T.unsafe(nil)); end -end - -class Bundler::URI::RFC2396_Parser -end - -module Bundler::URI::RFC2396_REGEXP -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ALNUM = ::T.let(nil, ::T.untyped) - ALPHA = ::T.let(nil, ::T.untyped) - DOMLABEL = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HEX = ::T.let(nil, ::T.untyped) - HIER_PART = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - HOSTNAME = ::T.let(nil, ::T.untyped) - HOSTPORT = ::T.let(nil, ::T.untyped) - IPV4ADDR = ::T.let(nil, ::T.untyped) - IPV6ADDR = ::T.let(nil, ::T.untyped) - IPV6REF = ::T.let(nil, ::T.untyped) - NET_PATH = ::T.let(nil, ::T.untyped) - OPAQUE_PART = ::T.let(nil, ::T.untyped) - PATH_SEGMENTS = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REG_NAME = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_SEGMENT = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - RESERVED = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TOPLABEL = ::T.let(nil, ::T.untyped) - UNRESERVED = ::T.let(nil, ::T.untyped) - URIC = ::T.let(nil, ::T.untyped) - URIC_NO_SLASH = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - X_ABS_URI = ::T.let(nil, ::T.untyped) - X_REL_URI = ::T.let(nil, ::T.untyped) -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN -end - -module Bundler::URI::RFC2396_REGEXP -end - -class Bundler::URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_URI = ::T.let(nil, ::T.untyped) - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::RFC3986_Parser -end - -module Bundler::URI::Util -end - -module Bundler::URI::Util - def self.make_components_hash(klass, array_hash); end -end - -class Bundler::URI::WS - def request_uri(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::WS -end - -class Bundler::URI::WSS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::WSS -end - -module Bundler::URI - def self.decode_uri_component(str, enc=T.unsafe(nil)); end - - def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end - - def self.decode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.encode_uri_component(str, enc=T.unsafe(nil)); end - - def self.encode_www_form(enum, enc=T.unsafe(nil)); end - - def self.encode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.extract(str, schemes=T.unsafe(nil), &block); end - - def self.for(scheme, *arguments, default: T.unsafe(nil)); end - - def self.get_encoding(label); end - - def self.join(*str); end - - def self.parse(uri); end - - def self.regexp(schemes=T.unsafe(nil)); end - - def self.register_scheme(scheme, klass); end - - def self.scheme_list(); end - - def self.split(uri); end -end - -module Bundler::URINormalizer -end - -module Bundler::URINormalizer - def self.normalize_suffix(uri, trailing_slash: T.unsafe(nil)); end -end - -module Bundler - def self.configure_gem_home_and_path(path=T.unsafe(nil)); end - - def self.create_bundle_path(); end - - def self.gem_version(); end - - def self.most_specific_locked_platform?(platform); end - - def self.original_exec(*args); end - - def self.original_system(*args); end - - def self.preferred_gemfile_name(); end - - def self.reset_settings_and_root!(); end - - def self.safe_load_marshal(data); end - - def self.self_manager(); end - - def self.unbundled_env(); end - - def self.unbundled_exec(*args); end - - def self.unbundled_system(*args); end -end - -class CGI - VERSION = ::T.let(nil, ::T.untyped) -end - -class CGI::Cookie - DOMAIN_VALUE_RE = ::T.let(nil, ::T.untyped) - PATH_VALUE_RE = ::T.let(nil, ::T.untyped) - TOKEN_RE = ::T.let(nil, ::T.untyped) -end - -module CGI::Escape - def escapeURIComponent(arg); end - - def unescapeURIComponent(*arg); end -end - -module CGI::HtmlExtension - def a(href=T.unsafe(nil)); end - - def base(href=T.unsafe(nil)); end - - def blockquote(cite=T.unsafe(nil)); end - - def caption(align=T.unsafe(nil)); end - - def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end - - def checkbox_group(name=T.unsafe(nil), *values); end - - def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end - - def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end - - def html(attributes=T.unsafe(nil)); end - - def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end - - def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end - - def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end - - def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def popup_menu(name=T.unsafe(nil), *values); end - - def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end - - def radio_group(name=T.unsafe(nil), *values); end - - def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end - - def scrolling_list(name=T.unsafe(nil), *values); end - - def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end - - def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end -end - -module CGI::HtmlExtension -end - -module CGI::Util - def escapeURIComponent(arg); end - - def unescapeURIComponent(*arg); end -end - -module Cachable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Cask::Artifact::AbstractArtifact - extend ::T::Private::Abstract::Hooks -end - -module Cask::Cache - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Cask::Config - def appdir(); end - - def appdir=(path); end - - def audio_unit_plugindir(); end - - def audio_unit_plugindir=(path); end - - def colorpickerdir(); end - - def colorpickerdir=(path); end - - def dictionarydir(); end - - def dictionarydir=(path); end - - def fontdir(); end - - def fontdir=(path); end - - def input_methoddir(); end - - def input_methoddir=(path); end - - def internet_plugindir(); end - - def internet_plugindir=(path); end - - def keyboard_layoutdir(); end - - def keyboard_layoutdir=(path); end - - def mdimporterdir(); end - - def mdimporterdir=(path); end - - def prefpanedir(); end - - def prefpanedir=(path); end - - def qlplugindir(); end - - def qlplugindir=(path); end - - def screen_saverdir(); end - - def screen_saverdir=(path); end - - def servicedir(); end - - def servicedir=(path); end - - def vst3_plugindir(); end - - def vst3_plugindir=(path); end - - def vst_plugindir(); end - - def vst_plugindir=(path); end -end - -class Cask::DSL::Version - def dots_to_hyphens(); end - - def dots_to_underscores(); end - - def hyphens_to_dots(); end - - def hyphens_to_underscores(); end - - def no_dots(); end - - def no_hyphens(); end - - def no_underscores(); end - - def underscores_to_dots(); end - - def underscores_to_hyphens(); end -end - -module Cask::Denylist - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Class - def any_instance(); end - - def json_creatable?(); end -end - -class Date - def infinite?(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class Date::Infinity - def initialize(d=T.unsafe(nil)); end -end - -class DateTime - def self.new(*arg); end -end - -class Delegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Dependencies - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Dependencies - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class DidYouMean::ClassNameChecker - def class_name(); end - - def class_names(); end - - def corrections(); end - - def initialize(exception); end - - def scopes(); end -end - -module DidYouMean::Correctable - def corrections(); end - - def original_message(); end - - def spell_checker(); end - - def to_s(); end -end - -class DidYouMean::Formatter - def message_for(corrections); end -end - -class DidYouMean::Formatter - def self.message_for(corrections); end -end - -module DidYouMean::Jaro - def self.distance(str1, str2); end -end - -module DidYouMean::JaroWinkler - def self.distance(str1, str2); end -end - -class DidYouMean::KeyErrorChecker - def corrections(); end - - def initialize(key_error); end -end - -class DidYouMean::KeyErrorChecker -end - -module DidYouMean::Levenshtein - def self.distance(str1, str2); end - - def self.min3(a, b, c); end -end - -class DidYouMean::MethodNameChecker - def corrections(); end - - def initialize(exception); end - - def method_name(); end - - def method_names(); end - - def names_to_exclude(); end - - def receiver(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -class DidYouMean::NullChecker - def corrections(); end - - def initialize(*arg); end -end - -class DidYouMean::PatternKeyNameChecker - def corrections(); end - - def initialize(no_matching_pattern_key_error); end -end - -class DidYouMean::PatternKeyNameChecker -end - -DidYouMean::PlainFormatter = DidYouMean::Formatter - -class DidYouMean::RequirePathChecker - def corrections(); end - - def initialize(exception); end - - def path(); end -end - -class DidYouMean::RequirePathChecker - def self.requireables(); end -end - -class DidYouMean::TreeSpellChecker - def augment(); end - - def correct(input); end - - def dictionary(); end - - def dictionary_without_leaves(); end - - def dimensions(); end - - def find_leaves(path); end - - def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end - - def plausible_dimensions(input); end - - def possible_paths(states); end - - def separator(); end - - def tree_depth(); end -end - -class DidYouMean::TreeSpellChecker -end - -class DidYouMean::VariableNameChecker - def corrections(); end - - def cvar_names(); end - - def initialize(exception); end - - def ivar_names(); end - - def lvar_names(); end - - def method_names(); end - - def name(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module DidYouMean - def self.correct_error(error_class, spell_checker); end - - def self.formatter(); end - - def self.formatter=(formatter); end - - def self.spell_checkers(); end -end - -module Digest - VERSION = ::T.let(nil, ::T.untyped) -end - -class Dir - def children(); end - - def each_child(); end -end - -module Dir::Tmpname - UNUSABLE_CHARS = ::T.let(nil, ::T.untyped) -end - -class Dir - def self.exists?(arg); end -end - -class ELFTools::LazyArray - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class ELFTools::Structs::ELF32_PhdrBe -end - -class ELFTools::Structs::ELF32_PhdrBe -end - -class ELFTools::Structs::ELF32_PhdrLe -end - -class ELFTools::Structs::ELF32_PhdrLe -end - -class ELFTools::Structs::ELF32_symBe -end - -class ELFTools::Structs::ELF32_symBe -end - -class ELFTools::Structs::ELF32_symLe -end - -class ELFTools::Structs::ELF32_symLe -end - -class ELFTools::Structs::ELF64_PhdrBe -end - -class ELFTools::Structs::ELF64_PhdrBe -end - -class ELFTools::Structs::ELF64_PhdrLe -end - -class ELFTools::Structs::ELF64_PhdrLe -end - -class ELFTools::Structs::ELF64_symBe -end - -class ELFTools::Structs::ELF64_symBe -end - -class ELFTools::Structs::ELF64_symLe -end - -class ELFTools::Structs::ELF64_symLe -end - -class ELFTools::Structs::ELF_DynBe -end - -class ELFTools::Structs::ELF_DynBe -end - -class ELFTools::Structs::ELF_DynLe -end - -class ELFTools::Structs::ELF_DynLe -end - -class ELFTools::Structs::ELF_EhdrBe -end - -class ELFTools::Structs::ELF_EhdrBe -end - -class ELFTools::Structs::ELF_EhdrLe -end - -class ELFTools::Structs::ELF_EhdrLe -end - -class ELFTools::Structs::ELF_NhdrBe -end - -class ELFTools::Structs::ELF_NhdrBe -end - -class ELFTools::Structs::ELF_NhdrLe -end - -class ELFTools::Structs::ELF_NhdrLe -end - -class ELFTools::Structs::ELF_RelBe -end - -class ELFTools::Structs::ELF_RelBe -end - -class ELFTools::Structs::ELF_RelLe -end - -class ELFTools::Structs::ELF_RelLe -end - -class ELFTools::Structs::ELF_RelaBe -end - -class ELFTools::Structs::ELF_RelaBe -end - -class ELFTools::Structs::ELF_RelaLe -end - -class ELFTools::Structs::ELF_RelaLe -end - -class ELFTools::Structs::ELF_ShdrBe -end - -class ELFTools::Structs::ELF_ShdrBe -end - -class ELFTools::Structs::ELF_ShdrLe -end - -class ELFTools::Structs::ELF_ShdrLe -end - -class ERB - def def_method(mod, methodname, fname=T.unsafe(nil)); end - - def def_module(methodname=T.unsafe(nil)); end -end - -class ERB::Compiler::Scanner - DEFAULT_ETAGS = ::T.let(nil, ::T.untyped) - DEFAULT_STAGS = ::T.let(nil, ::T.untyped) -end - -class Encoding - def _dump(*arg); end - CESU_8 = ::T.let(nil, ::T.untyped) - CP720 = ::T.let(nil, ::T.untyped) - IBM720 = ::T.let(nil, ::T.untyped) -end - -class Encoding::Converter - def initialize(*arg); end -end - -class Encoding - def self._load(arg); end -end - -module Enumerable - def compact(); end -end - -module Enumerable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Enumerator - def +(arg); end - - def each_with_index(); end -end - -class Enumerator::ArithmeticSequence - def begin(); end - - def each(&blk); end - - def end(); end - - def exclude_end?(); end - - def last(*arg); end - - def step(); end -end - -class Enumerator::ArithmeticSequence -end - -class Enumerator::Generator - def each(*arg, &blk); end - - def initialize(*arg); end -end - -class Enumerator::Producer - def each(&blk); end -end - -class Enumerator::Producer -end - -class Errno::EAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EAUTH -end - -class Errno::EBADARCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADARCH -end - -class Errno::EBADEXEC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADEXEC -end - -class Errno::EBADMACHO - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADMACHO -end - -class Errno::EBADRPC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADRPC -end - -Errno::ECAPMODE = Errno::NOERROR - -Errno::EDEADLOCK = Errno::NOERROR - -class Errno::EDEVERR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EDEVERR -end - -Errno::EDOOFUS = Errno::NOERROR - -class Errno::EFTYPE - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EFTYPE -end - -Errno::EIPSEC = Errno::NOERROR - -class Errno::ELAST - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ELAST -end - -class Errno::ENEEDAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENEEDAUTH -end - -class Errno::ENOATTR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOATTR -end - -class Errno::ENOPOLICY - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOPOLICY -end - -Errno::ENOTCAPABLE = Errno::NOERROR - -class Errno::ENOTSUP - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOTSUP -end - -class Errno::EPROCLIM - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCLIM -end - -class Errno::EPROCUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCUNAVAIL -end - -class Errno::EPROGMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGMISMATCH -end - -class Errno::EPROGUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGUNAVAIL -end - -class Errno::EPWROFF - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPWROFF -end - -Errno::EQFULL = Errno::ELAST - -class Errno::ERPCMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ERPCMISMATCH -end - -class Errno::ESHLIBVERS - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ESHLIBVERS -end - -module Etc - VERSION = ::T.let(nil, ::T.untyped) -end - -class Etc::Group - def gid(); end - - def gid=(_); end - - def mem(); end - - def mem=(_); end - - def name(); end - - def name=(_); end - - def passwd(); end - - def passwd=(_); end -end - -class Etc::Group - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class Etc::Passwd - def change(); end - - def change=(_); end - - def dir=(_); end - - def expire(); end - - def expire=(_); end - - def gecos(); end - - def gecos=(_); end - - def gid=(_); end - - def name=(_); end - - def passwd=(_); end - - def shell=(_); end - - def uclass(); end - - def uclass=(_); end - - def uid=(_); end -end - -class Etc::Passwd - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class ExitCalledError -end - -class ExitCalledError -end - -class FalseClass - include ::JSON::Ext::Generator::GeneratorMethods::FalseClass -end - -class Fiber - def backtrace(*arg); end - - def backtrace_locations(*arg); end - - def blocking?(); end - - def initialize(*arg); end - - def transfer(*arg); end -end - -class Fiber - def self.blocking?(); end - - def self.current(); end - - def self.current_scheduler(); end - - def self.schedule(*arg); end - - def self.scheduler(); end - - def self.set_scheduler(arg); end -end - -module Fiddle - ALIGN_INT16_T = ::T.let(nil, ::T.untyped) - ALIGN_INT32_T = ::T.let(nil, ::T.untyped) - ALIGN_INT64_T = ::T.let(nil, ::T.untyped) - ALIGN_INT8_T = ::T.let(nil, ::T.untyped) - NULL = ::T.let(nil, ::T.untyped) - RTLD_GLOBAL = ::T.let(nil, ::T.untyped) - RTLD_LAZY = ::T.let(nil, ::T.untyped) - RTLD_NOW = ::T.let(nil, ::T.untyped) - SIZEOF_CONST_STRING = ::T.let(nil, ::T.untyped) - SIZEOF_INT16_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT32_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT64_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT8_T = ::T.let(nil, ::T.untyped) - TYPE_CONST_STRING = ::T.let(nil, ::T.untyped) - TYPE_INT16_T = ::T.let(nil, ::T.untyped) - TYPE_INT32_T = ::T.let(nil, ::T.untyped) - TYPE_INT64_T = ::T.let(nil, ::T.untyped) - TYPE_INT8_T = ::T.let(nil, ::T.untyped) - TYPE_VARIADIC = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - WINDOWS = ::T.let(nil, ::T.untyped) -end - -class Fiddle::CStruct - include ::Enumerable - def each(&blk); end - - def each_pair(); end - - def replace(another); end - - def to_h(); end -end - -class Fiddle::CStruct - def self.entity_class(); end - - def self.offsetof(name, members, types); end -end - -module Fiddle::CStructBuilder -end - -module Fiddle::CStructBuilder - def self.create(klass, types, members); end -end - -class Fiddle::CStructEntity - include ::Fiddle::PackInfo - include ::Fiddle::ValueUtil - def [](*args); end - - def []=(*args); end - - def assign_names(members); end - - def initialize(addr, types, func=T.unsafe(nil)); end - - def set_ctypes(types); end - - def to_s(); end -end - -class Fiddle::CStructEntity - def self.alignment(types); end - - def self.malloc(types, func=T.unsafe(nil), size=T.unsafe(nil), &block); end - - def self.size(types); end -end - -class Fiddle::CUnion -end - -class Fiddle::CUnion - def self.entity_class(); end - - def self.offsetof(name, members, types); end -end - -class Fiddle::CUnionEntity -end - -class Fiddle::CUnionEntity -end - -class Fiddle::ClearedReferenceError -end - -class Fiddle::ClearedReferenceError -end - -class Fiddle::CompositeHandler - def [](symbol); end - - def handlers(); end - - def initialize(handlers); end - - def sym(symbol); end -end - -class Fiddle::CompositeHandler -end - -class Fiddle::Error -end - -class Fiddle::Error -end - -class Fiddle::Function - def need_gvl?(); end - - def to_proc(); end -end - -class Fiddle::Handle - def file_name(); end - - def to_ptr(); end -end - -module Fiddle::Importer - include ::Fiddle - include ::Fiddle::CParser -end - -module Fiddle::Importer - extend ::Fiddle::Importer - extend ::Fiddle - extend ::Fiddle::CParser -end - -class Fiddle::MemoryView - def [](*arg); end - - def byte_size(); end - - def format(); end - - def initialize(arg); end - - def item_size(); end - - def ndim(); end - - def obj(); end - - def readonly?(); end - - def release(); end - - def shape(); end - - def strides(); end - - def sub_offsets(); end -end - -class Fiddle::MemoryView - def self.export(arg); end -end - -module Fiddle::PackInfo - ALIGN_MAP = ::T.let(nil, ::T.untyped) - PACK_MAP = ::T.let(nil, ::T.untyped) - SIZE_MAP = ::T.let(nil, ::T.untyped) -end - -module Fiddle::PackInfo - def self.align(addr, align); end -end - -class Fiddle::Packer - include ::Fiddle::PackInfo - def initialize(types); end - - def pack(ary); end - - def size(); end - - def unpack(ary); end -end - -class Fiddle::Packer - def self.[](*types); end -end - -class Fiddle::Pinned - def clear(); end - - def cleared?(); end - - def initialize(arg); end - - def ref(); end -end - -class Fiddle::Pinned -end - -class Fiddle::Pointer - def call_free(); end - - def freed?(); end -end - -class Fiddle::StructArray - include ::Fiddle::ValueUtil - def []=(index, value); end - - def initialize(ptr, type, initial_values); end - - def to_ptr(); end -end - -class Fiddle::StructArray -end - -module Fiddle::ValueUtil - def signed_value(val, ty); end - - def unsigned_value(val, ty); end - - def wrap_arg(arg, ty, funcs=T.unsafe(nil), &block); end - - def wrap_args(args, tys, funcs, &block); end -end - -module Fiddle::ValueUtil -end - -class File - def self.absolute_path?(arg); end - - def self.exists?(arg); end -end - -module FileUtils - include ::FileUtils::StreamUtils_ -end - -module FileUtils::DryRun - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::DryRun - extend ::FileUtils::DryRun - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - extend ::FileUtils::NoWrite - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::Verbose - include ::FileUtils - include ::FileUtils::StreamUtils_ -end - -module FileUtils::Verbose - extend ::FileUtils::Verbose - extend ::FileUtils - extend ::FileUtils::StreamUtils_ -end - -module FileUtils - extend ::FileUtils::StreamUtils_ -end - -class Float - include ::JSON::Ext::Generator::GeneratorMethods::Float -end - -module FormulaCellarChecks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class FormulaConflict - def name(); end - - def name=(_); end - - def reason(); end - - def reason=(_); end -end - -class FormulaConflict - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Forwardable - VERSION = ::T.let(nil, ::T.untyped) -end - -module Forwardable - def self._compile_method(src, file, line); end - - def self._delegator_method(obj, accessor, method, ali); end - - def self._valid_method?(method); end - - def self.debug(); end - - def self.debug=(debug); end -end - -module GC - def garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end -end - -module GC - def self.latest_compact_info(); end - - def self.using_rvargc?(); end - - def self.verify_transient_heap_internal_consistency(); end -end - -module Gem - ConfigMap = ::T.let(nil, ::T.untyped) - HAVE_OPENSSL = ::T.let(nil, ::T.untyped) - KERNEL_WARN_IGNORES_INTERNAL_ENTRIES = ::T.let(nil, ::T.untyped) - RbConfigPriorities = ::T.let(nil, ::T.untyped) - RubyGemsVersion = ::T.let(nil, ::T.untyped) - UNTAINT = ::T.let(nil, ::T.untyped) -end - -class Gem::BasicSpecification - def plugins(); end -end - -module Gem::BundlerVersionFinder - def self.prioritize!(specs); end -end - -class Gem::ConfigFile - def ipv4_fallback_enabled(); end - - def ipv4_fallback_enabled=(ipv4_fallback_enabled); end - DEFAULT_IPV4_FALLBACK_ENABLED = ::T.let(nil, ::T.untyped) -end - -class Gem::Dependency - include ::Bundler::ForcePlatform - def force_ruby_platform(); end - - def prioritizes_bundler?(); end -end - -class Gem::DependencyList - include ::Gem::TSort -end - -module Gem::Deprecate - def deprecate(name, repl, year, month); end -end - -module Gem::Deprecate - def self.next_rubygems_major_version(); end - - def self.rubygems_deprecate(name, replacement=T.unsafe(nil)); end - - def self.rubygems_deprecate_command(); end -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::CargoBuilder - def build(_extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), cargo_dir=T.unsafe(nil)); end - - def build_crate(dest_path, results, args, cargo_dir); end - - def build_env(); end - - def cargo_command(cargo_dir, dest_path, args=T.unsafe(nil)); end - - def initialize(spec); end - - def profile(); end - - def profile=(profile); end - - def runner(); end - - def runner=(runner); end - - def spec(); end - - def spec=(spec); end -end - -class Gem::Ext::CargoBuilder::DylibNotFoundError - def initialize(dir); end -end - -class Gem::Ext::CargoBuilder::DylibNotFoundError -end - -class Gem::Ext::CargoBuilder -end - -class Gem::Ext::ExtConfBuilder -end - -class Gem::Ext::ExtConfBuilder - def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), extension_dir=T.unsafe(nil)); end - - def self.get_relative_path(path, base); end -end - -class Gem::Installer - include ::Gem::InstallerUninstallerUtils - def ensure_writable_dir(dir); end - - def explicit_version_requirement(name); end - - def gemdeps_load(name); end - - def generate_plugins(); end -end - -Gem::Installer::ExtensionBuildError = Gem::Ext::BuildError - -class Gem::Installer::FakePackage - def copy_to(path); end - - def data_mode(); end - - def data_mode=(data_mode); end - - def dir_mode(); end - - def dir_mode=(dir_mode); end - - def extract_files(destination_dir, pattern=T.unsafe(nil)); end - - def initialize(spec); end - - def prog_mode(); end - - def prog_mode=(prog_mode); end - - def spec(); end - - def spec=(spec); end -end - -class Gem::Installer::FakePackage -end - -class Gem::Installer - def self.inherited(klass); end -end - -module Gem::InstallerUninstallerUtils - def regenerate_plugins_for(spec, plugins_dir); end - - def remove_plugins_for(spec, plugins_dir); end -end - -module Gem::InstallerUninstallerUtils -end - -class Gem::Licenses - LICENSE_REF = ::T.let(nil, ::T.untyped) -end - -class Gem::PathSupport - def home(); end - - def initialize(env); end - - def path(); end - - def spec_cache_dir(); end -end - -class Gem::Platform - def normalized_linux_version(); end - - def normalized_linux_version_ext(); end - WINDOWS = ::T.let(nil, ::T.untyped) - X64_LINUX = ::T.let(nil, ::T.untyped) - X64_LINUX_MUSL = ::T.let(nil, ::T.untyped) -end - -class Gem::Platform - def self.match_gem?(platform, gem_name); end - - def self.match_spec?(spec); end - - def self.sort_priority(platform); end -end - -class Gem::Request - extend ::Gem::UserInteraction - extend ::Gem::DefaultUserInteraction - extend ::Gem::Text -end - -class Gem::RequestSet - include ::Gem::TSort -end - -class Gem::RequestSet::Lockfile::Tokenizer::Token - def self.keyword_init?(); end -end - -class Gem::Requirement - def _sorted_requirements(); end -end - -class Gem::Resolver::APISet::GemParser - def parse(line); end -end - -class Gem::Resolver::APISet::GemParser -end - -class Gem::Resolver::APISpecification - def self.new(set, api_data); end -end - -class Gem::Resolver::ActivationRequest - def eql?(other); end -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::IndexSpecification - def ==(other); end -end - -class Gem::Resolver::InstallerSet - def force(); end - - def force=(force); end -end - -class Gem::Resolver::LocalSpecification -end - -class Gem::Resolver::LocalSpecification -end - -module Gem::Resolver::Molinillo::Delegates::ResolutionState - def unused_unwind_options(); end -end - -module Gem::Resolver::Molinillo::Delegates::SpecificationProvider - def dependencies_equal?(dependencies, other_dependencies); end -end - -class Gem::Resolver::Molinillo::DependencyGraph - include ::Gem::TSort -end - -class Gem::Resolver::Molinillo::DependencyGraph::Edge - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - def add_edge_no_circular(graph, origin, destination, requirement); end - - def add_vertex(graph, name, payload, root); end - - def delete_edge(graph, origin_name, destination_name, requirement); end - - def detach_vertex_named(graph, name); end - - def each(&blk); end - - def pop!(graph); end - - def reverse_each(); end - - def rewind_to(graph, tag); end - - def set_payload(graph, name, payload); end - - def tag(graph, tag); end -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - extend ::Enumerable -end - -class Gem::Resolver::Molinillo::DependencyGraph::Vertex - def _path_to?(other, visited=T.unsafe(nil)); end - - def _recursive_predecessors(vertices=T.unsafe(nil)); end - - def _recursive_successors(vertices=T.unsafe(nil)); end -end - -class Gem::Resolver::Molinillo::ResolutionState - def unused_unwind_options(); end - - def unused_unwind_options=(_); end -end - -class Gem::Resolver::Molinillo::ResolutionState - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict - def possibility_set(); end - - def possibility_set=(_); end - - def underlying_error(); end - - def underlying_error=(_); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet - def dependencies(); end - - def dependencies=(_); end - - def latest_version(); end - - def possibilities(); end - - def possibilities=(_); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails - include ::Comparable - def all_requirements(); end - - def conflicting_requirements(); end - - def conflicting_requirements=(_); end - - def requirement_tree(); end - - def requirement_tree=(_); end - - def requirement_trees(); end - - def requirement_trees=(_); end - - def requirements_unwound_to_instead(); end - - def requirements_unwound_to_instead=(_); end - - def reversed_requirement_tree_index(); end - - def state_index(); end - - def state_index=(_); end - - def state_requirement(); end - - def state_requirement=(_); end - - def sub_dependencies_to_avoid(); end - - def unwinding_to_primary_requirement?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Gem::Resolver::Molinillo::SpecificationProvider - def dependencies_equal?(dependencies, other_dependencies); end -end - -class Gem::Resolver::Molinillo::VersionConflict - include ::Gem::Resolver::Molinillo::Delegates::SpecificationProvider - def message_with_trees(opts=T.unsafe(nil)); end - - def specification_provider(); end -end - -class Gem::Resolver::Specification - def required_ruby_version(); end - - def required_rubygems_version(); end -end - -class Gem::RuntimeRequirementNotMetError - def suggestion(); end - - def suggestion=(suggestion); end -end - -class Gem::RuntimeRequirementNotMetError -end - -class Gem::SpecFetcher - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def available_specs(type); end - - def detect(type=T.unsafe(nil)); end - - def initialize(sources=T.unsafe(nil)); end - - def latest_specs(); end - - def prerelease_specs(); end - - def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def sources(); end - - def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def specs(); end - - def suggest_gems_from_name(gem_name, type=T.unsafe(nil), num_results=T.unsafe(nil)); end - - def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end -end - -class Gem::SpecFetcher - def self.fetcher(); end - - def self.fetcher=(fetcher); end -end - -class Gem::Specification - include ::Bundler::MatchMetadata - include ::Bundler::MatchPlatform - include ::Bundler::GemHelpers - include ::Gem::Specification::YamlBackfiller - def _deprecated_validate_dependencies(); end - - def _deprecated_validate_metadata(); end - - def _deprecated_validate_permissions(); end - - def deleted_gem?(); end - - def flatten_require_paths(); end - - def removed_method_calls(); end - - def to_ruby(); end - LATEST_RUBY_WITHOUT_PATCH_VERSIONS = ::T.let(nil, ::T.untyped) - REMOVED_METHODS = ::T.let(nil, ::T.untyped) -end - -module Gem::Specification::YamlBackfiller - def to_yaml(opts=T.unsafe(nil)); end -end - -module Gem::Specification::YamlBackfiller -end - -class Gem::Specification - extend ::Gem::Deprecate - extend ::Enumerable - def self.add_spec(spec); end - - def self.latest_spec_for(name); end - - def self.remove_spec(spec); end - - def self.stubs_for_pattern(pattern, match_platform=T.unsafe(nil)); end -end - -class Gem::SpecificationPolicy - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def initialize(specification); end - - def packaging(); end - - def packaging=(packaging); end - - def validate(strict=T.unsafe(nil)); end - - def validate_dependencies(); end - - def validate_duplicate_dependencies(); end - - def validate_metadata(); end - - def validate_optional(strict); end - - def validate_permissions(); end - - def validate_required!(); end - HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped) - LAZY = ::T.let(nil, ::T.untyped) - LAZY_PATTERN = ::T.let(nil, ::T.untyped) - METADATA_LINK_KEYS = ::T.let(nil, ::T.untyped) - SPECIAL_CHARACTERS = ::T.let(nil, ::T.untyped) - VALID_NAME_PATTERN = ::T.let(nil, ::T.untyped) - VALID_URI_PATTERN = ::T.let(nil, ::T.untyped) -end - -class Gem::SpecificationPolicy -end - -class Gem::StubSpecification - def build_extensions(); end - - def extensions(); end - - def initialize(filename, base_dir, gems_dir, default_gem); end - - def missing_extensions?(); end - - def valid?(); end -end - -class Gem::StubSpecification::StubLine - def extensions(); end - - def full_name(); end - - def initialize(data, extensions); end - - def name(); end - - def platform(); end - - def require_paths(); end - - def version(); end -end - -class Gem::StubSpecification - def self.default_gemspec_stub(filename, base_dir, gems_dir); end - - def self.gemspec_stub(filename, base_dir, gems_dir); end -end - -module Gem::TSort - def each_strongly_connected_component(&block); end - - def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end - - def strongly_connected_components(); end - - def tsort(); end - - def tsort_each(&block); end - - def tsort_each_child(node); end - - def tsort_each_node(); end -end - -module Gem::TSort - def self.each_strongly_connected_component(each_node, each_child); end - - def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end - - def self.strongly_connected_components(each_node, each_child); end - - def self.tsort(each_node, each_child); end - - def self.tsort_each(each_node, each_child); end -end - -class Gem::UninstallError - def spec(); end - - def spec=(spec); end -end - -class Gem::UninstallError -end - -class Gem::UnknownCommandError - def initialize(unknown_command); end - - def unknown_command(); end -end - -class Gem::UnknownCommandError - def self.attach_correctable(); end -end - -class Gem::UnknownCommandSpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end -end - -class Gem::UnknownCommandSpellChecker -end - -Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError - -module Gem::Util - def self._deprecated_silent_system(*command); end -end - -Gem::Version::Requirement = Gem::Requirement - -module Gem - def self.activated_gem_paths(); end - - def self.cache_home(); end - - def self.config_home(); end - - def self.data_home(); end - - def self.disable_system_update_message(); end - - def self.disable_system_update_message=(disable_system_update_message); end - - def self.find_config_file(); end - - def self.open_file(path, flags, &block); end - - def self.plugin_suffix_pattern(); end - - def self.plugin_suffix_regexp(); end - - def self.plugindir(install_dir=T.unsafe(nil)); end - - def self.solaris_platform?(); end -end - -module GitHub::Actions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class GitHubRunner - def self.inherited(s); end -end - -class Hardware::CPU - def self.lm?(); end -end - -module Hardware - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Hash - include ::JSON::Ext::Generator::GeneratorMethods::Hash - def deconstruct_keys(arg); end -end - -class Hash - def self.ruby2_keywords_hash(arg); end - - def self.ruby2_keywords_hash?(arg); end -end - -module Homebrew::API::Analytics - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Homebrew::Completions::Variables - def aliases(); end - - def aliases=(_); end - - def builtin_command_descriptions(); end - - def builtin_command_descriptions=(_); end - - def completion_functions(); end - - def completion_functions=(_); end - - def function_mappings(); end - - def function_mappings=(_); end -end - -class Homebrew::Completions::Variables - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Homebrew::Completions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::EnvConfig - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Fetch - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::FreePort - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Livecheck::SkipConditions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Parlour - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Homebrew::Service - def on_arch_conditional(arm: T.unsafe(nil), intel: T.unsafe(nil)); end - - def on_arm(&block); end - - def on_big_sur(or_condition=T.unsafe(nil), &block); end - - def on_catalina(or_condition=T.unsafe(nil), &block); end - - def on_el_capitan(or_condition=T.unsafe(nil), &block); end - - def on_high_sierra(or_condition=T.unsafe(nil), &block); end - - def on_intel(&block); end - - def on_linux(&block); end - - def on_macos(&block); end - - def on_mojave(or_condition=T.unsafe(nil), &block); end - - def on_monterey(or_condition=T.unsafe(nil), &block); end - - def on_sierra(or_condition=T.unsafe(nil), &block); end - - def on_sonoma(or_condition=T.unsafe(nil), &block); end - - def on_system(linux, macos:, &block); end - - def on_ventura(or_condition=T.unsafe(nil), &block); end -end - -module Homebrew - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - extend ::FileUtils::StreamUtils_ -end - -module HostEnvironmentSimulatorHelper - def in_its_own_process_with(*files); end -end - -module HostEnvironmentSimulatorHelper -end - -class IO - def beep(); end - - def check_winsize_changed(); end - - def clear_screen(); end - - def console_mode(); end - - def console_mode=(console_mode); end - - def cooked(); end - - def cooked!(); end - - def cursor(); end - - def cursor=(cursor); end - - def cursor_down(arg); end - - def cursor_left(arg); end - - def cursor_right(arg); end - - def cursor_up(arg); end - - def echo=(echo); end - - def echo?(); end - - def erase_line(arg); end - - def erase_screen(arg); end - - def getch(*arg); end - - def getpass(*arg); end - - def goto(arg, arg1); end - - def goto_column(arg); end - - def iflush(); end - - def ioflush(); end - - def noecho(); end - - def nonblock(*arg); end - - def nonblock=(nonblock); end - - def nonblock?(); end - - def nread(); end - - def oflush(); end - - def pathconf(arg); end - - def pressed?(); end - - def raw(*arg); end - - def raw!(*arg); end - - def ready?(); end - - def scroll_backward(arg); end - - def scroll_forward(arg); end - - def wait(*arg); end - - def wait_priority(*arg); end - - def wait_readable(*arg); end - - def wait_writable(*arg); end - - def winsize(); end - - def winsize=(winsize); end - PRIORITY = ::T.let(nil, ::T.untyped) - READABLE = ::T.let(nil, ::T.untyped) - WRITABLE = ::T.let(nil, ::T.untyped) -end - -class IO::Buffer - include ::Comparable - def clear(*arg); end - - def copy(*arg); end - - def empty?(); end - - def external?(); end - - def free(); end - - def get_string(*arg); end - - def get_value(arg, arg1); end - - def hexdump(); end - - def initialize(*arg); end - - def internal?(); end - - def locked(); end - - def locked?(); end - - def mapped?(); end - - def null?(); end - - def pread(arg, arg1, arg2); end - - def pwrite(arg, arg1, arg2); end - - def read(arg, arg1); end - - def readonly?(); end - - def resize(arg); end - - def set_string(*arg); end - - def set_value(arg, arg1, arg2); end - - def size(); end - - def slice(arg, arg1); end - - def transfer(); end - - def valid?(); end - - def write(arg, arg1); end - BIG_ENDIAN = ::T.let(nil, ::T.untyped) - DEFAULT_SIZE = ::T.let(nil, ::T.untyped) - EXTERNAL = ::T.let(nil, ::T.untyped) - HOST_ENDIAN = ::T.let(nil, ::T.untyped) - INTERNAL = ::T.let(nil, ::T.untyped) - LITTLE_ENDIAN = ::T.let(nil, ::T.untyped) - LOCKED = ::T.let(nil, ::T.untyped) - MAPPED = ::T.let(nil, ::T.untyped) - NETWORK_ENDIAN = ::T.let(nil, ::T.untyped) - PAGE_SIZE = ::T.let(nil, ::T.untyped) - PRIVATE = ::T.let(nil, ::T.untyped) - READONLY = ::T.let(nil, ::T.untyped) -end - -class IO::Buffer::AccessError -end - -class IO::Buffer::AccessError -end - -class IO::Buffer::AllocationError -end - -class IO::Buffer::AllocationError -end - -class IO::Buffer::InvalidatedError -end - -class IO::Buffer::InvalidatedError -end - -class IO::Buffer::LockedError -end - -class IO::Buffer::LockedError -end - -class IO::Buffer - def self.for(arg); end - - def self.map(*arg); end -end - -class IO::ConsoleMode - def echo=(echo); end - - def raw(*arg); end - - def raw!(*arg); end -end - -class IO::ConsoleMode -end - -IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable - -IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable - -class IO - def self.console(*arg); end - - def self.console_size(); end - - def self.default_console_size(); end - - def self.new(*arg); end -end - -class IPAddr - def ==(other); end - - def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end - - def netmask(); end - - def zone_id(); end - - def zone_id=(zid); end - VERSION = ::T.let(nil, ::T.untyped) -end - -module IRB - IRBRC_EXT = ::T.let(nil, ::T.untyped) - MagicFile = ::T.let(nil, ::T.untyped) - STDIN_FILE_NAME = ::T.let(nil, ::T.untyped) - TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - 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) - RED = ::T.let(nil, ::T.untyped) - REVERSE = ::T.let(nil, ::T.untyped) - UNDERLINE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - def self.clear(colorable: T.unsafe(nil)); end - - def self.colorable?(); end - - def self.colorize(text, seq, colorable: T.unsafe(nil)); end - - def self.colorize_code(code, complete: T.unsafe(nil), ignore_error: T.unsafe(nil), colorable: T.unsafe(nil)); end - - def self.inspect_colorable?(obj, seen: T.unsafe(nil)); end -end - -class IRB::Context - def __exit__(*arg); end - - def __inspect__(); end - - def __to_s__(); end - - def echo_on_assignment(); end - - def echo_on_assignment=(echo_on_assignment); end - - def echo_on_assignment?(); end - - def evaluate(line, line_no, exception: T.unsafe(nil)); end - - def extra_doc_dirs(); end - - def extra_doc_dirs=(extra_doc_dirs); end - - def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def inspect_last_value(); end - - def newline_before_multiline_output(); end - - def newline_before_multiline_output=(newline_before_multiline_output); end - - def newline_before_multiline_output?(); end - - def use_autocomplete(); end - - def use_autocomplete?(); end - - def use_colorize(); end - - def use_colorize?(); end - - def use_multiline(); end - - def use_multiline?(); end - - def use_reidline(); end - - def use_reidline?(); end - - def use_singleline(); end - - def use_singleline?(); end - IDNAME_IVARS = ::T.let(nil, ::T.untyped) - NOPRINTING_IVARS = ::T.let(nil, ::T.untyped) - NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped) -end - -class IRB::DefaultEncodings - def external(); end - - def external=(_); end - - def internal=(_); end -end - -class IRB::DefaultEncodings - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module IRB::ExtendCommandBundle - def irb(*opts, **kwargs, &b); end - - def irb_change_workspace(*opts, **kwargs, &b); end - - def irb_current_working_workspace(*opts, **kwargs, &b); end - - def irb_fg(*opts, **kwargs, &b); end - - def irb_help(*opts, **kwargs, &b); end - - def irb_info(*opts, **kwargs, &b); end - - def irb_jobs(*opts, **kwargs, &b); end - - def irb_kill(*opts, **kwargs, &b); end - - def irb_ls(*opts, **kwargs, &b); end - - def irb_measure(*opts, **kwargs, &b); end - - def irb_pop_workspace(*opts, **kwargs, &b); end - - def irb_push_workspace(*opts, **kwargs, &b); end - - def irb_show_source(*opts, **kwargs, &b); end - - def irb_source(*opts, **kwargs, &b); end - - def irb_whereami(*opts, **kwargs, &b); end - - def irb_workspaces(*opts, **kwargs, &b); end -end - -IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle - -module IRB::ExtendCommandBundle - def self.irb_original_method_name(method_name); end -end - -class IRB::FileInputMethod - def close(); end - - def initialize(file); end -end - -class IRB::FileInputMethod - def self.open(file, &block); end -end - -module IRB::InputCompletor - BASIC_WORD_BREAK_CHARACTERS = ::T.let(nil, ::T.untyped) - CompletionProc = ::T.let(nil, ::T.untyped) - CompletionRequireProc = ::T.let(nil, ::T.untyped) - Operators = ::T.let(nil, ::T.untyped) - PerfectMatchedProc = ::T.let(nil, ::T.untyped) - ReservedWords = ::T.let(nil, ::T.untyped) -end - -module IRB::InputCompletor - def self.absolute_path?(p); end - - def self.ignored_modules(); end - - def self.retrieve_completion_data(input, bind: T.unsafe(nil), doc_namespace: T.unsafe(nil)); end - - def self.retrieve_files_to_require_from_load_path(); end - - def self.retrieve_files_to_require_relative_from_current_dir(); end - - def self.retrieve_gem_and_system_load_path(); end - - def self.select_message(receiver, message, candidates, sep=T.unsafe(nil)); end -end - -class IRB::InputMethod - def initialize(file=T.unsafe(nil)); end - - def winsize(); end -end - -class IRB::Inspector - def initialize(inspect_proc, init_proc=T.unsafe(nil)); end -end - -class IRB::Irb - def assignment_expression?(line); end - - def convert_invalid_byte_sequence(str, enc); end - - def encode_with_invalid_byte_sequence(str, enc); end - - def handle_exception(exc); end - - def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def output_value(omit=T.unsafe(nil)); end - - def prompt(prompt, ltype, indent, line_no); end - ASSIGNMENT_NODE_TYPES = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale - def String(mes); end - - def encoding(); end - - def find(file, paths=T.unsafe(nil)); end - - def format(*opts); end - - def gets(*rs); end - - def initialize(locale=T.unsafe(nil)); end - - def lang(); end - - def load(file, priv=T.unsafe(nil)); end - - def modifier(); end - - def print(*opts); end - - def printf(*opts); end - - def puts(*opts); end - - def readline(*rs); end - - def require(file, priv=T.unsafe(nil)); end - - def territory(); end - LOCALE_DIR = ::T.let(nil, ::T.untyped) - LOCALE_NAME_RE = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale -end - -class IRB::OutputMethod::NotImplementedError - def initialize(val); end -end - -class IRB::ReadlineInputMethod - def initialize(); end -end - -class IRB::ReadlineInputMethod - def self.initialize_readline(); end -end - -class IRB::ReidlineInputMethod - include ::Reline - def auto_indent(&block); end - - def check_termination(&block); end - - def dynamic_prompt(&block); end - - def encoding(); end - - def eof?(); end - - def initialize(); end - - def line(line_no); end - SHOW_DOC_DIALOG = ::T.let(nil, ::T.untyped) -end - -class IRB::StdioInputMethod - def initialize(); end -end - -class IRB::WorkSpace - def initialize(*main); end - - def local_variable_get(name); end - - def local_variable_set(name, value); end -end - -module IRB - def self.Inspector(inspect, init=T.unsafe(nil)); end - - def self.delete_caller(); end - - def self.init_config(ap_path); end - - def self.init_error(); end - - def self.load_modules(); end - - def self.parse_opts(argv: T.unsafe(nil)); end - - def self.rc_file(ext=T.unsafe(nil)); end - - def self.rc_file_generators(); end - - def self.run_config(); end - - def self.set_measure_callback(type=T.unsafe(nil), arg=T.unsafe(nil), &block); end - - def self.setup(ap_path, argv: T.unsafe(nil)); end - - def self.unset_measure_callback(type=T.unsafe(nil)); end -end - -class Integer - include ::JSON::Ext::Generator::GeneratorMethods::Integer - def to_bn(); end -end - -class Integer - def self.try_convert(arg); end -end - -class JSON::Ext::Generator::State - def escape_slash(); end - - def escape_slash=(escape_slash); end - - def escape_slash?(); end - - def script_safe(); end - - def script_safe=(script_safe); end - - def script_safe?(); end - - def strict(); end - - def strict=(strict); end - - def strict?(); end -end - -class JSON::Ext::Generator::State - def self.from_state(arg); end -end - -class JSON::Ext::Parser - def initialize(*arg); end -end - -JSON::Parser = JSON::Ext::Parser - -JSON::State = JSON::Ext::Generator::State - -JSON::UnparserError = JSON::GeneratorError - -module JSON - def self.create_fast_state(); end - - def self.create_pretty_state(); end -end - -module Kernel - def agree(*args, **arg, &block); end - - def ask(*args, **arg, &block); end - - def choose(*args, **arg, &block); end - - def pretty_inspect(); end - - def say(*args, **arg, &block); end -end - -module Kernel - extend ::Forwardable - def self.at_exit(); end -end - -class KeyError - include ::DidYouMean::Correctable -end - -module Language::Java - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Node::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Node - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Perl::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Python::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Python::Virtualenv - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class LazyObject - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class LinuxRunnerSpec - def self.inherited(s); end -end - -class LoadError - include ::DidYouMean::Correctable -end - -class Logger - def debug!(); end - - def error!(); end - - def fatal!(); end - - def info!(); end - - def warn!(); end - SEV_LABEL = ::T.let(nil, ::T.untyped) -end - -class Logger::Formatter - DatetimeFormat = ::T.let(nil, ::T.untyped) - Format = ::T.let(nil, ::T.untyped) -end - -class Logger::LogDevice - include ::MonitorMixin -end - -module Logger::Period - SiD = ::T.let(nil, ::T.untyped) -end - -class MacOSRunnerSpec - def self.inherited(s); end -end - -class MatchData - def match(arg); end - - def match_length(arg); end -end - -class MessagePack::ExtensionValue - def self.keyword_init?(); end -end - -class MessagePack::Packer - def register_type_internal(arg, arg1, arg2); end - - def reset(); end - - def write_bin(arg); end - - def write_bin_header(arg); end -end - -class MessagePack::Unpacker - def feed_reference(arg); end - - def freeze?(); end -end - -class Method - def private?(); end - - def protected?(); end - - def public?(); end -end - -class Mktemp - include ::FileUtils::StreamUtils_ -end - -class Module - def context(*a, &b); end - - def describe(*a, &b); end - - def example_group(*a, &b); end - - def fcontext(*a, &b); end - - def fdescribe(*a, &b); end - - def shared_context(name, *args, &block); end - - def shared_examples(name, *args, &block); end - - def shared_examples_for(name, *args, &block); end - - def xcontext(*a, &b); end - - def xdescribe(*a, &b); end -end - -class Monitor - def enter(); end - - def exit(); end - - def mon_check_owner(); end - - def mon_enter(); end - - def mon_exit(); end - - def mon_locked?(); end - - def mon_owned?(); end - - def mon_synchronize(); end - - def mon_try_enter(); end - - def new_cond(); end - - def synchronize(); end - - def try_enter(); end - - def try_mon_enter(); end - - def wait_for_cond(arg, arg1); end -end - -module MonitorMixin - def initialize(*arg, **arg1, &arg2); end -end - -class MonitorMixin::ConditionVariable - def initialize(monitor); end -end - -class NameError - include ::ErrorHighlight::CoreExt - include ::DidYouMean::Correctable -end - -class Net::BufferedIO - def write_timeout(); end - - def write_timeout=(write_timeout); end -end - -class Net::HTTP - def extra_chain_cert(); end - - def extra_chain_cert=(extra_chain_cert); end - - def ignore_eof(); end - - def ignore_eof=(ignore_eof); end - - def ipaddr(); end - - def ipaddr=(addr); end - - def max_version(); end - - def max_version=(max_version); end - - def min_version(); end - - def min_version=(min_version); end - - def response_body_encoding(); end - - def response_body_encoding=(value); end - - def verify_hostname(); end - - def verify_hostname=(verify_hostname); end - - def write_timeout(); end - - def write_timeout=(sec); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPAlreadyReported - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPAlreadyReported -end - -Net::HTTPClientErrorCode = Net::HTTPClientError - -class Net::HTTPEarlyHints - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPEarlyHints -end - -Net::HTTPFatalErrorCode = Net::HTTPClientError - -Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError - -Net::HTTPInformationCode = Net::HTTPInformation - -class Net::HTTPLoopDetected - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPLoopDetected -end - -class Net::HTTPMisdirectedRequest - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPMisdirectedRequest -end - -Net::HTTPMovedTemporarily = Net::HTTPFound - -Net::HTTPMultipleChoice = Net::HTTPMultipleChoices - -class Net::HTTPNotExtended - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPNotExtended -end - -class Net::HTTPPayloadTooLarge - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPPayloadTooLarge -end - -class Net::HTTPProcessing - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPProcessing -end - -class Net::HTTPRangeNotSatisfiable - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPRangeNotSatisfiable -end - -Net::HTTPRedirectionCode = Net::HTTPRedirection - -Net::HTTPRequestURITooLarge = Net::HTTPURITooLong - -Net::HTTPResponceReceiver = Net::HTTPResponse - -class Net::HTTPResponse - def body_encoding(); end - - def body_encoding=(value); end - - def ignore_eof(); end - - def ignore_eof=(ignore_eof); end -end - -class Net::HTTPResponse::Inflater - def bytes_inflated(); end -end - -Net::HTTPResponseReceiver = Net::HTTPResponse - -Net::HTTPRetriableCode = Net::HTTPRedirection - -Net::HTTPServerErrorCode = Net::HTTPServerError - -Net::HTTPSession = Net::HTTP - -class Net::HTTPSuccess -end - -Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError - -class Net::HTTPSuccess -end - -class Net::HTTPURITooLong - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPURITooLong -end - -Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError - -class Net::HTTPVariantAlsoNegotiates - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPVariantAlsoNegotiates -end - -Net::NetPrivate::HTTPRequest = Net::HTTPRequest - -Net::NetPrivate::Socket = Net::InternetMessageIO - -Net::ProtocRetryError = Net::ProtoRetriableError - -class Net::Protocol - VERSION = ::T.let(nil, ::T.untyped) -end - -class Net::ReadTimeout - def initialize(io=T.unsafe(nil)); end - - def io(); end -end - -class Net::WriteTimeout - def initialize(io=T.unsafe(nil)); end - - def io(); end -end - -class NilClass - include ::JSON::Ext::Generator::GeneratorMethods::NilClass -end - -class NoMatchingPatternKeyError - include ::DidYouMean::Correctable - def key(); end - - def matchee(); end -end - -class NoMatchingPatternKeyError -end - -module OS::Linux::Glibc - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Linux::Kernel - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Mac::CLT - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Mac::Xcode - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Object - include ::JSON::Ext::Generator::GeneratorMethods::Object - def __send(*arg); end - - def __send!(*arg); end - - def to_yaml(options=T.unsafe(nil)); end - ARGF = ::T.let(nil, ::T.untyped) - ARGV = ::T.let(nil, ::T.untyped) - CROSS_COMPILING = ::T.let(nil, ::T.untyped) - DEPRECATED_OFFICIAL_TAPS = ::T.let(nil, ::T.untyped) - ENV = ::T.let(nil, ::T.untyped) - FORMULA_COMPONENT_PRECEDENCE_LIST = ::T.let(nil, ::T.untyped) - GZIP_BUFFER_SIZE = ::T.let(nil, ::T.untyped) - HOMEBREW_API_DEFAULT_DOMAIN = ::T.let(nil, ::T.untyped) - HOMEBREW_API_WWW = ::T.let(nil, ::T.untyped) - HOMEBREW_BOTTLES_EXTNAME_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_BOTTLE_DEFAULT_DOMAIN = ::T.let(nil, ::T.untyped) - HOMEBREW_BREWED_CURL_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_BREW_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped) - HOMEBREW_BREW_FILE = ::T.let(nil, ::T.untyped) - HOMEBREW_CACHE = ::T.let(nil, ::T.untyped) - HOMEBREW_CACHE_FORMULA = ::T.let(nil, ::T.untyped) - HOMEBREW_CASK_APPDIR_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_CASK_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_CELLAR = ::T.let(nil, ::T.untyped) - HOMEBREW_CELLAR_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_CORE_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped) - HOMEBREW_DATA_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_CACHE = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_LOGS = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_TEMP = ::T.let(nil, ::T.untyped) - HOMEBREW_DOCS_WWW = ::T.let(nil, ::T.untyped) - HOMEBREW_GITHUB_PACKAGES_AUTH = ::T.let(nil, ::T.untyped) - HOMEBREW_HOME_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_LIBRARY = ::T.let(nil, ::T.untyped) - HOMEBREW_LIBRARY_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_LINKED_KEGS = ::T.let(nil, ::T.untyped) - HOMEBREW_LINUX_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_LINUX_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_LOCKS = ::T.let(nil, ::T.untyped) - HOMEBREW_LOGS = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_ARM_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_NEWEST_UNSUPPORTED = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_OLDEST_ALLOWED = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_OLDEST_SUPPORTED = ::T.let(nil, ::T.untyped) - HOMEBREW_MAINTAINER_JSON = ::T.let(nil, ::T.untyped) - HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_PHYSICAL_PROCESSOR = ::T.let(nil, ::T.untyped) - HOMEBREW_PINNED_KEGS = ::T.let(nil, ::T.untyped) - HOMEBREW_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_PREFIX_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_PROCESSOR = ::T.let(nil, ::T.untyped) - HOMEBREW_PRODUCT = ::T.let(nil, ::T.untyped) - HOMEBREW_PULL_API_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_PULL_OR_COMMIT_URL_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_REQUIRED_RUBY_VERSION = ::T.let(nil, ::T.untyped) - HOMEBREW_RUBY_EXEC_ARGS = ::T.let(nil, ::T.untyped) - HOMEBREW_SHIMS_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_SYSTEM = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_DIR_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_FORMULA_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_PATH_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TEMP = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_CURL = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_FAKE_SAFARI = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_RUBY = ::T.let(nil, ::T.untyped) - HOMEBREW_VERSION = ::T.let(nil, ::T.untyped) - HOMEBREW_WWW = ::T.let(nil, ::T.untyped) - LINUXBREW_CORE_MIGRATION_LIST = ::T.let(nil, ::T.untyped) - OFFICIAL_CASK_TAPS = ::T.let(nil, ::T.untyped) - OFFICIAL_CMD_TAPS = ::T.let(nil, ::T.untyped) - OS_VERSION = ::T.let(nil, ::T.untyped) - PATCH_A_SHA256 = ::T.let(nil, ::T.untyped) - PATCH_B_SHA256 = ::T.let(nil, ::T.untyped) - RUBY18 = ::T.let(nil, ::T.untyped) - RUBY19 = ::T.let(nil, ::T.untyped) - RUBY_BIN = ::T.let(nil, ::T.untyped) - RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped) - RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped) - RUBY_ENGINE = ::T.let(nil, ::T.untyped) - RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped) - RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped) - RUBY_PATH = ::T.let(nil, ::T.untyped) - RUBY_PLATFORM = ::T.let(nil, ::T.untyped) - RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped) - RUBY_REVISION = ::T.let(nil, ::T.untyped) - RUBY_VERSION = ::T.let(nil, ::T.untyped) - STDERR = ::T.let(nil, ::T.untyped) - STDIN = ::T.let(nil, ::T.untyped) - STDOUT = ::T.let(nil, ::T.untyped) - TESTBALL_PATCHES_SHA256 = ::T.let(nil, ::T.untyped) - TESTBALL_SHA256 = ::T.let(nil, ::T.untyped) - TEST_FIXTURE_DIR = ::T.let(nil, ::T.untyped) - TEST_SHA256 = ::T.let(nil, ::T.untyped) - TEST_TMPDIR = ::T.let(nil, ::T.untyped) - TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) -end - -class Object - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - extend ::MacOSVersionErrorCompat - def self.hpricot_slate_method_added(name); end - - def self.yaml_tag(url); end -end - -module OnSystem::MacOSAndLinux - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OnSystem::MacOSOnly - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OnSystem - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Open3 - VERSION = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::ASN1::ASN1Data - def indefinite_length(); end - - def indefinite_length=(indefinite_length); end -end - -class OpenSSL::BN - def +@(); end - - def -@(); end - - def /(arg); end - - def abs(); end - - def get_flags(arg); end - - def negative?(); end - - def set_flags(arg); end - CONSTTIME = ::T.let(nil, ::T.untyped) -end - -module OpenSSL::Buffering - def getbyte(); end -end - -class OpenSSL::Buffering::Buffer - def <<(string); end - - def concat(string); end - - def initialize(); end - BINARY = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::Buffering::Buffer -end - -class OpenSSL::Cipher - def ccm_data_len=(ccm_data_len); end -end - -class OpenSSL::HMAC - def ==(other); end - - def base64digest(); end -end - -class OpenSSL::HMAC - def self.base64digest(digest, key, data); end -end - -module OpenSSL::Marshal - def _dump(_level); end -end - -module OpenSSL::Marshal::ClassMethods - def _load(string); end -end - -module OpenSSL::Marshal::ClassMethods -end - -module OpenSSL::Marshal - def self.included(base); end -end - -class OpenSSL::OCSP::Request - def signed?(); end -end - -OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo - -class OpenSSL::PKey::DH - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::DH - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -class OpenSSL::PKey::DSA - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::DSA - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -class OpenSSL::PKey::EC - include ::OpenSSL::Marshal - EXPLICIT_CURVE = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::PKey::EC::Point - def add(arg); end - - def to_octet_string(arg); end -end - -class OpenSSL::PKey::EC - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::PKey::PKey - def compare?(arg); end - - def decrypt(*arg); end - - def derive(*arg); end - - def encrypt(*arg); end - - def oid(); end - - def private_to_der(*arg); end - - def private_to_pem(*arg); end - - def public_to_der(); end - - def public_to_pem(); end - - def sign_raw(*arg); end - - def to_text(); end - - def verify_raw(*arg); end - - def verify_recover(*arg); end -end - -class OpenSSL::PKey::RSA - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::RSA - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -module OpenSSL::PKey - def self.generate_key(*arg); end - - def self.generate_parameters(*arg); end -end - -module OpenSSL::SSL - OP_ALLOW_CLIENT_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped) - OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_CLEANSE_PLAINTEXT = ::T.let(nil, ::T.untyped) - OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped) - OP_DISABLE_TLSEXT_CA_NAMES = ::T.let(nil, ::T.untyped) - OP_ENABLE_KTLS = ::T.let(nil, ::T.untyped) - OP_ENABLE_MIDDLEBOX_COMPAT = ::T.let(nil, ::T.untyped) - OP_IGNORE_UNEXPECTED_EOF = ::T.let(nil, ::T.untyped) - OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped) - OP_NO_ANTI_REPLAY = ::T.let(nil, ::T.untyped) - OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped) - OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped) - OP_PRIORITIZE_CHACHA = ::T.let(nil, ::T.untyped) - OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped) - OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped) - SSL2_VERSION = ::T.let(nil, ::T.untyped) - SSL3_VERSION = ::T.let(nil, ::T.untyped) - TLS1_1_VERSION = ::T.let(nil, ::T.untyped) - TLS1_2_VERSION = ::T.let(nil, ::T.untyped) - TLS1_3_VERSION = ::T.let(nil, ::T.untyped) - TLS1_VERSION = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLContext - def alpn_protocols(); end - - def alpn_protocols=(alpn_protocols); end - - def alpn_select_cb(); end - - def alpn_select_cb=(alpn_select_cb); end - - def enable_fallback_scsv(); end - - def max_version=(version); end - - def min_version=(version); end - - def tmp_dh=(tmp_dh); end - DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLSocket - def alpn_protocol(); end - - def finished_message(); end - - def peer_finished_message(); end - - def tmp_key(); end -end - -class OpenSSL::SSL::SSLSocket - def self.open(remote_host, remote_port, local_host=T.unsafe(nil), local_port=T.unsafe(nil), context: T.unsafe(nil)); end -end - -module OpenSSL::SSL::SocketForwarder - def fileno(); end -end - -module OpenSSL::Timestamp -end - -class OpenSSL::Timestamp::Factory - def additional_certs(); end - - def additional_certs=(additional_certs); end - - def allowed_digests(); end - - def allowed_digests=(allowed_digests); end - - def create_timestamp(arg, arg1, arg2); end - - def default_policy_id(); end - - def default_policy_id=(default_policy_id); end - - def gen_time(); end - - def gen_time=(gen_time); end - - def serial_number(); end - - def serial_number=(serial_number); end -end - -class OpenSSL::Timestamp::Factory -end - -class OpenSSL::Timestamp::Request - def algorithm(); end - - def algorithm=(algorithm); end - - def cert_requested=(cert_requested); end - - def cert_requested?(); end - - def initialize(*arg); end - - def message_imprint(); end - - def message_imprint=(message_imprint); end - - def nonce(); end - - def nonce=(nonce); end - - def policy_id(); end - - def policy_id=(policy_id); end - - def to_der(); end - - def version(); end - - def version=(version); end -end - -class OpenSSL::Timestamp::Request -end - -class OpenSSL::Timestamp::Response - def failure_info(); end - - def initialize(arg); end - - def status(); end - - def status_text(); end - - def to_der(); end - - def token(); end - - def token_info(); end - - def tsa_certificate(); end - - def verify(*arg); end - GRANTED = ::T.let(nil, ::T.untyped) - GRANTED_WITH_MODS = ::T.let(nil, ::T.untyped) - REJECTION = ::T.let(nil, ::T.untyped) - REVOCATION_NOTIFICATION = ::T.let(nil, ::T.untyped) - REVOCATION_WARNING = ::T.let(nil, ::T.untyped) - WAITING = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::Timestamp::Response -end - -class OpenSSL::Timestamp::TimestampError -end - -class OpenSSL::Timestamp::TimestampError -end - -class OpenSSL::Timestamp::TokenInfo - def algorithm(); end - - def gen_time(); end - - def initialize(arg); end - - def message_imprint(); end - - def nonce(); end - - def ordering(); end - - def policy_id(); end - - def serial_number(); end - - def to_der(); end - - def version(); end -end - -class OpenSSL::Timestamp::TokenInfo -end - -module OpenSSL::Timestamp -end - -module OpenSSL::X509 - V_ERR_CA_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_CA_MD_TOO_WEAK = ::T.let(nil, ::T.untyped) - V_ERR_CRL_PATH_VALIDATION_ERROR = ::T.let(nil, ::T.untyped) - V_ERR_DANE_NO_MATCH = ::T.let(nil, ::T.untyped) - V_ERR_DIFFERENT_CRL_SCOPE = ::T.let(nil, ::T.untyped) - V_ERR_EE_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_EMAIL_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_EXCLUDED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_HOSTNAME_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_CALL = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_NON_CA = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_POLICY_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_IP_ADDRESS_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_CRL_SIGN = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = ::T.let(nil, ::T.untyped) - V_ERR_NO_EXPLICIT_POLICY = ::T.let(nil, ::T.untyped) - V_ERR_NO_VALID_SCTS = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_CERT_UNKNOWN = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_FAILED = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_NEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PATH_LOOP = ::T.let(nil, ::T.untyped) - V_ERR_PERMITTED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_PATH_LENGTH_EXCEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_SUBJECT_NAME_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_STORE_LOOKUP = ::T.let(nil, ::T.untyped) - V_ERR_SUBTREE_MINMAX = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_CURVE = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_VERSION = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_LOS_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_UNABLE_TO_GET_CRL_ISSUER = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNNESTED_RESOURCE = ::T.let(nil, ::T.untyped) - V_ERR_UNSPECIFIED = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_TYPE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_EXTENSION_FEATURE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_NAME_SYNTAX = ::T.let(nil, ::T.untyped) - V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped) - V_FLAG_PARTIAL_CHAIN = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS_ONLY = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_192_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped) - V_FLAG_USE_CHECK_TIME = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::X509::Attribute - include ::OpenSSL::Marshal - def ==(other); end -end - -class OpenSSL::X509::Attribute - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::CRL - include ::OpenSSL::Marshal - include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def ==(other); end -end - -class OpenSSL::X509::CRL - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Certificate - include ::OpenSSL::Marshal - include ::OpenSSL::X509::Extension::SubjectKeyIdentifier - include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::CRLDistributionPoints - include ::OpenSSL::X509::Extension::AuthorityInfoAccess - include ::OpenSSL::X509::Extension::Helpers -end - -class OpenSSL::X509::Certificate - extend ::OpenSSL::Marshal::ClassMethods - def self.load(arg); end - - def self.load_file(path); end -end - -class OpenSSL::X509::Extension - include ::OpenSSL::Marshal - def ==(other); end - - def value_der(); end -end - -module OpenSSL::X509::Extension::AuthorityInfoAccess - include ::OpenSSL::X509::Extension::Helpers - def ca_issuer_uris(); end - - def ocsp_uris(); end -end - -module OpenSSL::X509::Extension::AuthorityInfoAccess -end - -module OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def authority_key_identifier(); end -end - -module OpenSSL::X509::Extension::AuthorityKeyIdentifier -end - -module OpenSSL::X509::Extension::CRLDistributionPoints - include ::OpenSSL::X509::Extension::Helpers - def crl_uris(); end -end - -module OpenSSL::X509::Extension::CRLDistributionPoints -end - -module OpenSSL::X509::Extension::Helpers - def find_extension(oid); end -end - -module OpenSSL::X509::Extension::Helpers -end - -module OpenSSL::X509::Extension::SubjectKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def subject_key_identifier(); end -end - -module OpenSSL::X509::Extension::SubjectKeyIdentifier -end - -class OpenSSL::X509::Extension - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Name - include ::OpenSSL::Marshal - def to_utf8(); end -end - -class OpenSSL::X509::Name - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Request - include ::OpenSSL::Marshal - def ==(other); end -end - -class OpenSSL::X509::Request - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Revoked - def ==(other); end - - def to_der(); end -end - -module OpenSSL - def self.fips_mode(); end -end - -class OpenStruct - def __id__!(); end - - def __send__!(*arg); end - - def class!(); end - - def clone!(freeze: T.unsafe(nil)); end - - def define_singleton_method!(*arg); end - - def delete_field!(name); end - - def dig!(name, *names); end - - def display!(*arg); end - - def dup!(); end - - def each_pair!(); end - - def encode_with(coder); end - - def encode_with!(coder); end - - def enum_for!(*arg); end - - def extend!(mod, *args); end - - def freeze!(); end - - def gem!(dep, *reqs); end - - def hash!(); end - - def init_with(coder); end - - def init_with!(coder); end - - def inspect!(); end - - def instance_eval!(*arg); end - - def instance_exec!(*arg); end - - def instance_variable_get!(arg); end - - def instance_variable_set!(arg, arg1); end - - def instance_variables!(); end - - def itself!(); end - - def marshal_dump!(); end - - def method!(arg); end - - def methods!(*arg); end - - def object_id!(); end - - def private_methods!(*arg); end - - def protected_methods!(*arg); end - - def public_method!(arg); end - - def public_methods!(*arg); end - - def public_send!(*arg); end - - def remove_instance_variable!(arg); end - - def send!(*arg); end - - def singleton_class!(); end - - def singleton_method!(arg); end - - def singleton_methods!(*arg); end - - def taint!(); end - - def tap!(); end - - def then!(); end - - def to_enum!(*arg); end - - def to_h!(&block); end - - def to_s!(); end - - def trust!(); end - - def untaint!(); end - - def untrust!(); end - - def yield_self!(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class OptionParser - def additional_message(typ, opt); end - - def require_exact(); end - - def require_exact=(require_exact); end - Version = ::T.let(nil, ::T.untyped) -end - -class OptionParser::List - def get_candidates(id); end -end - -class OptionParser::ParseError - def additional(); end - - def additional=(additional); end -end - -class PP - def self.width_for(out); end -end - -class Parlour::Conversion::Converter - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Parlour::Debugging - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Parlour::Mixin::Searchable - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Parlour::Plugin - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Parlour::TypeLoader - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Parlour::TypedObject - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Parlour::Types::Type - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Proc - def <<(arg); end - - def >>(arg); end - - def clone(); end -end - -class Process::Status - def self.wait(*arg); end -end - -class Process::Tms - def self.keyword_init?(); end -end - -module Process - def self._fork(); end -end - -module Psych - VERSION = ::T.let(nil, ::T.untyped) -end - -class Psych::ScalarScanner - INTEGER_LEGACY = ::T.let(nil, ::T.untyped) - INTEGER_STRICT = ::T.let(nil, ::T.untyped) -end - -class Psych::Visitors::RestrictedYAMLTree - def visit_Symbol(sym); end - DEFAULT_PERMITTED_CLASSES = ::T.let(nil, ::T.untyped) -end - -class Psych::Visitors::RestrictedYAMLTree -end - -class Psych::Visitors::Visitor - def self.dispatch_cache(); end -end - -module Psych - def self.add_builtin_type(type_tag, &block); end - - def self.add_domain_type(domain, type_tag, &block); end - - def self.add_tag(tag, klass); end - - def self.config(); end - - def self.domain_types(*args, **arg, &block); end - - def self.domain_types=(*args, **arg, &block); end - - def self.dump_tags(*args, **arg, &block); end - - def self.dump_tags=(*args, **arg, &block); end - - def self.libyaml_version(); end - - def self.load_tags(*args, **arg, &block); end - - def self.load_tags=(*args, **arg, &block); end - - def self.remove_type(type_tag); end - - def self.safe_dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.unsafe_load(yaml, filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil), freeze: T.unsafe(nil), strict_integer: T.unsafe(nil)); end - - def self.unsafe_load_file(filename, **kwargs); end -end - -module PyPI - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RBI::Index - include ::T::Enumerable -end - -module RBI::Indexable - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RBI::Node - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class RBI::Visitor - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class RDoc::Alias - def initialize(text, old_name, new_name, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::AnyMethod - def _call_seq(); end - - def section_title(); end - - def section_title=(section_title); end -end - -class RDoc::Attr - def initialize(text, name, rw, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::ClassModule - def initialize(name, superclass=T.unsafe(nil)); end -end - -class RDoc::CodeObject - def initialize_visibility(); end -end - -class RDoc::Comment - def initialize(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end - - def line(); end - - def line=(line); end -end - -class RDoc::Constant - def initialize(name, value, comment); end -end - -class RDoc::Context - def add_module_by_normal_module(mod); end - - def initialize_methods_etc(); end - - def instance_methods(); end -end - -class RDoc::Context::Section - def initialize(parent, title, comment); end -end - -class RDoc::CrossReference - def initialize(context); end - - def resolve_method(name); end -end - -module RDoc::Encoding - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -module RDoc::Encoding - def self.detect_encoding(string); end - - def self.remove_magic_comment(string); end -end - -class RDoc::Generator::Darkfish - def initialize(store, options); end -end - -class RDoc::Generator::JsonIndex - def initialize(parent_generator, options); end -end - -class RDoc::Generator::POT - def initialize(store, options); end -end - -class RDoc::Generator::POT::MessageExtractor - def initialize(store); end -end - -class RDoc::Generator::POT::POEntry - def initialize(msgid, options=T.unsafe(nil)); end -end - -class RDoc::Generator::RI - def initialize(store, options); end -end - -class RDoc::I18n::Locale - def initialize(name); end -end - -class RDoc::I18n::Text - def initialize(raw); end -end - -class RDoc::Markdown - def _Table(); end - - def _TableColumn(); end - - def _TableItem(); end - - def _TableLine(); end - - def _TableRow(); end - - def initialize(extensions=T.unsafe(nil), debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals - def initialize(str, debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::Literals::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markdown::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markup - def add_regexp_handling(pattern, name); end - - def initialize(attribute_manager=T.unsafe(nil)); end -end - -class RDoc::Markup::AttrChanger - def self.keyword_init?(); end -end - -class RDoc::Markup::AttrSpan - def initialize(length, exclusive); end -end - -class RDoc::Markup::AttributeManager - def add_regexp_handling(pattern, name, exclusive=T.unsafe(nil)); end - - def convert_attrs_matching_word_pairs(str, attrs, exclusive); end - - def convert_attrs_word_pair_map(str, attrs, exclusive); end - - def convert_regexp_handlings(str, attrs, exclusive=T.unsafe(nil)); end - - def exclusive?(attr); end - - def exclusive_bitmap(); end - - def regexp_handlings(); end - NON_PRINTING_END = ::T.let(nil, ::T.untyped) - NON_PRINTING_START = ::T.let(nil, ::T.untyped) -end - -class RDoc::Markup::Attributes - def regexp_handling(); end -end - -class RDoc::Markup::Document - def initialize(*parts); end -end - -class RDoc::Markup::Formatter - def add_regexp_handling_RDOCLINK(); end - - def add_regexp_handling_TIDYLINK(); end - - def convert_regexp_handling(target); end - - def initialize(options, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::Formatter::InlineTag - def self.keyword_init?(); end -end - -class RDoc::Markup::Heading - def self.keyword_init?(); end -end - -class RDoc::Markup::Include - def initialize(file, include_path); end -end - -class RDoc::Markup::IndentedParagraph - def initialize(indent, *parts); end -end - -class RDoc::Markup::List - def initialize(type=T.unsafe(nil), *items); end -end - -class RDoc::Markup::ListItem - def initialize(label=T.unsafe(nil), *parts); end -end - -class RDoc::Markup::Parser::MyStringScanner - def [](i); end - - def eos?(); end - - def initialize(input); end - - def matched(); end - - def newline!(); end - - def pos(); end - - def scan(re); end - - def unscan(s); end -end - -class RDoc::Markup::Parser::MyStringScanner -end - -class RDoc::Markup::PreProcess - def initialize(input_file_name, include_path); end -end - -class RDoc::Markup::Raw - def initialize(*parts); end -end - -class RDoc::Markup::RegexpHandling - def ==(o); end - - def initialize(type, text); end - - def text(); end - - def text=(text); end - - def type(); end -end - -class RDoc::Markup::RegexpHandling -end - -class RDoc::Markup::Table - def ==(other); end - - def accept(visitor); end - - def align(); end - - def align=(align); end - - def body(); end - - def body=(body); end - - def header(); end - - def header=(header); end - - def initialize(header, align, body); end -end - -class RDoc::Markup::Table -end - -class RDoc::Markup::ToHtml - def accept_table(header, body, aligns); end - - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_HYPERLINK(target); end - - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end - - def init_link_notation_regexp_handlings(); end - - def init_regexp_handlings(); end -end - -class RDoc::Markup::ToHtmlCrossref - def handle_regexp_CROSSREF(target); end - - def initialize(options, from_path, context, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToHtmlSnippet - def handle_regexp_CROSSREF(target); end - - def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToJoinedParagraph - def accept_table(*node); end - - def initialize(); end -end - -class RDoc::Markup::ToLabel - def handle_regexp_CROSSREF(target); end - - def handle_regexp_HARD_BREAK(*node); end - - def handle_regexp_TIDYLINK(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToMarkdown - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end -end - -class RDoc::Markup::ToRdoc - def accept_table(header, body, aligns); end - - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_SUPPRESSED_CROSSREF(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToTableOfContents - def accept_table(*node); end - - def initialize(); end -end - -class RDoc::Markup::ToTtOnly - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::MethodAttr - def initialize(text, name); end -end - -class RDoc::Mixin - def initialize(name, comment); end -end - -class RDoc::Options - def initialize(loaded_options=T.unsafe(nil)); end - - def override(map); end -end - -class RDoc::Options - def self.load_options(); end -end - -class RDoc::Parser - def initialize(top_level, file_name, content, options, stats); end -end - -class RDoc::Parser::C - def add_alias(var_name, class_obj, old_name, new_name, comment); end - - def do_classes_and_modules(); end - - def new_comment(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end -end - -class RDoc::Parser::ChangeLog - def parse_date(date); end -end - -module RDoc::Parser::ChangeLog::Git - def create_entries(entries); end - - def parse_entries(); end - - def parse_info(info); end - HEADING_LEVEL = ::T.let(nil, ::T.untyped) -end - -class RDoc::Parser::ChangeLog::Git::LogEntry - def accept(visitor); end - - def aref(); end - - def author(); end - - def author=(_); end - - def base(); end - - def base=(_); end - - def commit(); end - - def commit=(_); end - - def contents(); end - - def contents=(_); end - - def date(); end - - def date=(_); end - - def email(); end - - def email=(_); end - - def initialize(base, commit, author, email, date, contents); end - - def label(context=T.unsafe(nil)); end - - def level(); end - - def text(); end -end - -class RDoc::Parser::ChangeLog::Git::LogEntry - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module RDoc::Parser::ChangeLog::Git -end - -class RDoc::Parser::RipperStateLex - def get_squashed_tk(); end - - def initialize(code); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - RIPPER_HAS_LEX_STATE = ::T.let(nil, ::T.untyped) -end - -class RDoc::Parser::RipperStateLex::InnerStateLex - def initialize(code); end - - def on_default(event, tok, data); end -end - -class RDoc::Parser::RipperStateLex::InnerStateLex -end - -class RDoc::Parser::RipperStateLex::Token - def char_no(); end - - def char_no=(_); end - - def kind(); end - - def kind=(_); end - - def line_no(); end - - def line_no=(_); end - - def state(); end - - def state=(_); end - - def text(); end - - def text=(_); end -end - -class RDoc::Parser::RipperStateLex::Token - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class RDoc::Parser::RipperStateLex - def self.end?(token); end - - def self.parse(code); end -end - -class RDoc::Parser::Ruby - def get_included_module_with_optional_parens(); end - - def parse_included_with_activesupport_concern(container, comment); end - - def retrieve_comment_body(tk); end -end - -module RDoc::Parser::RubyTools - def skip_tkspace_without_nl(); end -end - -class RDoc::RD::BlockParser - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RD::Inline - def initialize(rdoc, reference); end -end - -class RDoc::RD::InlineParser - def initialize(block_parser); end - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RI::Driver - def initialize(initial_options=T.unsafe(nil)); end -end - -class RDoc::RI::Driver::NotFoundError - def initialize(klass, suggestions=T.unsafe(nil)); end -end - -RDoc::RI::Store = RDoc::Store - -class RDoc::Require - def initialize(name, comment); end -end - -class RDoc::Stats - def initialize(store, num_files, verbosity=T.unsafe(nil)); end -end - -class RDoc::Stats::Quiet - def initialize(num_files); end -end - -class RDoc::Store - def initialize(path=T.unsafe(nil), type=T.unsafe(nil)); end - - def unmatched_constant_alias(); end - - def update_parser_of_file(absolute_name, parser); end -end - -class RDoc::Store::MissingFileError - def initialize(store, file, name); end -end - -module RDoc::Text - def language(); end - - def language=(language); end -end - -class RDoc::TopLevel - def initialize(absolute_name, relative_name=T.unsafe(nil)); end -end - -module RDoc - def self.home(); end -end - -class RSpec::Core::ExampleGroup - include ::RSpec::Core::MockingAdapters::RSpec - include ::RSpec::Mocks::ExampleMethods - include ::RSpec::Mocks::ArgumentMatchers - include ::RSpec::Mocks::ExampleMethods::ExpectHost - include ::RSpec::Matchers -end - -module RSpec::Core::HashImitatable - def assert_valid_keys(*args, &block); end - - def compact_blank(*args, &block); end - - def deep_merge(*args, &block); end - - def deep_merge!(*args, &block); end - - def deep_stringify_keys(*args, &block); end - - def deep_stringify_keys!(*args, &block); end - - def deep_symbolize_keys(*args, &block); end - - def deep_symbolize_keys!(*args, &block); end - - def deep_transform_keys(*args, &block); end - - def deep_transform_keys!(*args, &block); end - - def deep_transform_values(*args, &block); end - - def deep_transform_values!(*args, &block); end - - def exclude?(*args, &block); end - - def save_plist(*args, &block); end - - def to_plist(*args, &block); end -end - -module RSpec::Core::MockingAdapters -end - -module RSpec::Core::MockingAdapters::RSpec - include ::RSpec::Mocks::ExampleMethods - include ::RSpec::Mocks::ArgumentMatchers - include ::RSpec::Mocks::ExampleMethods::ExpectHost - def setup_mocks_for_rspec(); end - - def teardown_mocks_for_rspec(); end - - def verify_mocks_for_rspec(); end -end - -module RSpec::Core::MockingAdapters::RSpec - def self.configuration(); end - - def self.framework_name(); end -end - -module RSpec::Core::MockingAdapters -end - -class RSpec::Core::OutputWrapper - def readline_nonblock(*args, &block); end -end - -class RSpec::Expectations::MultipleExpectationsNotMetError - include ::RSpec::Core::MultipleExceptionError::InterfaceTag -end - -module RSpec::Sorbet::Doubles - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Racc::CparseParams -end - -class Racc::CparseParams -end - -class Ractor::ClosedError -end - -class Ractor::ClosedError -end - -class Ractor::Error -end - -class Ractor::Error -end - -class Ractor::IsolationError -end - -class Ractor::IsolationError -end - -class Ractor::MovedError -end - -class Ractor::MovedError -end - -class Ractor::MovedObject - def !(*arg); end - - def !=(*arg); end - - def ==(*arg); end - - def __id__(*arg); end - - def equal?(*arg); end -end - -class Ractor::MovedObject -end - -class Ractor::RemoteError - def ractor(); end -end - -class Ractor::RemoteError -end - -class Ractor::UnsafeError -end - -class Ractor::UnsafeError -end - -class Ractor - def self.new(*args, name: T.unsafe(nil), &block); end -end - -class Random::Base - include ::Random::Formatter - def bytes(arg); end - - def initialize(*arg); end - - def seed(); end -end - -class Random::Base - extend ::Random::Formatter -end - -class Random - def self.bytes(arg); end - - def self.seed(); end -end - -class Range - def %(arg); end - - def entries(); end - - def to_a(); end -end - -module RbConfig - def self.expand(val, config=T.unsafe(nil)); end - - def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end -end - -module Reline - DEFAULT_DIALOG_CONTEXT = ::T.let(nil, ::T.untyped) - DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ::T.let(nil, ::T.untyped) - FILENAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - HISTORY = ::T.let(nil, ::T.untyped) - USERNAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Reline::Config - KEYSEQ_PATTERN = ::T.let(nil, ::T.untyped) - VARIABLE_NAMES = ::T.let(nil, ::T.untyped) - VARIABLE_NAME_SYMBOLS = ::T.let(nil, ::T.untyped) -end - -class Reline::Core - ATTR_READER_NAMES = ::T.let(nil, ::T.untyped) -end - -Reline::IOGate = Reline::GeneralIO - -Reline::Key = Struct::Key - -class Reline::KeyActor::Base - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::Emacs - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViCommand - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViInsert - MAPPING = ::T.let(nil, ::T.untyped) -end - -module Reline::KillRing::State - CONTINUED = ::T.let(nil, ::T.untyped) - FRESH = ::T.let(nil, ::T.untyped) - PROCESSED = ::T.let(nil, ::T.untyped) - YANK = ::T.let(nil, ::T.untyped) -end - -class Reline::LineEditor - DIALOG_DEFAULT_HEIGHT = ::T.let(nil, ::T.untyped) - PROMPT_LIST_CACHE_TIMEOUT = ::T.let(nil, ::T.untyped) - VI_MOTIONS = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::CompletionJourneyData = Struct::CompletionJourneyData - -module Reline::LineEditor::CompletionState - COMPLETION = ::T.let(nil, ::T.untyped) - JOURNEY = ::T.let(nil, ::T.untyped) - MENU = ::T.let(nil, ::T.untyped) - MENU_WITH_PERFECT_MATCH = ::T.let(nil, ::T.untyped) - NORMAL = ::T.let(nil, ::T.untyped) - PERFECT_MATCH = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::MenuInfo = Struct::MenuInfo - -module Reline::Terminfo - extend ::Fiddle - extend ::Fiddle::CParser -end - -class Reline::Unicode - CSI_REGEXP = ::T.let(nil, ::T.untyped) - CSI_REGEXP_INDEX = ::T.let(nil, ::T.untyped) - EscapedChars = ::T.let(nil, ::T.untyped) - EscapedPairs = ::T.let(nil, ::T.untyped) - GRAPHEME_CLUSTER_INDEX = ::T.let(nil, ::T.untyped) - HalfwidthDakutenHandakuten = ::T.let(nil, ::T.untyped) - MBCharWidthRE = ::T.let(nil, ::T.untyped) - NON_PRINTING_END = ::T.let(nil, ::T.untyped) - NON_PRINTING_END_INDEX = ::T.let(nil, ::T.untyped) - NON_PRINTING_START = ::T.let(nil, ::T.untyped) - NON_PRINTING_START_INDEX = ::T.let(nil, ::T.untyped) - OSC_REGEXP = ::T.let(nil, ::T.untyped) - OSC_REGEXP_INDEX = ::T.let(nil, ::T.untyped) - WIDTH_SCANNER = ::T.let(nil, ::T.untyped) -end - -class Reline::Unicode::EastAsianWidth - TYPE_A = ::T.let(nil, ::T.untyped) - TYPE_F = ::T.let(nil, ::T.untyped) - TYPE_H = ::T.let(nil, ::T.untyped) - TYPE_N = ::T.let(nil, ::T.untyped) - TYPE_NA = ::T.let(nil, ::T.untyped) - TYPE_W = ::T.let(nil, ::T.untyped) -end - -class Requirements - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Requirements - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Resolv::DNS - def extract_resources(msg, name, typeclass); end - RequestID = ::T.let(nil, ::T.untyped) - RequestIDMutex = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Config - def initialize(config_info=T.unsafe(nil)); end -end - -class Resolv::DNS::Label::Str - def initialize(string); end -end - -class Resolv::DNS::Message - def initialize(id=T.unsafe(nil)); end -end - -class Resolv::DNS::Message::MessageDecoder - def initialize(data); end -end - -class Resolv::DNS::Requester::ConnectedUDP - def initialize(host, port=T.unsafe(nil)); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::Sender - def initialize(msg, data, sock); end -end - -class Resolv::DNS::Requester::TCP - def initialize(host, port=T.unsafe(nil)); end -end - -class Resolv::DNS::Requester::UnconnectedUDP - def initialize(*nameserver_port); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::UnconnectedUDP::Sender - def initialize(msg, data, sock, host, port); end -end - -class Resolv::DNS::Resource - ClassValue = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Resource::LOC - def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end -end - -class Resolv::DNS - def self.allocate_request_id(host, port); end - - def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end - - def self.free_request_id(host, port, id); end - - def self.random(arg); end -end - -class Resolv::IPv6 - Regex_8HexLinkLocal = ::T.let(nil, ::T.untyped) - Regex_CompressedHexLinkLocal = ::T.let(nil, ::T.untyped) -end - -class Ripper - def column(); end - - def debug_output(); end - - def debug_output=(debug_output); end - - def encoding(); end - - def end_seen?(); end - - def error?(); end - - def filename(); end - - def initialize(*arg); end - - def lineno(); end - - def parse(); end - - def state(); end - - def token(); end - - def yydebug(); end - - def yydebug=(yydebug); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Ripper::Filter - def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end -end - -class Ripper::Lexer - def errors(); end - - def lex(**kw); end - - def parse(raise_errors: T.unsafe(nil)); end - - def scan(**kw); end - - def tokenize(**kw); end -end - -class Ripper::Lexer::Elem - def [](index); end - - def event(); end - - def event=(event); end - - def initialize(pos, event, tok, state, message=T.unsafe(nil)); end - - def message(); end - - def message=(message); end - - def pos(); end - - def pos=(pos); end - - def state(); end - - def state=(state); end - - def to_a(); end - - def tok(); end - - def tok=(tok); end -end - -class Ripper::Lexer::Elem -end - -class Ripper::Lexer::State - def &(i); end - - def ==(i); end - - def [](index); end - - def allbits?(i); end - - def anybits?(i); end - - def initialize(i); end - - def nobits?(i); end - - def to_i(); end - - def to_int(); end - - def |(i); end -end - -class Ripper::Lexer::State -end - -class Ripper::Lexer -end - -class Ripper::SexpBuilder - def on_BEGIN(*args); end - - def on_CHAR(tok); end - - def on_END(*args); end - - def on___end__(tok); end - - def on_alias(*args); end - - def on_alias_error(*args); end - - def on_aref(*args); end - - def on_aref_field(*args); end - - def on_arg_ambiguous(*args); end - - def on_arg_paren(*args); end - - def on_args_add(*args); end - - def on_args_add_block(*args); end - - def on_args_add_star(*args); end - - def on_args_forward(*args); end - - def on_args_new(*args); end - - def on_array(*args); end - - def on_aryptn(*args); end - - def on_assign(*args); end - - def on_assign_error(*args); end - - def on_assoc_new(*args); end - - def on_assoc_splat(*args); end - - def on_assoclist_from_args(*args); end - - def on_backref(tok); end - - def on_backtick(tok); end - - def on_bare_assoc_hash(*args); end - - def on_begin(*args); end - - def on_binary(*args); end - - def on_block_var(*args); end - - def on_blockarg(*args); end - - def on_bodystmt(*args); end - - def on_brace_block(*args); end - - def on_break(*args); end - - def on_call(*args); end - - def on_case(*args); end - - def on_class(*args); end - - def on_class_name_error(*args); end - - def on_comma(tok); end - - def on_command(*args); end - - def on_command_call(*args); end - - def on_comment(tok); end - - def on_const(tok); end - - def on_const_path_field(*args); end - - def on_const_path_ref(*args); end - - def on_const_ref(*args); end - - def on_cvar(tok); end - - def on_def(*args); end - - def on_defined(*args); end - - def on_defs(*args); end - - def on_do_block(*args); end - - def on_dot2(*args); end - - def on_dot3(*args); end - - def on_dyna_symbol(*args); end - - def on_else(*args); end - - def on_elsif(*args); end - - def on_embdoc(tok); end - - def on_embdoc_beg(tok); end - - def on_embdoc_end(tok); end - - def on_embexpr_beg(tok); end - - def on_embexpr_end(tok); end - - def on_embvar(tok); end - - def on_ensure(*args); end - - def on_excessed_comma(*args); end - - def on_fcall(*args); end - - def on_field(*args); end - - def on_float(tok); end - - def on_fndptn(*args); end - - def on_for(*args); end - - def on_gvar(tok); end - - def on_hash(*args); end - - def on_heredoc_beg(tok); end - - def on_heredoc_end(tok); end - - def on_hshptn(*args); end - - def on_ident(tok); end - - def on_if(*args); end - - def on_if_mod(*args); end - - def on_ifop(*args); end - - def on_ignored_nl(tok); end - - def on_ignored_sp(tok); end - - def on_imaginary(tok); end - - def on_in(*args); end - - def on_int(tok); end - - def on_ivar(tok); end - - def on_kw(tok); end - - def on_kwrest_param(*args); end - - def on_label(tok); end - - def on_label_end(tok); end - - def on_lambda(*args); end - - def on_lbrace(tok); end - - def on_lbracket(tok); end - - def on_lparen(tok); end - - def on_magic_comment(*args); end - - def on_massign(*args); end - - def on_method_add_arg(*args); end - - def on_method_add_block(*args); end - - def on_mlhs_add(*args); end - - def on_mlhs_add_post(*args); end - - def on_mlhs_add_star(*args); end - - def on_mlhs_new(*args); end - - def on_mlhs_paren(*args); end - - def on_module(*args); end - - def on_mrhs_add(*args); end - - def on_mrhs_add_star(*args); end - - def on_mrhs_new(*args); end - - def on_mrhs_new_from_args(*args); end - - def on_next(*args); end - - def on_nl(tok); end - - def on_nokw_param(*args); end - - def on_op(tok); end - - def on_opassign(*args); end - - def on_operator_ambiguous(*args); end - - def on_param_error(*args); end - - def on_params(*args); end - - def on_paren(*args); end - - def on_period(tok); end - - def on_program(*args); end - - def on_qsymbols_add(*args); end - - def on_qsymbols_beg(tok); end - - def on_qsymbols_new(*args); end - - def on_qwords_add(*args); end - - def on_qwords_beg(tok); end - - def on_qwords_new(*args); end - - def on_rational(tok); end - - def on_rbrace(tok); end - - def on_rbracket(tok); end - - def on_redo(*args); end - - def on_regexp_add(*args); end - - def on_regexp_beg(tok); end - - def on_regexp_end(tok); end - - def on_regexp_literal(*args); end - - def on_regexp_new(*args); end - - def on_rescue(*args); end - - def on_rescue_mod(*args); end - - def on_rest_param(*args); end - - def on_retry(*args); end - - def on_return(*args); end - - def on_return0(*args); end - - def on_rparen(tok); end - - def on_sclass(*args); end - - def on_semicolon(tok); end - - def on_sp(tok); end - - def on_stmts_add(*args); end - - def on_stmts_new(*args); end - - def on_string_add(*args); end - - def on_string_concat(*args); end - - def on_string_content(*args); end - - def on_string_dvar(*args); end - - def on_string_embexpr(*args); end - - def on_string_literal(*args); end - - def on_super(*args); end - - def on_symbeg(tok); end - - def on_symbol(*args); end - - def on_symbol_literal(*args); end - - def on_symbols_add(*args); end - - def on_symbols_beg(tok); end - - def on_symbols_new(*args); end - - def on_tlambda(tok); end - - def on_tlambeg(tok); end - - def on_top_const_field(*args); end - - def on_top_const_ref(*args); end - - def on_tstring_beg(tok); end - - def on_tstring_content(tok); end - - def on_tstring_end(tok); end - - def on_unary(*args); end - - def on_undef(*args); end - - def on_unless(*args); end - - def on_unless_mod(*args); end - - def on_until(*args); end - - def on_until_mod(*args); end - - def on_var_alias(*args); end - - def on_var_field(*args); end - - def on_var_ref(*args); end - - def on_vcall(*args); end - - def on_void_stmt(*args); end - - def on_when(*args); end - - def on_while(*args); end - - def on_while_mod(*args); end - - def on_word_add(*args); end - - def on_word_new(*args); end - - def on_words_add(*args); end - - def on_words_beg(tok); end - - def on_words_new(*args); end - - def on_words_sep(tok); end - - def on_xstring_add(*args); end - - def on_xstring_literal(*args); end - - def on_xstring_new(*args); end - - def on_yield(*args); end - - def on_yield0(*args); end - - def on_zsuper(*args); end -end - -class Ripper::TokenPattern - def initialize(pattern); end - - def match(str); end - - def match_list(tokens); end - MAP = ::T.let(nil, ::T.untyped) -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::MatchData - def initialize(tokens, match); end - - def string(n=T.unsafe(nil)); end -end - -class Ripper::TokenPattern::MatchData -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern - def self.compile(*arg, **arg1); end -end - -class Ripper - def self.dedent_string(arg, arg1); end - - def self.lex_state_name(arg); end - - def self.token_match(src, pattern); end -end - -module RuboCop::AST::CollectionNode - def compact_blank(*args, **arg, &block); end - - def exclude?(*args, **arg, &block); end - - def fifth(*args, **arg, &block); end - - def fourth(*args, **arg, &block); end - - def save_plist(*args, **arg, &block); end - - def second(*args, **arg, &block); end - - def third(*args, **arg, &block); end - - def to_plist(*args, **arg, &block); end - - def to_sentence(*args, **arg, &block); end -end - -module RuboCop::AST::NodePattern::Sets - SET_ARM_INTEL = ::T.let(nil, ::T.untyped) - SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped) - SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped) - SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped) - SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped) - SET_MAC_LINUX = ::T.let(nil, ::T.untyped) - SET_ON_ARM_ON_INTEL_ON_SONOMA_ETC = ::T.let(nil, ::T.untyped) - SET_ON_INTEL_ON_ARM = ::T.let(nil, ::T.untyped) - SET_OR_NEWER_OR_OLDER = ::T.let(nil, ::T.untyped) - SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped) - SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped) - SET____ETC_5 = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cask::AST::Stanza - def app?(); end - - def appcast?(); end - - def arch?(); end - - def artifact?(); end - - def audio_unit_plugin?(); end - - def auto_updates?(); end - - def binary?(); end - - def caveats?(); end - - def colorpicker?(); end - - def conflicts_with?(); end - - def container?(); end - - def depends_on?(); end - - def deprecate?(); end - - def desc?(); end - - def dictionary?(); end - - def disable?(); end - - def font?(); end - - def homepage?(); end - - def input_method?(); end - - def installer?(); end - - def internet_plugin?(); end - - def keyboard_layout?(); end - - def language?(); end - - def livecheck?(); end - - def manpage?(); end - - def mdimporter?(); end - - def name?(); end - - def on_arch_conditional?(); end - - def on_arm?(); end - - def on_big_sur?(); end - - def on_catalina?(); end - - def on_el_capitan?(); end - - def on_high_sierra?(); end - - def on_intel?(); end - - def on_mojave?(); end - - def on_monterey?(); end - - def on_sierra?(); end - - def on_sonoma?(); end - - def on_ventura?(); end - - def pkg?(); end - - def postflight?(); end - - def preflight?(); end - - def prefpane?(); end - - def qlplugin?(); end - - def screen_saver?(); end - - def service?(); end - - def sha256?(); end - - def stage_only?(); end - - def suite?(); end - - def uninstall?(); end - - def uninstall_postflight?(); end - - def uninstall_preflight?(); end - - def url?(); end - - def version?(); end - - def vst3_plugin?(); end - - def vst_plugin?(); end - - def zap?(); end -end - -module RuboCop::Cop::Cask::CaskHelp - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::CaskHelp - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RuboCop::Cop::Cask::Desc - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Discontinued - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::HomepageUrlTrailingSlash - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::NoOverrides - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnDescStanza - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnHomepageStanza - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::OnSystemConditionals - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnUrlStanza - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::StanzaGrouping - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::StanzaOrder - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Url - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Variables - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cop - def highlights(); end - - def messages(); end -end - -class RuboCop::Cop::FormulaAudit::ComponentsOrder - def depends_on_node?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::DependencyOrder - def build_with_dependency_node(param0); end - - def buildtime_dependency?(param0); end - - def dependency_name_node(param0); end - - def depends_on_node?(param0=T.unsafe(nil)); end - - def negate_normal_dependency?(param0); end - - def optional_dependency?(param0); end - - def recommended_dependency?(param0); end - - def test_dependency?(param0); end - - def uses_from_macos_node?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::DeprecateDisableDate - def date(param0); end -end - -class RuboCop::Cop::FormulaAudit::DeprecateDisableReason - def reason(param0); end -end - -class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL - def correctable_shell_completion_node(param0); end - - def shell_completion_node(param0); end -end - -class RuboCop::Cop::FormulaAudit::GitUrls - def url_has_revision?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::Licenses - def license_exception?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::Miscellaneous - def conditional_dependencies(param0); end - - def destructure_hash(param0=T.unsafe(nil)); end - - def formula_path_strings(param0, param1); end - - def hash_dep(param0=T.unsafe(nil)); end - - def languageNodeModule?(param0); end -end - -class RuboCop::Cop::FormulaAudit::OptionDeclarations - def depends_on_build_with(param0); end -end - -class RuboCop::Cop::FormulaAudit::Patches - def patch_data?(param0); end -end - -class RuboCop::Cop::FormulaAudit::Test - def test_calls(param0); end -end - -class RuboCop::Cop::FormulaAudit::Text - def prefix_path(param0); end -end - -class RuboCop::Cop::FormulaAuditStrict::GitUrls - def url_has_tag?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAuditStrict::Text - def interpolated_share_path_starts_with(param0, param1); end - - def share_path_starts_with(param0, param1); end -end - -class RuboCop::Cop::FormulaCop - def dependency_name_hash_match?(param0, param1); end - - def dependency_type_hash_match?(param0, param1); end - - def required_dependency?(param0); end - - def required_dependency_name?(param0, param1); end -end - -class RuboCop::Cop::FormulaCop - extend ::T::Private::Abstract::Hooks -end - -module RuboCop::Cop::HelperFunctions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RuboCop::Cop::Homebrew::Blank - def nil_or_empty?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::CompactBlank - def reject_with_block?(param0=T.unsafe(nil)); end - - def reject_with_block_pass?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::MoveToExtendOS - def os_check?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::NegateInclude - def negate_include_call?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::Presence - def redundant_negative_receiver_and_other(param0=T.unsafe(nil)); end - - def redundant_receiver_and_other(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::Present - def exists_and_not_empty?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::SafeNavigationWithBlank - def safe_navigation_blank_in_conditional?(param0=T.unsafe(nil)); end -end - -module RuboCop::Cop::OnSystemConditionalsHelper - def hardware_cpu_search(param0, method:); end - - def if_arch_node_search(param0, arch:); end - - def if_base_os_node_search(param0, base_os:); end - - def if_macos_version_node_search(param0, os_version:); end - - def macos_version_comparison_search(param0, os_version:); end - - def on_macos_version_method_call(param0=T.unsafe(nil), on_method:); end - - def on_system_method_call(param0=T.unsafe(nil)); end -end - -module RuboCop::RSpec::ExpectOffense - def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end - - def expect_no_corrections(); end - - def expect_no_offenses(source, file=T.unsafe(nil)); end - - def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end - - def format_offense(source, **replacements); end - - def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end - - def parse_processed_source(source, file=T.unsafe(nil)); end - - def set_formatter_options(); end -end - -class RuboCop::RSpec::ExpectOffense::AnnotatedSource - def ==(other); end - - def annotations(); end - - def initialize(lines, annotations); end - - def lines(); end - - def match_annotations?(other); end - - def plain_source(); end - - def with_offense_annotations(offenses); end - ABBREV = ::T.let(nil, ::T.untyped) - ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::RSpec::ExpectOffense::AnnotatedSource - def self.parse(annotated_source); end -end - -module RuboCop::RSpec::ExpectOffense -end - -class RuboCop::RSpec::ParallelFormatter - def dump_pending(*arg); end -end - -class RuboCop::RSpec::ParallelFormatter -end - -class RubyLex - def check_code_block(code, tokens=T.unsafe(nil)); end - - def check_corresponding_token_depth(lines, line_index); end - - def check_newline_depth_difference(); end - - def check_state(code, tokens=T.unsafe(nil), context: T.unsafe(nil)); end - - def check_string_literal(tokens); end - - def check_termination_in_prev_line(code, context: T.unsafe(nil)); end - - def each_top_level_statement(); end - - def find_prev_spaces(line_index); end - - def initialize_input(); end - - def is_method_calling?(tokens, index); end - - def is_the_in_correspond_to_a_for(tokens, index); end - - def lex(); end - - def process_continue(tokens=T.unsafe(nil)); end - - def process_literal_type(tokens=T.unsafe(nil)); end - - def process_nesting_level(tokens=T.unsafe(nil)); end - - def prompt(); end - - def set_auto_indent(context); end - - def set_input(io, p=T.unsafe(nil), context: T.unsafe(nil), &block); end - - def set_prompt(p=T.unsafe(nil), &block); end - - def take_corresponding_syntax_to_kw_do(tokens, index); end - ERROR_TOKENS = ::T.let(nil, ::T.untyped) -end - -class RubyLex::TerminateLineInput - def initialize(); end -end - -class RubyLex::TerminateLineInput -end - -class RubyLex - def self.compile_with_errors_suppressed(code, line_no: T.unsafe(nil)); end - - def self.ripper_lex_without_warning(code, context: T.unsafe(nil)); end -end - -class RubyVM::AbstractSyntaxTree::Node - def node_id(); end - - def pretty_print_children(q, names=T.unsafe(nil)); end - - def script_lines(); end - - def source(); end -end - -class RubyVM::InstructionSequence - def script_lines(); end -end - -module RubyVM::MJIT -end - -module RubyVM::MJIT - def self.enabled?(); end - - def self.pause(*arg); end - - def self.resume(); end -end - -class RubyVM - def self.keep_script_lines(); end - - def self.keep_script_lines=(keep_script_lines); end -end - -ScanError = StringScanner::Error - -class Set - def ==(other); end - - def ===(o); end - - def divide(&func); end - - def eql?(o); end - - def flatten_merge(set, seen=T.unsafe(nil)); end - - def pretty_print(pp); end - - def pretty_print_cycle(pp); end - - def reset(); end - InspectKey = ::T.let(nil, ::T.untyped) -end - -module SharedEnvExtension - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class SimpleDelegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -module Singleton - def _dump(depth=T.unsafe(nil)); end - - def clone(); end - - def dup(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -module Singleton::SingletonClassMethods - def _load(str); end - - def clone(); end -end - -module Singleton - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - def self.__init__(klass); end -end - -class Socket - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DECnet = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AF_VSOCK = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DECnet = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_VSOCK = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -module Socket::Constants - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DECnet = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AF_VSOCK = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DECnet = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_VSOCK = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -module Spoom::Cli::Helper - HIGHLIGHT_COLOR = ::T.let(nil, ::T.untyped) -end - -module Spoom::Cli::Helper - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Colorize - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Bundle - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Exec - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::FileSystem - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Git - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Sorbet - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Coverage::D3::Base - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Coverage::D3 - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Coverage::Template - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Coverage - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Deadcode::Error - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Spoom::Deadcode::Plugins::Base - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Deadcode - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::FileTree::Visitor - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::LSP::PrintableSymbol - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Printer - extend ::T::Helpers -end - -module Spoom::Sorbet::Errors - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Sorbet::MetricsParser - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Sorbet::Sigils - extend ::T::Private::Methods::SingletonMethodHooks -end - -class String - include ::JSON::Ext::Generator::GeneratorMethods::String - def fast_xs(); end - - def to_nfc(); end - - def to_nfd(); end - - def to_nfkc(); end - - def to_nfkd(); end -end - -class StringIO - def set_encoding_by_bom(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class StringIO - def self.new(*arg); end -end - -class StringScanner - def bol?(); end - - def fixed_anchor?(); end - - def initialize(*arg); end - Id = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Struct - def deconstruct(); end - - def deconstruct_keys(arg); end - - def filter(*arg); end -end - -Struct::Group = Etc::Group - -Struct::Passwd = Etc::Passwd - -class Struct - def self.new(*arg); end -end - -module Superenv - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Symbol - def to_msgpack_ext(); end -end - -module Tapioca - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Tempfile - def _close(); end - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Tempfile::Remover - def call(*args); end - - def initialize(tmpfile); end -end - -class Tempfile::Remover -end - -class Test::Helper::OutputAsTTY::Output - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Thread::Backtrace - def self.limit(); end -end - -class Thread - def self.ignore_deadlock(); end - - def self.ignore_deadlock=(ignore_deadlock); end - - def self.new(*arg); end -end - -module Timeout - VERSION = ::T.let(nil, ::T.untyped) -end - -class TracePoint - def eval_script(); end - - def instruction_sequence(); end - - def parameters(); end -end - -class TracePoint - def self.allow_reentry(); end - - def self.new(*events); end -end - -class TrueClass - include ::JSON::Ext::Generator::GeneratorMethods::TrueClass -end - -module Tty - extend ::T::Private::Methods::SingletonMethodHooks -end - -module URI - include ::URI::RFC2396_REGEXP - TBLENCURICOMP_ = ::T.let(nil, ::T.untyped) -end - -class URI::FTP - def buffer_open(buf, proxy, options); end -end - -class URI::FTP - def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end -end - -class URI::File - def check_password(user); end - - def check_user(user); end - - def check_userinfo(user); end - - def set_userinfo(v); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class URI::Generic - def decoded_password(); end - - def decoded_user(); end -end - -class URI::HTTP - def authority(); end - - def buffer_open(buf, proxy, options); end - - def origin(); end -end - -class URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end -end - -class URI::MailTo - def initialize(*arg); end -end - -class URI::RFC2396_Parser - def initialize(opts=T.unsafe(nil)); end -end - -class URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -module URI::Util - def self.make_components_hash(klass, array_hash); end -end - -class URI::WSS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class URI::WSS -end - -module URI - def self.decode_uri_component(str, enc=T.unsafe(nil)); end - - def self.for(scheme, *arguments, default: T.unsafe(nil)); end - - def self.get_encoding(label); end - - def self.open(name, *rest, &block); end - - def self.register_scheme(scheme, klass); end -end - -class UnboundMethod - def private?(); end - - def protected?(); end - - def public?(); end -end - -module UnicodeNormalize -end - -module UnicodeNormalize -end - -module Utils::AST - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Autoremove - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Backtrace - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Gzip - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Inreplace - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Service - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Shell - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Timer - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Version::Parser - extend ::T::Private::Abstract::Hooks -end - -class Version::Token - extend ::T::Private::Abstract::Hooks -end - -module YARDSorbet::Directives - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::Handlers::StructClassHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::NodeUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::SigToYARD - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::TagUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Zlib::Deflate - def initialize(*arg); end -end - -class Zlib::GzipReader - def initialize(*arg); end -end - -class Zlib::GzipReader - def self.zcat(*arg); end -end - -class Zlib::GzipWriter - def initialize(*arg); end -end - -class Zlib::InProgressError -end - -class Zlib::InProgressError -end - -class Zlib::Inflate - def initialize(*arg); end -end From b010e397d68cd1c42df9a0c9d4c3ea929a1ca842 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 05:46:18 -0800 Subject: [PATCH 03/15] Add extend/node.rbi, remove unused methods --- Library/Homebrew/rubocops/cask/extend/node.rb | 6 ------ .../Homebrew/rubocops/cask/extend/node.rbi | 21 +++++++++++++++++++ 2 files changed, 21 insertions(+), 6 deletions(-) create mode 100644 Library/Homebrew/rubocops/cask/extend/node.rbi diff --git a/Library/Homebrew/rubocops/cask/extend/node.rb b/Library/Homebrew/rubocops/cask/extend/node.rb index 54b8654df2..463a1ad6fd 100644 --- a/Library/Homebrew/rubocops/cask/extend/node.rb +++ b/Library/Homebrew/rubocops/cask/extend/node.rb @@ -8,17 +8,11 @@ module RuboCop include RuboCop::Cask::Constants def_node_matcher :method_node, "{$(send ...) (block $(send ...) ...)}" - def_node_matcher :block_args, "(block _ $_ _)" def_node_matcher :block_body, "(block _ _ $_)" - - def_node_matcher :key_node, "{(pair $_ _) (hash (pair $_ _) ...)}" - def_node_matcher :val_node, "{(pair _ $_) (hash (pair _ $_) ...)}" - def_node_matcher :cask_block?, "(block (send nil? :cask ...) args ...)" def_node_matcher :on_system_block?, "(block (send nil? {#{ON_SYSTEM_METHODS.map(&:inspect).join(" ")}} ...) args ...)" def_node_matcher :arch_variable?, "(lvasgn _ (send nil? :on_arch_conditional ...))" - def_node_matcher :begin_block?, "(begin ...)" sig { returns(T::Boolean) } diff --git a/Library/Homebrew/rubocops/cask/extend/node.rbi b/Library/Homebrew/rubocops/cask/extend/node.rbi new file mode 100644 index 0000000000..f3db682720 --- /dev/null +++ b/Library/Homebrew/rubocops/cask/extend/node.rbi @@ -0,0 +1,21 @@ +# typed: strict + +class RuboCop::AST::Node + sig { returns(T::Boolean) } + def arch_variable?; end + + sig { returns(T::Boolean) } + def begin_block?; end + + sig { returns(T.nilable(RuboCop::AST::Node)) } + def block_body; end + + sig { returns(T::Boolean) } + def cask_block?; end + + sig { returns(T.nilable(RuboCop::AST::Node)) } + def method_node; end + + sig { returns(T::Boolean) } + def on_system_block?; end +end From c83e0170a9017f74b3321b9d787fb2e372953fbc Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 05:53:24 -0800 Subject: [PATCH 04/15] Fix cask_help rbi --- Library/Homebrew/rubocops/cask/mixin/cask_help.rb | 2 +- Library/Homebrew/rubocops/cask/mixin/cask_help.rbi | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/Library/Homebrew/rubocops/cask/mixin/cask_help.rb b/Library/Homebrew/rubocops/cask/mixin/cask_help.rb index b964bbe763..661f218b7d 100644 --- a/Library/Homebrew/rubocops/cask/mixin/cask_help.rb +++ b/Library/Homebrew/rubocops/cask/mixin/cask_help.rb @@ -6,7 +6,7 @@ module RuboCop module Cask # Common functionality for cops checking casks. module CaskHelp - prepend CommentsHelp + prepend CommentsHelp # Update the rbi file if changing this: https://github.com/sorbet/sorbet/issues/259 sig { overridable.params(cask_block: RuboCop::Cask::AST::CaskBlock).void } def on_cask(cask_block); end diff --git a/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi index 366d9ac46f..134eae355e 100644 --- a/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi +++ b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi @@ -1,6 +1,7 @@ # typed: strict module RuboCop::Cop::Cask::CaskHelp + # Sorbet doesn't understand `prepend`: https://github.com/sorbet/sorbet/issues/259 + include RuboCop::Cop::CommentsHelp requires_ancestor { RuboCop::Cop::Base } - # requires_ancestor { RuboCop::Cop::CommentsHelp } end From 5b5cfe89deb677659ceb7e394020a84583d414d3 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 05:53:52 -0800 Subject: [PATCH 05/15] Resolve violations from removing hidden.rbi --- Library/Homebrew/dev-cmd/determine-test-runners.rb | 2 +- Library/Homebrew/extend/ENV/shared.rb | 2 +- Library/Homebrew/formula_cellar_checks.rb | 4 ++-- Library/Homebrew/mktemp.rb | 2 +- Library/Homebrew/requirements/macos_requirement.rb | 4 ++-- Library/Homebrew/software_spec.rb | 2 +- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Library/Homebrew/dev-cmd/determine-test-runners.rb b/Library/Homebrew/dev-cmd/determine-test-runners.rb index 9a94f20ca9..68639819e8 100755 --- a/Library/Homebrew/dev-cmd/determine-test-runners.rb +++ b/Library/Homebrew/dev-cmd/determine-test-runners.rb @@ -55,7 +55,7 @@ module Homebrew github_output = ENV.fetch("GITHUB_OUTPUT") File.open(github_output, "a") do |f| - f.puts("runners=#{runners.to_json}") + f.puts("runners=#{T.unsafe(runners).to_json}") f.puts("runners_present=#{runners.present?}") end end diff --git a/Library/Homebrew/extend/ENV/shared.rb b/Library/Homebrew/extend/ENV/shared.rb index 1f42f1fa10..c4749280a2 100644 --- a/Library/Homebrew/extend/ENV/shared.rb +++ b/Library/Homebrew/extend/ENV/shared.rb @@ -63,7 +63,7 @@ module SharedEnvExtension sig { returns(T::Hash[String, String]) } def remove_cc_etc keys = %w[CC CXX OBJC OBJCXX LD CPP CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS LDFLAGS CPPFLAGS] - keys.to_h { |key| [key, delete(key)] } + keys.to_h { |key| [key, T.must(delete(key))] } end sig { params(newflags: String).void } diff --git a/Library/Homebrew/formula_cellar_checks.rb b/Library/Homebrew/formula_cellar_checks.rb index 5c6f562642..58831e49fa 100644 --- a/Library/Homebrew/formula_cellar_checks.rb +++ b/Library/Homebrew/formula_cellar_checks.rb @@ -355,11 +355,11 @@ module FormulaCellarChecks else true end - return if mismatches.empty? && universal_binaries_expected + return if T.must(mismatches).empty? && universal_binaries_expected mismatches_expected = formula.tap.blank? || formula.tap.audit_exception(:mismatched_binary_allowlist, formula.name) - return if compatible_universal_binaries.empty? && mismatches_expected + return if T.must(compatible_universal_binaries).empty? && mismatches_expected return if universal_binaries_expected && mismatches_expected diff --git a/Library/Homebrew/mktemp.rb b/Library/Homebrew/mktemp.rb index 4bbf14b5dd..c89d01c0ed 100644 --- a/Library/Homebrew/mktemp.rb +++ b/Library/Homebrew/mktemp.rb @@ -68,7 +68,7 @@ class Mktemp begin chown(nil, group_id, @tmpdir) rescue Errno::EPERM - opoo "Failed setting group \"#{T.must(Etc.getgrgid(group_id)).name}\" on #{@tmpdir}" + opoo "Failed setting group \"#{T.unsafe(Etc.getgrgid(group_id)).name}\" on #{@tmpdir}" end begin diff --git a/Library/Homebrew/requirements/macos_requirement.rb b/Library/Homebrew/requirements/macos_requirement.rb index b58a3ce50d..3371ca25b3 100644 --- a/Library/Homebrew/requirements/macos_requirement.rb +++ b/Library/Homebrew/requirements/macos_requirement.rb @@ -118,8 +118,8 @@ class MacOSRequirement < Requirement def to_json(options) comp = @comparator.to_s - return { comp => @version.map(&:to_s) }.to_json(options) if @version.is_a?(Array) + return T.unsafe({ comp => @version.map(&:to_s) }).to_json(options) if @version.is_a?(Array) - { comp => [@version.to_s] }.to_json(options) + T.unsafe({ comp => [@version.to_s] }).to_json(options) end end diff --git a/Library/Homebrew/software_spec.rb b/Library/Homebrew/software_spec.rb index 078bd539cc..788bacfc32 100644 --- a/Library/Homebrew/software_spec.rb +++ b/Library/Homebrew/software_spec.rb @@ -192,7 +192,7 @@ class SoftwareSpec def uses_from_macos(deps, bounds = {}) if deps.is_a?(Hash) bounds = deps.dup - deps = [bounds.shift].to_h + deps = [T.unsafe(bounds).shift].to_h end spec, tags = deps.is_a?(Hash) ? deps.first : deps From a40fc0afd37589d73f502ba96c70b8dcf7e0cc10 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 06:00:32 -0800 Subject: [PATCH 06/15] Add upstream rbi --- Library/Homebrew/sorbet/rbi/upstream.rbi | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Library/Homebrew/sorbet/rbi/upstream.rbi b/Library/Homebrew/sorbet/rbi/upstream.rbi index 7653a8622e..bfb50d9bb1 100644 --- a/Library/Homebrew/sorbet/rbi/upstream.rbi +++ b/Library/Homebrew/sorbet/rbi/upstream.rbi @@ -3,6 +3,12 @@ # This file contains temporary definitions for fixes that have # been submitted upstream to https://github.com/sorbet/sorbet. +# https://github.com/sorbet/sorbet/pull/7647/files +module IRB + sig { params(ap_path: T.nilable(String), argv: T::Array[String]).void } + def self.setup(ap_path, argv: ::ARGV); end +end + # https://github.com/sorbet/sorbet/pull/7678 class String sig do From 07fad780de762d75a34e240860c129d12330eb4c Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 06:01:02 -0800 Subject: [PATCH 07/15] Remove hidden defs references --- .gitignore | 1 - Library/.rubocop.yml | 1 - Library/Homebrew/dev-cmd/typecheck.rb | 12 ------------ .../sorbet/hidden_definitions_hacks/webrick.rb | 4 ---- 4 files changed, 18 deletions(-) delete mode 100644 Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb diff --git a/.gitignore b/.gitignore index 50bf06a265..c4cc9d81b9 100644 --- a/.gitignore +++ b/.gitignore @@ -21,7 +21,6 @@ /Library/Taps /Library/PinnedTaps /Library/Homebrew/.byebug_history -/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt # Ignore Bundler files **/.bundle/bin diff --git a/Library/.rubocop.yml b/Library/.rubocop.yml index a53fd285f8..b024cb4dc3 100644 --- a/Library/.rubocop.yml +++ b/Library/.rubocop.yml @@ -18,7 +18,6 @@ AllCops: - "**/*.rbi" Exclude: - "Homebrew/sorbet/rbi/gems/**/*.rbi" - - "Homebrew/sorbet/rbi/hidden-definitions/*.rbi" - "Homebrew/bin/*" - "Homebrew/vendor/**/*" - "Taps/*/*/vendor/**/*" diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb index 7378baf7c0..3f2a03ed9c 100644 --- a/Library/Homebrew/dev-cmd/typecheck.rb +++ b/Library/Homebrew/dev-cmd/typecheck.rb @@ -60,18 +60,6 @@ module Homebrew safe_system "bundle", "exec", "tapioca", "gem", *tapioca_args safe_system "bundle", "exec", "parlour" - safe_system({ "RUBYLIB" => "#{HOMEBREW_LIBRARY_PATH}/sorbet/hidden_definitions_hacks" }, - "bundle", "exec", "srb", "rbi", "hidden-definitions") - # HACK: we'll phase out hidden-definitions soon - tmp_file = "sorbet/rbi/hidden-definitions/hidden.rbi.tmp" - orig_file = "sorbet/rbi/hidden-definitions/hidden.rbi" - File.open(tmp_file, "w") do |out_file| - File.foreach(orig_file) do |line| - out_file.puts line unless line.include?("def self.new(*args, **arg, &blk); end") - end - end - File.rename(tmp_file, orig_file) - if args.suggest_typed? ohai "Bumping Sorbet `typed` sigils..." # --sorbet needed because of https://github.com/Shopify/spoom/issues/488 diff --git a/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb b/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb deleted file mode 100644 index e8251a00ec..0000000000 --- a/Library/Homebrew/sorbet/hidden_definitions_hacks/webrick.rb +++ /dev/null @@ -1,4 +0,0 @@ -# typed: strict -# frozen_string_literal: true - -# This file intentionally left blank From 1dd0f6bbb2d29d1438fc8b752d68acf156d6c879 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 11:44:43 -0800 Subject: [PATCH 08/15] Exclude msgpack from RBI generation --- Library/Homebrew/dev-cmd/typecheck.rb | 4 +- .../sorbet/rbi/gems/msgpack@1.7.2.rbi | 319 ------------------ 2 files changed, 3 insertions(+), 320 deletions(-) delete mode 100644 Library/Homebrew/sorbet/rbi/gems/msgpack@1.7.2.rbi diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb index 3f2a03ed9c..63acb99008 100644 --- a/Library/Homebrew/dev-cmd/typecheck.rb +++ b/Library/Homebrew/dev-cmd/typecheck.rb @@ -46,8 +46,10 @@ module Homebrew HOMEBREW_LIBRARY_PATH.cd do if update safe_system "bundle", "exec", "tapioca", "dsl" + # RBI files already provided by Sorbet: excluded_gems = [ - "json", # RBI file is already provided by Sorbet + "json", + "msgpack", ] tapioca_args = ["--exclude", *excluded_gems, "--pre", "sorbet/tapioca/prerequire.rb"] tapioca_args << "--all" if args.update_all? diff --git a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.7.2.rbi b/Library/Homebrew/sorbet/rbi/gems/msgpack@1.7.2.rbi deleted file mode 100644 index 7b17f65d9b..0000000000 --- a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.7.2.rbi +++ /dev/null @@ -1,319 +0,0 @@ -# typed: false - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `msgpack` gem. -# Please instead update this file by running `bin/tapioca gem msgpack`. - -# source://msgpack//lib/msgpack/core_ext.rb#67 -class Array - include ::Enumerable - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#71 - def to_msgpack_with_packer(packer); end -end - -Bignum = Integer - -# source://msgpack//lib/msgpack/core_ext.rb#37 -class FalseClass - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#41 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#47 -class Float < ::Numeric - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#51 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#77 -class Hash - include ::Enumerable - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#81 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#98 -class Integer < ::Numeric - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#102 - def to_msgpack_with_packer(packer); end -end - -# MessagePack extention packer and unpacker for built-in Time class -# -# source://msgpack//lib/msgpack/version.rb#1 -module MessagePack - private - - # source://msgpack//lib/msgpack.rb#39 - def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#22 - def load(src, param = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#39 - def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#22 - def unpack(src, param = T.unsafe(nil)); end - - class << self - # source://msgpack//lib/msgpack.rb#39 - def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#22 - def load(src, param = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#39 - def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack.rb#22 - def unpack(src, param = T.unsafe(nil)); end - end -end - -# source://msgpack//lib/msgpack/core_ext.rb#2 -module MessagePack::CoreExt - # source://msgpack//lib/msgpack/core_ext.rb#3 - def to_msgpack(packer_or_io = T.unsafe(nil)); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#130 -class MessagePack::ExtensionValue < ::Struct - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#134 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/factory.rb#2 -class MessagePack::Factory - # source://msgpack//lib/msgpack/factory.rb#113 - def dump(v, *rest); end - - # source://msgpack//lib/msgpack/factory.rb#99 - def load(src, param = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack/factory.rb#113 - def pack(v, *rest); end - - # source://msgpack//lib/msgpack/factory.rb#120 - def pool(size = T.unsafe(nil), **options); end - - # see ext for other methods - # - # @raise [FrozenError] - # - # source://msgpack//lib/msgpack/factory.rb#5 - def register_type(type, klass, options = T.unsafe(nil)); end - - # [ {type: id, class: Class(or nil), packer: arg, unpacker: arg}, ... ] - # - # source://msgpack//lib/msgpack/factory.rb#41 - def registered_types(selector = T.unsafe(nil)); end - - # @return [Boolean] - # - # source://msgpack//lib/msgpack/factory.rb#86 - def type_registered?(klass_or_type, selector = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack/factory.rb#99 - def unpack(src, param = T.unsafe(nil)); end -end - -# source://msgpack//lib/msgpack/factory.rb#128 -class MessagePack::Factory::Pool - # @return [Pool] a new instance of Pool - # - # source://msgpack//lib/msgpack/factory.rb#181 - def initialize(factory, size, options = T.unsafe(nil)); end - - # source://msgpack//lib/msgpack/factory.rb#195 - def dump(object); end - - # source://msgpack//lib/msgpack/factory.rb#188 - def load(data); end - - # source://msgpack//lib/msgpack/factory.rb#206 - def packer(&block); end - - # source://msgpack//lib/msgpack/factory.rb#202 - def unpacker(&block); end -end - -# source://msgpack//lib/msgpack/factory.rb#130 -class MessagePack::Factory::Pool::MemberPool - # @return [MemberPool] a new instance of MemberPool - # - # source://msgpack//lib/msgpack/factory.rb#131 - def initialize(size, &block); end - - # source://msgpack//lib/msgpack/factory.rb#137 - def with; end -end - -class MessagePack::HeldBuffer < ::BasicObject; end - -# source://msgpack//lib/msgpack/packer.rb#2 -class MessagePack::Packer - # @raise [ArgumentError] - # - # source://msgpack//lib/msgpack/packer.rb#9 - def register_type(type, klass, method_name = T.unsafe(nil), &block); end - - # source://msgpack//lib/msgpack/packer.rb#14 - def registered_types; end - - # @return [Boolean] - # - # source://msgpack//lib/msgpack/packer.rb#24 - def type_registered?(klass_or_type); end -end - -# source://msgpack//lib/msgpack/time.rb#5 -module MessagePack::Time; end - -# source://msgpack//lib/msgpack/time.rb#25 -MessagePack::Time::Packer = T.let(T.unsafe(nil), Proc) - -# 3-arg Time.at is available Ruby >= 2.5 -# -# source://msgpack//lib/msgpack/time.rb#7 -MessagePack::Time::TIME_AT_3_AVAILABLE = T.let(T.unsafe(nil), TrueClass) - -# source://msgpack//lib/msgpack/time.rb#13 -MessagePack::Time::Unpacker = T.let(T.unsafe(nil), Proc) - -# a.k.a. "TimeSpec" -# -# source://msgpack//lib/msgpack/timestamp.rb#4 -class MessagePack::Timestamp - # @param sec [Integer] - # @param nsec [Integer] - # @return [Timestamp] a new instance of Timestamp - # - # source://msgpack//lib/msgpack/timestamp.rb#24 - def initialize(sec, nsec); end - - # source://msgpack//lib/msgpack/timestamp.rb#72 - def ==(other); end - - # @return [Integer] - # - # source://msgpack//lib/msgpack/timestamp.rb#20 - def nsec; end - - # @return [Integer] - # - # source://msgpack//lib/msgpack/timestamp.rb#17 - def sec; end - - # source://msgpack//lib/msgpack/timestamp.rb#68 - def to_msgpack_ext; end - - class << self - # source://msgpack//lib/msgpack/timestamp.rb#29 - def from_msgpack_ext(data); end - - # source://msgpack//lib/msgpack/timestamp.rb#50 - def to_msgpack_ext(sec, nsec); end - end -end - -# source://msgpack//lib/msgpack/timestamp.rb#13 -MessagePack::Timestamp::TIMESTAMP32_MAX_SEC = T.let(T.unsafe(nil), Integer) - -# source://msgpack//lib/msgpack/timestamp.rb#14 -MessagePack::Timestamp::TIMESTAMP64_MAX_SEC = T.let(T.unsafe(nil), Integer) - -# The timestamp extension type defined in the MessagePack spec. -# See https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type for details. -# -# source://msgpack//lib/msgpack/timestamp.rb#11 -MessagePack::Timestamp::TYPE = T.let(T.unsafe(nil), Integer) - -class MessagePack::UnexpectedTypeError < ::MessagePack::UnpackError - include ::MessagePack::TypeError -end - -# source://msgpack//lib/msgpack/unpacker.rb#2 -class MessagePack::Unpacker - # source://msgpack//lib/msgpack/unpacker.rb#9 - def register_type(type, klass = T.unsafe(nil), method_name = T.unsafe(nil), &block); end - - # source://msgpack//lib/msgpack/unpacker.rb#18 - def registered_types; end - - # @return [Boolean] - # - # source://msgpack//lib/msgpack/unpacker.rb#28 - def type_registered?(klass_or_type); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#17 -class NilClass - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#21 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/core_ext.rb#57 -class String - include ::Comparable - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#61 - def to_msgpack_with_packer(packer); end -end - -# source://msgpack//lib/msgpack/symbol.rb#1 -class Symbol - include ::Comparable - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#91 - def to_msgpack_with_packer(packer); end - - class << self - # source://msgpack//lib/msgpack/symbol.rb#12 - def from_msgpack_ext(data); end - end -end - -# source://msgpack//lib/msgpack/core_ext.rb#27 -class TrueClass - include ::MessagePack::CoreExt - - private - - # source://msgpack//lib/msgpack/core_ext.rb#31 - def to_msgpack_with_packer(packer); end -end From adfec16871183fa4f36354ef2dd520e3e34617cb Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 11:46:03 -0800 Subject: [PATCH 09/15] Make gather_constants dynamic --- .../sorbet/tapioca/compilers/rubocop.rb | 53 ++++++++----------- 1 file changed, 21 insertions(+), 32 deletions(-) diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb index 0135bd6e5f..d0f6d0d0e1 100644 --- a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb +++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb @@ -3,55 +3,44 @@ require "method_source" require "rubocop" +require_relative "../../../extend/string" # placate rubocop require_relative "../../../rubocops" module Tapioca module Compilers - class Rubocop < Tapioca::Dsl::Compiler + class RuboCop < Tapioca::Dsl::Compiler # FIXME: Enable cop again when https://github.com/sorbet/sorbet/issues/3532 is fixed. # rubocop:disable Style/MutableConstant - ConstantType = type_member { { fixed: T::Class[T.anything] } } + # This should be a module whose singleton class contains RuboCop::AST::NodePattern::Macros, + # but I don't know how to express that in Sorbet. + ConstantType = type_member { { fixed: Module } } # rubocop:enable Style/MutableConstant sig { override.returns(T::Enumerable[Module]) } def self.gather_constants - [ - RuboCop::Cop::Cask::Variables, - RuboCop::Cop::Homebrew::Blank, - RuboCop::Cop::Homebrew::CompactBlank, - RuboCop::Cop::Homebrew::MoveToExtendOS, - RuboCop::Cop::Homebrew::NegateInclude, - RuboCop::Cop::Homebrew::Presence, - RuboCop::Cop::Homebrew::Present, - RuboCop::Cop::Homebrew::SafeNavigationWithBlank, - RuboCop::Cop::FormulaAudit::ComponentsOrder, - RuboCop::Cop::FormulaAudit::DependencyOrder, - RuboCop::Cop::FormulaAudit::DeprecateDisableDate, - RuboCop::Cop::FormulaAudit::DeprecateDisableReason, - RuboCop::Cop::FormulaAudit::Licenses, - RuboCop::Cop::FormulaAudit::OptionDeclarations, - RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL, - RuboCop::Cop::FormulaAudit::GitUrls, - RuboCop::Cop::FormulaAudit::Miscellaneous, - RuboCop::Cop::FormulaAudit::Patches, - RuboCop::Cop::FormulaAudit::Test, - RuboCop::Cop::FormulaAudit::Text, - RuboCop::Cop::FormulaAuditStrict::GitUrls, - RuboCop::Cop::FormulaAuditStrict::Text, - RuboCop::Cop::FormulaCop, - RuboCop::Cop::OnSystemConditionalsHelper, - ] + all_modules.select do |klass| + next unless klass.singleton_class < ::RuboCop::AST::NodePattern::Macros + + path = T.must(Object.const_source_location(klass.to_s)).fetch(0).to_s + # exclude vendored code, to avoid contradicting their RBI files + path.exclude?("/vendor/bundle/ruby/") && + # exclude source code that already has an RBI file + !Pathname("#{path}i").exist? && + # exclude source code that doesn't use the DSLs + File.readlines(path).grep(/def_node_/).any? + end end sig { override.void } def decorate root.create_path(constant) do |klass| - # For each encrypted attribute we find in the class constant.instance_methods(false).each do |method_name| source = constant.instance_method(method_name).source.lstrip - # https://www.rubydoc.info/gems/rubocop-ast/RuboCop/AST/NodePattern/Macros - # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb - # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern/method_definer.rb + # For more info on these DSLs: + # https://www.rubydoc.info/gems/rubocop-ast/RuboCop/AST/NodePattern/Macros + # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb + # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern/method_definer.rb + # The type signatures below could maybe be stronger, but I only wanted to avoid errors: if source.start_with?("def_node_matcher") # https://github.com/Shopify/tapioca/blob/3341a9b/lib/tapioca/rbi_ext/model.rb#L89 klass.create_method( From 791ca27896148a18d603d696f0dccbd3eb493786 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 12:58:34 -0800 Subject: [PATCH 10/15] Add rubocop exclusion --- Library/.rubocop.yml | 1 + Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Library/.rubocop.yml b/Library/.rubocop.yml index b024cb4dc3..51c67f9f03 100644 --- a/Library/.rubocop.yml +++ b/Library/.rubocop.yml @@ -68,6 +68,7 @@ Homebrew/NegateInclude: # `exclude?` is not available here: - "Homebrew/standalone/init.rb" - "Homebrew/rubocops/**/*" + - "Homebrew/sorbet/tapioca/**/*" # `system` is a special case and aligns on second argument, so allow this for formulae. Layout/ArgumentAlignment: diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb index d0f6d0d0e1..d1c1b5934a 100644 --- a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb +++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb @@ -3,7 +3,6 @@ require "method_source" require "rubocop" -require_relative "../../../extend/string" # placate rubocop require_relative "../../../rubocops" module Tapioca @@ -23,7 +22,7 @@ module Tapioca path = T.must(Object.const_source_location(klass.to_s)).fetch(0).to_s # exclude vendored code, to avoid contradicting their RBI files - path.exclude?("/vendor/bundle/ruby/") && + !path.include?("/vendor/bundle/ruby/") && # exclude source code that already has an RBI file !Pathname("#{path}i").exist? && # exclude source code that doesn't use the DSLs From 772ddb0e1ef08f5a22b4366b98dff885a86bb5d4 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 22:07:05 -0800 Subject: [PATCH 11/15] Add Etc::Group struct members to upstream --- Library/Homebrew/mktemp.rb | 2 +- Library/Homebrew/sorbet/rbi/upstream.rbi | 14 +++++++++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/Library/Homebrew/mktemp.rb b/Library/Homebrew/mktemp.rb index c89d01c0ed..4bbf14b5dd 100644 --- a/Library/Homebrew/mktemp.rb +++ b/Library/Homebrew/mktemp.rb @@ -68,7 +68,7 @@ class Mktemp begin chown(nil, group_id, @tmpdir) rescue Errno::EPERM - opoo "Failed setting group \"#{T.unsafe(Etc.getgrgid(group_id)).name}\" on #{@tmpdir}" + opoo "Failed setting group \"#{T.must(Etc.getgrgid(group_id)).name}\" on #{@tmpdir}" end begin diff --git a/Library/Homebrew/sorbet/rbi/upstream.rbi b/Library/Homebrew/sorbet/rbi/upstream.rbi index bfb50d9bb1..877921e54f 100644 --- a/Library/Homebrew/sorbet/rbi/upstream.rbi +++ b/Library/Homebrew/sorbet/rbi/upstream.rbi @@ -3,7 +3,19 @@ # This file contains temporary definitions for fixes that have # been submitted upstream to https://github.com/sorbet/sorbet. -# https://github.com/sorbet/sorbet/pull/7647/files +# https://github.com/sorbet/sorbet/pull/7650 +class Etc::Group < Struct + sig { returns(Integer) } + def gid; end + sig { returns(T::Array[String]) } + def mem; end + sig { returns(String) } + def name; end + sig { returns(String) } + def passwd; end +end + +# https://github.com/sorbet/sorbet/pull/7647 module IRB sig { params(ap_path: T.nilable(String), argv: T::Array[String]).void } def self.setup(ap_path, argv: ::ARGV); end From 9dcde74e8163ffbea03dcd705f9d966577132fd2 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 11:46:10 -0800 Subject: [PATCH 12/15] brew tc --update-all --- .../cop/formula_audit/assert_statements.rbi | 7 + .../cop/formula_audit/class_inheritance.rbi | 7 + .../rubo_cop/cop/formula_audit/class_name.rbi | 7 + .../rubo_cop/cop/formula_audit/comments.rbi | 7 + .../cop/formula_audit/license_arrays.rbi | 7 + .../dsl/rubo_cop/cop/formula_audit/lines.rbi | 7 + .../cop/formula_audit/mac_os_on_linux.rbi | 7 + .../rubo_cop/cop/formula_audit/mpi_check.rbi | 7 + .../formula_audit/on_system_conditionals.rbi | 7 + .../rubo_cop/cop/formula_audit/py_pi_urls.rbi | 7 + .../cop/formula_audit/pyoxidizer_check.rbi | 7 + .../cop/formula_audit/python_versions.rbi | 7 + .../cop/formula_audit/quic_tls_check.rbi | 7 + .../cop/formula_audit/safe_popen_commands.rbi | 7 + .../cop/formula_audit/shell_variables.rbi | 7 + .../single_generate_completions_dsl_call.rbi | 7 + .../dsl/rubo_cop/cop/formula_audit/urls.rbi | 7 + .../cop/formula_audit_strict/make_check.rbi | 7 + .../cop/formula_audit_strict/requirements.rbi | 7 + .../cop/formula_audit_strict/rust_check.rbi | 7 + .../cop/formula_audit_strict/test_present.rbi | 7 + .../sorbet/rbi/gems/parlour@8.1.0.rbi | 16 +- .../Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi | 4 +- .../sorbet/rbi/gems/rspec-github@2.4.0.rbi | 44 +- .../sorbet/rbi/gems/rspec-its@1.3.0.rbi | 44 +- .../sorbet/rbi/gems/rspec-retry@0.6.2.rbi | 380 +++++++++--------- .../sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi | 46 +-- .../sorbet/rbi/gems/rubocop-ast@1.30.0.rbi | 6 +- .../sorbet/rbi/gems/rubocop-md@1.2.2.rbi | 2 +- .../sorbet/rbi/gems/rubocop@1.60.2.rbi | 28 +- .../Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi | 30 +- .../sorbet/rbi/gems/tapioca@0.12.0.rbi | 40 +- .../sorbet/rbi/gems/yard-sorbet@0.8.1.rbi | 2 +- 33 files changed, 468 insertions(+), 321 deletions(-) create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi create mode 100644 Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi new file mode 100644 index 0000000000..f74eb0de22 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::AssertStatements`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::AssertStatements`. + +class RuboCop::Cop::FormulaAudit::AssertStatements; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi new file mode 100644 index 0000000000..afdcd0520d --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ClassInheritance`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ClassInheritance`. + +class RuboCop::Cop::FormulaAudit::ClassInheritance; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi new file mode 100644 index 0000000000..5da5345c4a --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ClassName`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ClassName`. + +class RuboCop::Cop::FormulaAudit::ClassName; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi new file mode 100644 index 0000000000..ac7bd57cd7 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Comments`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Comments`. + +class RuboCop::Cop::FormulaAudit::Comments; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi new file mode 100644 index 0000000000..8713cd0c11 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::LicenseArrays`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::LicenseArrays`. + +class RuboCop::Cop::FormulaAudit::LicenseArrays; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi new file mode 100644 index 0000000000..63c9683ba6 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Lines`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Lines`. + +class RuboCop::Cop::FormulaAudit::Lines; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi new file mode 100644 index 0000000000..4756be69d0 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::MacOSOnLinux`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::MacOSOnLinux`. + +class RuboCop::Cop::FormulaAudit::MacOSOnLinux; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi new file mode 100644 index 0000000000..8cb02f1b1c --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::MpiCheck`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::MpiCheck`. + +class RuboCop::Cop::FormulaAudit::MpiCheck; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi new file mode 100644 index 0000000000..3c31d80fff --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::OnSystemConditionals`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::OnSystemConditionals`. + +class RuboCop::Cop::FormulaAudit::OnSystemConditionals; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi new file mode 100644 index 0000000000..396070d077 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PyPiUrls`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PyPiUrls`. + +class RuboCop::Cop::FormulaAudit::PyPiUrls; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi new file mode 100644 index 0000000000..8a1d3fb90b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PyoxidizerCheck`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PyoxidizerCheck`. + +class RuboCop::Cop::FormulaAudit::PyoxidizerCheck; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi new file mode 100644 index 0000000000..b337d5f950 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PythonVersions`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PythonVersions`. + +class RuboCop::Cop::FormulaAudit::PythonVersions; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi new file mode 100644 index 0000000000..00c50d5ced --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::QuicTLSCheck`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::QuicTLSCheck`. + +class RuboCop::Cop::FormulaAudit::QuicTLSCheck; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi new file mode 100644 index 0000000000..6b2f9cc064 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::SafePopenCommands`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::SafePopenCommands`. + +class RuboCop::Cop::FormulaAudit::SafePopenCommands; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi new file mode 100644 index 0000000000..f1dfbf889f --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ShellVariables`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ShellVariables`. + +class RuboCop::Cop::FormulaAudit::ShellVariables; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi new file mode 100644 index 0000000000..c89323128b --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall`. + +class RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi new file mode 100644 index 0000000000..8d2db0b574 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Urls`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Urls`. + +class RuboCop::Cop::FormulaAudit::Urls; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi new file mode 100644 index 0000000000..65afcd4e01 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::MakeCheck`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::MakeCheck`. + +class RuboCop::Cop::FormulaAuditStrict::MakeCheck; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi new file mode 100644 index 0000000000..924633f348 --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::Requirements`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::Requirements`. + +class RuboCop::Cop::FormulaAuditStrict::Requirements; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi new file mode 100644 index 0000000000..871097ff3c --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::RustCheck`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::RustCheck`. + +class RuboCop::Cop::FormulaAuditStrict::RustCheck; end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi new file mode 100644 index 0000000000..736592dcba --- /dev/null +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi @@ -0,0 +1,7 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::TestPresent`. +# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::TestPresent`. + +class RuboCop::Cop::FormulaAuditStrict::TestPresent; end diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi index a5a1976383..ff888b396b 100644 --- a/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi @@ -913,7 +913,7 @@ class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject # @param block [T.proc.params(x: Attribute).void, nil] # @return [Attribute] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def create_attr(*args, **_arg1, &blk); end # source://parlour//lib/parlour/rbi_generator/namespace.rb#472 @@ -1121,7 +1121,7 @@ class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject # @return [Array] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def type_aliases(*args, **_arg1, &blk); end private @@ -1885,7 +1885,7 @@ class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject # @param block [T.proc.params(x: Attribute).void, nil] # @return [Attribute] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def create_attr(*args, **_arg1, &blk); end # source://parlour//lib/parlour/rbs_generator/namespace.rb#347 @@ -2052,7 +2052,7 @@ class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject # @return [Array] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def type_aliases(*args, **_arg1, &blk); end private @@ -2395,7 +2395,7 @@ class Parlour::TypeParser::IntermediateSig < ::T::Struct prop :params, T.nilable(T::Array[::Parser::AST::Node]) class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2450,7 +2450,7 @@ class Parlour::TypedObject # @param comment [String, Array] # @return [void] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def add_comments(*args, **_arg1, &blk); end # source://parlour//lib/parlour/typed_object.rb#32 @@ -2471,7 +2471,7 @@ class Parlour::TypedObject # @return [String] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def inspect(*args, **_arg1, &blk); end # source://parlour//lib/parlour/typed_object.rb#26 @@ -2480,7 +2480,7 @@ class Parlour::TypedObject # @return [String] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def to_s(*args, **_arg1, &blk); end protected diff --git a/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi b/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi index 2326ef5648..e27079cfd0 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi @@ -1820,7 +1820,7 @@ class RBI::Rewriters::Merge::Conflict < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11230/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2037,7 +2037,7 @@ class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11230/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.4.0.rbi index 331134320a..061a23053d 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.4.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.4.0.rbi @@ -7,70 +7,70 @@ # source://rspec-github//lib/rspec/github/version.rb#3 module RSpec class << self - # source://rspec-core/3.12.2/lib/rspec/core.rb#70 + # source://rspec-core/3.13.0/lib/rspec/core.rb#70 def clear_examples; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#85 + # source://rspec-core/3.13.0/lib/rspec/core.rb#85 def configuration; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def configuration=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#97 + # source://rspec-core/3.13.0/lib/rspec/core.rb#97 def configure; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#194 + # source://rspec-core/3.13.0/lib/rspec/core.rb#194 def const_missing(name); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def context(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#122 + # source://rspec-core/3.13.0/lib/rspec/core.rb#122 def current_example; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#128 + # source://rspec-core/3.13.0/lib/rspec/core.rb#128 def current_example=(example); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#154 + # source://rspec-core/3.13.0/lib/rspec/core.rb#154 def current_scope; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#134 + # source://rspec-core/3.13.0/lib/rspec/core.rb#134 def current_scope=(scope); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def describe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def example_group(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#58 + # source://rspec-core/3.13.0/lib/rspec/core.rb#58 def reset; end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_context(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples_for(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#160 + # source://rspec-core/3.13.0/lib/rspec/core.rb#160 def world; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def world=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xdescribe(*args, &example_group_block); end 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 index 1e7a6429bb..71a72a8f88 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi @@ -7,70 +7,70 @@ # source://rspec-its//lib/rspec/its/version.rb#1 module RSpec class << self - # source://rspec-core/3.12.2/lib/rspec/core.rb#70 + # source://rspec-core/3.13.0/lib/rspec/core.rb#70 def clear_examples; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#85 + # source://rspec-core/3.13.0/lib/rspec/core.rb#85 def configuration; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def configuration=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#97 + # source://rspec-core/3.13.0/lib/rspec/core.rb#97 def configure; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#194 + # source://rspec-core/3.13.0/lib/rspec/core.rb#194 def const_missing(name); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def context(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#122 + # source://rspec-core/3.13.0/lib/rspec/core.rb#122 def current_example; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#128 + # source://rspec-core/3.13.0/lib/rspec/core.rb#128 def current_example=(example); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#154 + # source://rspec-core/3.13.0/lib/rspec/core.rb#154 def current_scope; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#134 + # source://rspec-core/3.13.0/lib/rspec/core.rb#134 def current_scope=(scope); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def describe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def example_group(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#58 + # source://rspec-core/3.13.0/lib/rspec/core.rb#58 def reset; end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_context(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples_for(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#160 + # source://rspec-core/3.13.0/lib/rspec/core.rb#160 def world; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def world=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xdescribe(*args, &example_group_block); end 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 index 67beecc289..40915385e3 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi @@ -7,70 +7,70 @@ # source://rspec-retry//lib/rspec/retry/version.rb#1 module RSpec class << self - # source://rspec-core/3.12.2/lib/rspec/core.rb#70 + # source://rspec-core/3.13.0/lib/rspec/core.rb#70 def clear_examples; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#85 + # source://rspec-core/3.13.0/lib/rspec/core.rb#85 def configuration; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def configuration=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#97 + # source://rspec-core/3.13.0/lib/rspec/core.rb#97 def configure; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#194 + # source://rspec-core/3.13.0/lib/rspec/core.rb#194 def const_missing(name); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def context(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#122 + # source://rspec-core/3.13.0/lib/rspec/core.rb#122 def current_example; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#128 + # source://rspec-core/3.13.0/lib/rspec/core.rb#128 def current_example=(example); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#154 + # source://rspec-core/3.13.0/lib/rspec/core.rb#154 def current_scope; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#134 + # source://rspec-core/3.13.0/lib/rspec/core.rb#134 def current_scope=(scope); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def describe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def example_group(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#58 + # source://rspec-core/3.13.0/lib/rspec/core.rb#58 def reset; end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_context(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples_for(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#160 + # source://rspec-core/3.13.0/lib/rspec/core.rb#160 def world; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def world=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xdescribe(*args, &example_group_block); end end end @@ -78,14 +78,14 @@ end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#2 module RSpec::Core class << self - # source://rspec-core/3.12.2/lib/rspec/core.rb#181 + # source://rspec-core/3.13.0/lib/rspec/core.rb#181 def path_to_executable; end end end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#3 class RSpec::Core::Example - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#186 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#186 def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end # Returns the value of attribute attempts. @@ -103,305 +103,305 @@ class RSpec::Core::Example # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#6 def clear_exception; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#174 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#174 def clock; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#174 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#174 def clock=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#76 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#76 def description; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#388 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#388 def display_exception; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#396 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#396 def display_exception=(ex); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#132 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#132 def duplicate_with(metadata_overrides = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#230 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#230 def example_group; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#170 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#170 def example_group_instance; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#158 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#158 def exception; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def execution_result; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#439 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#439 def fail_with_exception(reporter, exception); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def file_path; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def full_description; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#117 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#117 def id; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#220 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#220 def inspect; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#87 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#87 def inspect_output; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#456 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#456 def instance_exec(*args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def location; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#96 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#96 def location_rerun_argument; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#163 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#163 def metadata; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def pending; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#234 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#234 def pending?; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#226 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#226 def reporter; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#111 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#111 def rerun_argument; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#246 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#246 def run(example_group_instance, reporter); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#425 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#425 def set_aggregate_failures_exception(exception); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#412 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#412 def set_exception(exception); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#49 def skip; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#449 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#449 def skip_with_exception(reporter, exception); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#238 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#238 def skipped?; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#220 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#220 def to_s; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#148 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#148 def update_inherited_metadata(updates); end private - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#534 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#534 def assign_generated_description; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#478 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#478 def finish(reporter); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#543 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#543 def generate_description; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#462 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#462 def hooks; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#550 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#550 def location_description; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#530 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#530 def mocks_need_verification?; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#498 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#498 def record_finished(status, reporter); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#516 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#516 def run_after_example; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#503 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#503 def run_before_example; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#473 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#473 def start(reporter); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#524 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#524 def verify_mocks; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#508 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#508 def with_around_and_singleton_context_hooks; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#466 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#466 def with_around_example_hooks; end class << self - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#48 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#48 def delegate_to_metadata(key); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#122 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#122 def parse_id(id); end end end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#10 class RSpec::Core::Example::Procsy - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#362 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#362 def initialize(example, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def <<(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def ==(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def ===(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def >>(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def [](*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def arity(*a, &b); end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#15 def attempts; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def binding(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#350 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#350 def call(*args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def clock(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def clock=(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def clone(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def curry(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def description(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def dup(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def duplicate_with(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def eql?(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#333 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#333 def example; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def example_group(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def example_group_instance(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def exception(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#374 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#374 def executed?; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def execution_result(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def file_path(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def full_description(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def hash(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def id(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#379 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#379 def inspect; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def inspect_output(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def lambda?(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def location(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def location_rerun_argument(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def metadata(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def parameters(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def pending(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def pending?(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def reporter(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def rerun_argument(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def ruby2_keywords(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#350 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#350 def run(*args, &block); end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#11 def run_with_retry(opts = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def skip(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def skipped?(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def source_location(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#358 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#358 def to_proc; end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#339 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#339 def update_inherited_metadata(*a, &b); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#369 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#369 def wrap(&block); end - # source://rspec-core/3.12.2/lib/rspec/core/example.rb#346 + # source://rspec-core/3.13.0/lib/rspec/core/example.rb#346 def yield(*a, &b); end end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#25 class RSpec::Core::ExampleGroup - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#707 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#707 def initialize(inspect_output = T.unsafe(nil)); end # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#34 @@ -410,222 +410,222 @@ class RSpec::Core::ExampleGroup # source://rspec-retry//lib/rspec_ext/rspec_ext.rb#26 def clear_memoized; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#99 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#99 def described_class; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#713 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#713 def inspect; end private - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#758 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#758 def method_missing(name, *args, **_arg2); end class << self - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#367 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#367 def add_example(example); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#529 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#529 def before_context_ivars; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#466 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#466 def children; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def context(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#542 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#542 def currently_executing_a_context_hook?; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#667 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#667 def declaration_locations; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#246 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#246 def define_example_group_method(name, metadata = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#145 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#145 def define_example_method(name, extra_options = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#317 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#317 def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#76 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#76 def delegate_to_metadata(*names); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#460 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#460 def descendant_filtered_examples; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#503 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#503 def descendants; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def describe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#78 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#78 def described_class; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#85 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#85 def description; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#700 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#700 def each_instance_variable_for_example(group); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#518 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#518 def ensure_example_groups_are_configured; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def example(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def example_group(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#450 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#450 def examples; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def fcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def fdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def fexample(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#78 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#78 def file_path; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#455 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#455 def filtered_examples; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#379 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#379 def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def fit(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def focus(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#655 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#655 def for_filtered_examples(reporter, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def fspecify(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#675 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#675 def id; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#40 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#40 def idempotently_define_singleton_method(name, &definition); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#343 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#343 def include_context(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#353 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#353 def include_examples(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def it(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#318 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#318 def it_behaves_like(name, *args, &customization_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#318 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#318 def it_should_behave_like(name, *args, &customization_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#78 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#78 def location; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#51 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#51 def metadata; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#485 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#485 def next_runnable_index_for(file); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#625 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#625 def ordering_strategy; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#508 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#508 def parent_groups; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def pending(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#373 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#373 def remove_example(example); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#359 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#359 def reset_memoized; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#599 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#599 def run(reporter = T.unsafe(nil)); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#585 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#585 def run_after_context_hooks(example_group_instance); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#547 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#547 def run_before_context_hooks(example_group_instance); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#641 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#641 def run_examples(reporter); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#410 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#410 def set_it_up(description, args, registration_collection, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#685 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#685 def set_ivars(instance, ivars); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def skip(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def specify(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#534 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#534 def store_before_context_ivars(example_group_instance); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#395 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#395 def subclass(parent, description, args, registration_collection, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#562 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#562 def superclass_before_context_ivars; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#71 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#71 def superclass_metadata; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#513 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#513 def top_level?; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#680 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#680 def top_level_description; end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#476 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#476 def traverse_tree_until(&block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#727 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#727 def update_inherited_metadata(updates); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#61 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#61 def with_replaced_metadata(meta); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def xcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#247 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#247 def xdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def xexample(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def xit(*all_args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#146 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#146 def xspecify(*all_args, &block); end private - # source://rspec-core/3.12.2/lib/rspec/core/example_group.rb#742 + # source://rspec-core/3.13.0/lib/rspec/core/example_group.rb#742 def method_missing(name, *args); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi index a5ed7d683c..361cb21747 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi @@ -7,70 +7,70 @@ # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#6 module RSpec class << self - # source://rspec-core/3.12.2/lib/rspec/core.rb#70 + # source://rspec-core/3.13.0/lib/rspec/core.rb#70 def clear_examples; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#85 + # source://rspec-core/3.13.0/lib/rspec/core.rb#85 def configuration; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def configuration=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#97 + # source://rspec-core/3.13.0/lib/rspec/core.rb#97 def configure; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#194 + # source://rspec-core/3.13.0/lib/rspec/core.rb#194 def const_missing(name); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def context(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#122 + # source://rspec-core/3.13.0/lib/rspec/core.rb#122 def current_example; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#128 + # source://rspec-core/3.13.0/lib/rspec/core.rb#128 def current_example=(example); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#154 + # source://rspec-core/3.13.0/lib/rspec/core.rb#154 def current_scope; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#134 + # source://rspec-core/3.13.0/lib/rspec/core.rb#134 def current_scope=(scope); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def describe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def example_group(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def fdescribe(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#58 + # source://rspec-core/3.13.0/lib/rspec/core.rb#58 def reset; end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_context(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core/shared_example_group.rb#110 + # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110 def shared_examples_for(name, *args, &block); end - # source://rspec-core/3.12.2/lib/rspec/core.rb#160 + # source://rspec-core/3.13.0/lib/rspec/core.rb#160 def world; end - # source://rspec-core/3.12.2/lib/rspec/core.rb#49 + # source://rspec-core/3.13.0/lib/rspec/core.rb#49 def world=(_arg0); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xcontext(*args, &example_group_block); end - # source://rspec-core/3.12.2/lib/rspec/core/dsl.rb#42 + # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42 def xdescribe(*args, &example_group_block); end end end @@ -90,7 +90,7 @@ module RSpec::Sorbet::Doubles # @return [void] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def allow_instance_doubles!(*args, **_arg1, &blk); end # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#36 diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi index 9c22af394c..b1271d9bb1 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi @@ -6027,6 +6027,9 @@ class RuboCop::AST::ProcessedSource # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#49 def lines; end + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#95 + def parse(src, *args); end + # Returns the value of attribute parser_error. # # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 @@ -6089,9 +6092,6 @@ class RuboCop::AST::ProcessedSource # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#299 def last_token_index(range_or_node); end - # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#196 - def parse(source, ruby_version); end - # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#230 def parser_class(ruby_version); end diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-md@1.2.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-md@1.2.2.rbi index 46f2f8afe0..d475fc1786 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop-md@1.2.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-md@1.2.2.rbi @@ -1,4 +1,4 @@ -# typed: false +# typed: true # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rubocop-md` gem. diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi index 714dea99c4..60d86eb255 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi @@ -1,4 +1,4 @@ -# typed: false +# typed: true # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `rubocop` gem. @@ -56928,6 +56928,18 @@ class RuboCop::Runner # source://rubocop//lib/rubocop/runner.rb#56 def errors; end + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#74 + def file_finished(file, offenses); end + + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#56 + def file_offense_cache(file); end + + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#48 + def get_processed_source(*args); end + + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#62 + def inspect_file(*args); end + # source://rubocop//lib/rubocop/runner.rb#67 def run(paths); end @@ -56982,12 +56994,6 @@ class RuboCop::Runner # source://rubocop//lib/rubocop/runner.rb#357 def extract_ruby_sources(processed_source); end - # source://rubocop//lib/rubocop/runner.rb#245 - def file_finished(file, offenses); end - - # source://rubocop//lib/rubocop/runner.rb#174 - def file_offense_cache(file); end - # source://rubocop//lib/rubocop/runner.rb#162 def file_offenses(file); end @@ -57003,12 +57009,6 @@ class RuboCop::Runner # source://rubocop//lib/rubocop/runner.rb#414 def formatter_set; end - # source://rubocop//lib/rubocop/runner.rb#470 - def get_processed_source(file); end - - # source://rubocop//lib/rubocop/runner.rb#342 - def inspect_file(processed_source, team = T.unsafe(nil)); end - # source://rubocop//lib/rubocop/runner.rb#115 def inspect_files(files); end @@ -57250,7 +57250,7 @@ class RuboCop::TargetFinder # @api private # @return [Boolean] # - # source://rubocop//lib/rubocop/target_finder.rb#172 + # source://rubocop-md/1.2.2/lib/rubocop/markdown/rubocop_ext.rb#88 def ruby_file?(file); end # @api private diff --git a/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi b/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi index b9e3328903..3911630528 100644 --- a/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi @@ -958,7 +958,7 @@ class Spoom::Coverage::D3::ColorPalette < ::T::Struct prop :strong, ::String class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -1298,7 +1298,7 @@ class Spoom::Coverage::Snapshot < ::T::Struct sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) } def from_obj(obj); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -1450,7 +1450,7 @@ class Spoom::Deadcode::Definition < ::T::Struct def module?; end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2343,7 +2343,7 @@ class Spoom::Deadcode::Reference < ::T::Struct def method?; end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2593,7 +2593,7 @@ class Spoom::Deadcode::Send < ::T::Struct def each_arg_assoc(&block); end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2613,7 +2613,7 @@ class Spoom::ExecResult < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2821,7 +2821,7 @@ class Spoom::FileTree::Node < ::T::Struct def path; end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2887,7 +2887,7 @@ class Spoom::Git::Commit < ::T::Struct def timestamp; end class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end # Parse a line formated as `%h %at` into a `Commit` @@ -2999,7 +2999,7 @@ class Spoom::LSP::Diagnostic < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3032,7 +3032,7 @@ class Spoom::LSP::DocumentSymbol < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3090,7 +3090,7 @@ class Spoom::LSP::Hover < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3115,7 +3115,7 @@ class Spoom::LSP::Location < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3178,7 +3178,7 @@ class Spoom::LSP::Position < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3216,7 +3216,7 @@ class Spoom::LSP::Range < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -3282,7 +3282,7 @@ class Spoom::LSP::SignatureHelp < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) } def from_json(json); end - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi index 4fe9bdd2f4..6a2146ae2d 100644 --- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi @@ -54,7 +54,7 @@ module RBI; end # source://tapioca//lib/tapioca/rbi_ext/model.rb#5 class RBI::Tree < ::RBI::NodeWithComments - # source://rbi/0.1.6/lib/rbi/model.rb#119 + # source://rbi/0.1.8/lib/rbi/model.rb#119 sig do params( loc: T.nilable(::RBI::Loc), @@ -64,19 +64,19 @@ class RBI::Tree < ::RBI::NodeWithComments end def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # source://rbi/0.1.6/lib/rbi/model.rb#126 + # source://rbi/0.1.8/lib/rbi/model.rb#126 sig { params(node: ::RBI::Node).void } def <<(node); end - # source://rbi/0.1.6/lib/rbi/printer.rb#226 + # source://rbi/0.1.8/lib/rbi/printer.rb#226 sig { override.params(v: ::RBI::Printer).void } def accept_printer(v); end - # source://rbi/0.1.6/lib/rbi/rewriters/add_sig_templates.rb#66 + # source://rbi/0.1.8/lib/rbi/rewriters/add_sig_templates.rb#66 sig { params(with_todo_comment: T::Boolean).void } def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end - # source://rbi/0.1.6/lib/rbi/rewriters/annotate.rb#49 + # source://rbi/0.1.8/lib/rbi/rewriters/annotate.rb#49 sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void } def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end @@ -140,23 +140,23 @@ class RBI::Tree < ::RBI::NodeWithComments end def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end - # source://rbi/0.1.6/lib/rbi/rewriters/deannotate.rb#41 + # source://rbi/0.1.8/lib/rbi/rewriters/deannotate.rb#41 sig { params(annotation: ::String).void } def deannotate!(annotation); end - # source://rbi/0.1.6/lib/rbi/model.rb#132 + # source://rbi/0.1.8/lib/rbi/model.rb#132 sig { returns(T::Boolean) } def empty?; end - # source://rbi/0.1.6/lib/rbi/rewriters/group_nodes.rb#38 + # source://rbi/0.1.8/lib/rbi/rewriters/group_nodes.rb#38 sig { void } def group_nodes!; end - # source://rbi/0.1.6/lib/rbi/index.rb#68 + # source://rbi/0.1.8/lib/rbi/index.rb#68 sig { returns(::RBI::Index) } def index; end - # source://rbi/0.1.6/lib/rbi/rewriters/merge_trees.rb#324 + # source://rbi/0.1.8/lib/rbi/rewriters/merge_trees.rb#324 sig do params( other: ::RBI::Tree, @@ -167,23 +167,23 @@ class RBI::Tree < ::RBI::NodeWithComments end def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end - # source://rbi/0.1.6/lib/rbi/rewriters/nest_non_public_methods.rb#46 + # source://rbi/0.1.8/lib/rbi/rewriters/nest_non_public_methods.rb#46 sig { void } def nest_non_public_methods!; end - # source://rbi/0.1.6/lib/rbi/rewriters/nest_singleton_methods.rb#36 + # source://rbi/0.1.8/lib/rbi/rewriters/nest_singleton_methods.rb#36 sig { void } def nest_singleton_methods!; end - # source://rbi/0.1.6/lib/rbi/model.rb#110 + # source://rbi/0.1.8/lib/rbi/model.rb#110 sig { returns(T::Array[::RBI::Node]) } def nodes; end - # source://rbi/0.1.6/lib/rbi/printer.rb#233 + # source://rbi/0.1.8/lib/rbi/printer.rb#233 sig { override.returns(T::Boolean) } def oneline?; end - # source://rbi/0.1.6/lib/rbi/rewriters/sort_nodes.rb#119 + # source://rbi/0.1.8/lib/rbi/rewriters/sort_nodes.rb#119 sig { void } def sort_nodes!; end @@ -204,7 +204,7 @@ class RBI::TypedParam < ::T::Struct const :type, ::String class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -1121,7 +1121,7 @@ class Tapioca::ConfigHelper::ConfigError < ::T::Struct const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart] class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -1132,7 +1132,7 @@ class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct const :colors, T::Array[::Symbol] class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end @@ -2432,7 +2432,7 @@ class Tapioca::Loaders::Loader # @param engine [T.class_of(Rails::Engine)] # @return [Array] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def eager_load_paths(*args, **_arg1, &blk); end # source://tapioca//lib/tapioca/loaders/loader.rb#198 @@ -3340,7 +3340,7 @@ module Tapioca::Static::SymbolLoader # @return [Array] # - # source://sorbet-runtime/0.5.11222/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 def engines(*args, **_arg1, &blk); end # source://tapioca//lib/tapioca/static/symbol_loader.rb#82 diff --git a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi index 1d44a3b556..6dcfa5ff8d 100644 --- a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi @@ -381,7 +381,7 @@ class YARDSorbet::TStructProp < ::T::Struct const :types, T::Array[::String] class << self - # source://sorbet-runtime/0.5.11222/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 def inherited(s); end end end From 1b84c5c8c2dd6fbc9ff0731b46feea5e96bc638d Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Fri, 9 Feb 2024 11:40:35 -0800 Subject: [PATCH 13/15] Add upstream JSON generator modules --- Library/Homebrew/dev-cmd/determine-test-runners.rb | 2 +- Library/Homebrew/requirements/macos_requirement.rb | 4 ++-- Library/Homebrew/sorbet/rbi/upstream.rbi | 8 ++++++++ 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/Library/Homebrew/dev-cmd/determine-test-runners.rb b/Library/Homebrew/dev-cmd/determine-test-runners.rb index 68639819e8..9a94f20ca9 100755 --- a/Library/Homebrew/dev-cmd/determine-test-runners.rb +++ b/Library/Homebrew/dev-cmd/determine-test-runners.rb @@ -55,7 +55,7 @@ module Homebrew github_output = ENV.fetch("GITHUB_OUTPUT") File.open(github_output, "a") do |f| - f.puts("runners=#{T.unsafe(runners).to_json}") + f.puts("runners=#{runners.to_json}") f.puts("runners_present=#{runners.present?}") end end diff --git a/Library/Homebrew/requirements/macos_requirement.rb b/Library/Homebrew/requirements/macos_requirement.rb index 3371ca25b3..b58a3ce50d 100644 --- a/Library/Homebrew/requirements/macos_requirement.rb +++ b/Library/Homebrew/requirements/macos_requirement.rb @@ -118,8 +118,8 @@ class MacOSRequirement < Requirement def to_json(options) comp = @comparator.to_s - return T.unsafe({ comp => @version.map(&:to_s) }).to_json(options) if @version.is_a?(Array) + return { comp => @version.map(&:to_s) }.to_json(options) if @version.is_a?(Array) - T.unsafe({ comp => [@version.to_s] }).to_json(options) + { comp => [@version.to_s] }.to_json(options) end end diff --git a/Library/Homebrew/sorbet/rbi/upstream.rbi b/Library/Homebrew/sorbet/rbi/upstream.rbi index 877921e54f..1c15b292f8 100644 --- a/Library/Homebrew/sorbet/rbi/upstream.rbi +++ b/Library/Homebrew/sorbet/rbi/upstream.rbi @@ -3,6 +3,14 @@ # This file contains temporary definitions for fixes that have # been submitted upstream to https://github.com/sorbet/sorbet. +# https://github.com/sorbet/sorbet/pull/7682 +class Array + include JSON::Ext::Generator::GeneratorMethods::Array +end +class Hash + include JSON::Ext::Generator::GeneratorMethods::Hash +end + # https://github.com/sorbet/sorbet/pull/7650 class Etc::Group < Struct sig { returns(Integer) } From aab04229d18b4daa38a5510c1d047297d06e1582 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sat, 10 Feb 2024 11:03:50 -0800 Subject: [PATCH 14/15] Code review fixes --- Library/Homebrew/extend/ENV/shared.rb | 4 ++-- Library/Homebrew/rubocops/cask/extend/node.rbi | 16 ++++++++-------- .../Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi | 4 ++-- .../Homebrew/sorbet/tapioca/compilers/rubocop.rb | 9 +++++---- 4 files changed, 17 insertions(+), 16 deletions(-) diff --git a/Library/Homebrew/extend/ENV/shared.rb b/Library/Homebrew/extend/ENV/shared.rb index c4749280a2..e9bfd35bd9 100644 --- a/Library/Homebrew/extend/ENV/shared.rb +++ b/Library/Homebrew/extend/ENV/shared.rb @@ -60,10 +60,10 @@ module SharedEnvExtension end private :reset - sig { returns(T::Hash[String, String]) } + sig { returns(T::Hash[String, T.nilable(String)]) } def remove_cc_etc keys = %w[CC CXX OBJC OBJCXX LD CPP CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS LDFLAGS CPPFLAGS] - keys.to_h { |key| [key, T.must(delete(key))] } + keys.to_h { |key| [key, delete(key)] } end sig { params(newflags: String).void } diff --git a/Library/Homebrew/rubocops/cask/extend/node.rbi b/Library/Homebrew/rubocops/cask/extend/node.rbi index f3db682720..d5850b29bd 100644 --- a/Library/Homebrew/rubocops/cask/extend/node.rbi +++ b/Library/Homebrew/rubocops/cask/extend/node.rbi @@ -1,11 +1,8 @@ # typed: strict class RuboCop::AST::Node - sig { returns(T::Boolean) } - def arch_variable?; end - - sig { returns(T::Boolean) } - def begin_block?; end + sig { returns(T.nilable(RuboCop::AST::SendNode)) } + def method_node; end sig { returns(T.nilable(RuboCop::AST::Node)) } def block_body; end @@ -13,9 +10,12 @@ class RuboCop::AST::Node sig { returns(T::Boolean) } def cask_block?; end - sig { returns(T.nilable(RuboCop::AST::Node)) } - def method_node; end - sig { returns(T::Boolean) } def on_system_block?; end + + sig { returns(T::Boolean) } + def arch_variable?; end + + sig { returns(T::Boolean) } + def begin_block?; end end diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi index 60d86eb255..86b12d92ac 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.60.2.rbi @@ -41602,7 +41602,7 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # source://rubocop-sorbet/0.7.6/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#18 + # source://rubocop-sorbet/0.7.7/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#18 def on_assignment(value); end # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#127 @@ -41620,7 +41620,7 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#217 def splat_value(param0 = T.unsafe(nil)); end - # source://rubocop-sorbet/0.7.6/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#12 + # source://rubocop-sorbet/0.7.7/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#12 def t_let(param0 = T.unsafe(nil)); end private diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb index d1c1b5934a..da03f37a3b 100644 --- a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb +++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb @@ -24,9 +24,9 @@ module Tapioca # exclude vendored code, to avoid contradicting their RBI files !path.include?("/vendor/bundle/ruby/") && # exclude source code that already has an RBI file - !Pathname("#{path}i").exist? && + !File.exist?("#{path}i") && # exclude source code that doesn't use the DSLs - File.readlines(path).grep(/def_node_/).any? + File.readlines(path).any?(/def_node_/) end end @@ -40,7 +40,8 @@ module Tapioca # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb # https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern/method_definer.rb # The type signatures below could maybe be stronger, but I only wanted to avoid errors: - if source.start_with?("def_node_matcher") + case source + when /\Adef_node_matcher/ # https://github.com/Shopify/tapioca/blob/3341a9b/lib/tapioca/rbi_ext/model.rb#L89 klass.create_method( method_name.to_s, @@ -51,7 +52,7 @@ module Tapioca ], return_type: "T.untyped", ) - elsif source.start_with?("def_node_search") + when /\Adef_node_search/ klass.create_method( method_name.to_s, parameters: [ From 439c8c18198f124f6145d422a6d0bd83cd68b0d1 Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 11 Feb 2024 20:47:22 -0800 Subject: [PATCH 15/15] Tighten up the types --- .../rbi/dsl/rubo_cop/cop/cask/variables.rbi | 11 ++- .../cop/formula_audit/components_order.rbi | 2 +- .../cop/formula_audit/dependency_order.rbi | 81 +++++++++++++++---- .../formula_audit/deprecate_disable_date.rbi | 11 ++- .../deprecate_disable_reason.rbi | 11 ++- .../generate_completions_dsl.rbi | 22 ++++- .../rubo_cop/cop/formula_audit/git_urls.rbi | 2 +- .../rubo_cop/cop/formula_audit/licenses.rbi | 2 +- .../cop/formula_audit/miscellaneous.rbi | 37 +++++++-- .../cop/formula_audit/option_declarations.rbi | 11 ++- .../rubo_cop/cop/formula_audit/patches.rbi | 11 ++- .../dsl/rubo_cop/cop/formula_audit/test.rbi | 11 ++- .../dsl/rubo_cop/cop/formula_audit/text.rbi | 11 ++- .../cop/formula_audit_strict/git_urls.rbi | 2 +- .../cop/formula_audit_strict/text.rbi | 22 ++++- .../rbi/dsl/rubo_cop/cop/formula_cop.rbi | 44 ++++++++-- .../rbi/dsl/rubo_cop/cop/homebrew/blank.rbi | 2 +- .../rubo_cop/cop/homebrew/compact_blank.rbi | 4 +- .../cop/homebrew/move_to_extend_os.rbi | 2 +- .../rubo_cop/cop/homebrew/negate_include.rbi | 2 +- .../dsl/rubo_cop/cop/homebrew/presence.rbi | 4 +- .../rbi/dsl/rubo_cop/cop/homebrew/present.rbi | 2 +- .../homebrew/safe_navigation_with_blank.rbi | 2 +- .../cop/on_system_conditionals_helper.rbi | 59 +++++++++++--- .../sorbet/rbi/gems/parlour@8.1.0.rbi | 16 ++-- .../Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi | 4 +- .../sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi | 2 +- .../Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi | 30 +++---- .../sorbet/rbi/gems/tapioca@0.12.0.rbi | 10 +-- .../sorbet/rbi/gems/yard-sorbet@0.8.1.rbi | 2 +- .../sorbet/tapioca/compilers/rubocop.rb | 6 +- 31 files changed, 325 insertions(+), 113 deletions(-) diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi index 03b3da5b04..77af835550 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::Variables`. class RuboCop::Cop::Cask::Variables - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def variable_assignment(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def variable_assignment(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi index 470b6df1b8..0a56de7564 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::FormulaAudit::ComponentsOrder sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def depends_on_node?(*node, **kwargs, &block); end + def depends_on_node?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi index bbb86d9b5b..02c57246a9 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi @@ -5,30 +5,79 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DependencyOrder`. class RuboCop::Cop::FormulaAudit::DependencyOrder - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def build_with_dependency_node(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def build_with_dependency_node(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def buildtime_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def buildtime_dependency?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def dependency_name_node(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def dependency_name_node(node, *pattern, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def depends_on_node?(*node, **kwargs, &block); end + def depends_on_node?(node, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def negate_normal_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def negate_normal_dependency?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def optional_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def optional_dependency?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def recommended_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def recommended_dependency?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def test_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def test_dependency?(node, *pattern, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def uses_from_macos_node?(*node, **kwargs, &block); end + def uses_from_macos_node?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi index 18b209a2fd..2a67553b9c 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableDate`. class RuboCop::Cop::FormulaAudit::DeprecateDisableDate - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def date(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def date(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi index f3473654f4..efaff881a2 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableReason`. class RuboCop::Cop::FormulaAudit::DeprecateDisableReason - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def reason(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def reason(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi index 152d2b3456..0e20431584 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi @@ -5,9 +5,23 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL`. class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def correctable_shell_completion_node(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def correctable_shell_completion_node(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def shell_completion_node(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def shell_completion_node(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi index 5b0dd74ad9..65adb7065b 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::FormulaAudit::GitUrls sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def url_has_revision?(*node, **kwargs, &block); end + def url_has_revision?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi index 5eab79ac26..3cab20a1c7 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::FormulaAudit::Licenses sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def license_exception?(*node, **kwargs, &block); end + def license_exception?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi index aa46db2eb2..ce9addd4c5 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi @@ -5,18 +5,39 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Miscellaneous`. class RuboCop::Cop::FormulaAudit::Miscellaneous - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def conditional_dependencies(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def conditional_dependencies(node, *pattern, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def destructure_hash(*node, **kwargs, &block); end + def destructure_hash(node, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def formula_path_strings(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def formula_path_strings(node, *pattern, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def hash_dep(*node, **kwargs, &block); end + def hash_dep(node, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def languageNodeModule?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def languageNodeModule?(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi index eb94588521..4503647f98 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::OptionDeclarations`. class RuboCop::Cop::FormulaAudit::OptionDeclarations - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def depends_on_build_with(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def depends_on_build_with(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi index 81db7b48e2..1abdb46964 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Patches`. class RuboCop::Cop::FormulaAudit::Patches - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def patch_data?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def patch_data?(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi index 0d9fcb3e5a..856ae2a708 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Test`. class RuboCop::Cop::FormulaAudit::Test - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def test_calls(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def test_calls(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi index e45270488b..efd1de8751 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi @@ -5,6 +5,13 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Text`. class RuboCop::Cop::FormulaAudit::Text - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def prefix_path(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def prefix_path(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi index db8f61d930..25e1615fe1 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::FormulaAuditStrict::GitUrls sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def url_has_tag?(*node, **kwargs, &block); end + def url_has_tag?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi index 1444a5206e..f096d342d1 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi @@ -5,9 +5,23 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::Text`. class RuboCop::Cop::FormulaAuditStrict::Text - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def interpolated_share_path_starts_with(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def interpolated_share_path_starts_with(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def share_path_starts_with(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def share_path_starts_with(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi index aaea44eacc..574dcfd615 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi @@ -5,15 +5,43 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaCop`. class RuboCop::Cop::FormulaCop - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def dependency_name_hash_match?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def dependency_name_hash_match?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def dependency_type_hash_match?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def dependency_type_hash_match?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def required_dependency?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def required_dependency?(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T::Boolean) } - def required_dependency_name?(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T::Boolean) + end + def required_dependency_name?(node, *pattern, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi index 3973833606..e4d2a8fac0 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::Homebrew::Blank sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def nil_or_empty?(*node, **kwargs, &block); end + def nil_or_empty?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi index c3063b7941..4b9fb22729 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi @@ -6,8 +6,8 @@ class RuboCop::Cop::Homebrew::CompactBlank sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def reject_with_block?(*node, **kwargs, &block); end + def reject_with_block?(node, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def reject_with_block_pass?(*node, **kwargs, &block); end + def reject_with_block_pass?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi index fa23bca2c3..ba982aa1eb 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::Homebrew::MoveToExtendOS sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def os_check?(*node, **kwargs, &block); end + def os_check?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi index d254d9f06c..76e5d9d585 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::Homebrew::NegateInclude sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def negate_include_call?(*node, **kwargs, &block); end + def negate_include_call?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi index 45fbcf61f0..da15dd2ebd 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi @@ -6,8 +6,8 @@ class RuboCop::Cop::Homebrew::Presence sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def redundant_negative_receiver_and_other(*node, **kwargs, &block); end + def redundant_negative_receiver_and_other(node, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def redundant_receiver_and_other(*node, **kwargs, &block); end + def redundant_receiver_and_other(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi index 0a02fdf79e..69bc2befde 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::Homebrew::Present sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def exists_and_not_empty?(*node, **kwargs, &block); end + def exists_and_not_empty?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi index 22567eb453..9543900bfc 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi @@ -6,5 +6,5 @@ class RuboCop::Cop::Homebrew::SafeNavigationWithBlank sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def safe_navigation_blank_in_conditional?(*node, **kwargs, &block); end + def safe_navigation_blank_in_conditional?(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi index bd34168242..5e1ab8346f 100644 --- a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi +++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi @@ -5,24 +5,59 @@ # Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::OnSystemConditionalsHelper`. module RuboCop::Cop::OnSystemConditionalsHelper - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def hardware_cpu_search(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def hardware_cpu_search(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def if_arch_node_search(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def if_arch_node_search(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def if_base_os_node_search(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def if_base_os_node_search(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def if_macos_version_node_search(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def if_macos_version_node_search(node, *pattern, **kwargs, &block); end - sig { params(node: T.untyped, block: T.untyped).returns(T.untyped) } - def macos_version_comparison_search(*node, &block); end + sig do + params( + node: RuboCop::AST::Node, + pattern: T.any(String, Symbol), + kwargs: T.untyped, + block: T.untyped + ).returns(T.untyped) + end + def macos_version_comparison_search(node, *pattern, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def on_macos_version_method_call(*node, **kwargs, &block); end + def on_macos_version_method_call(node, **kwargs, &block); end sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) } - def on_system_method_call(*node, **kwargs, &block); end + def on_system_method_call(node, **kwargs, &block); end end diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi index ff888b396b..4dc97171ff 100644 --- a/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/parlour@8.1.0.rbi @@ -913,7 +913,7 @@ class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject # @param block [T.proc.params(x: Attribute).void, nil] # @return [Attribute] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def create_attr(*args, **_arg1, &blk); end # source://parlour//lib/parlour/rbi_generator/namespace.rb#472 @@ -1121,7 +1121,7 @@ class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject # @return [Array] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def type_aliases(*args, **_arg1, &blk); end private @@ -1885,7 +1885,7 @@ class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject # @param block [T.proc.params(x: Attribute).void, nil] # @return [Attribute] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def create_attr(*args, **_arg1, &blk); end # source://parlour//lib/parlour/rbs_generator/namespace.rb#347 @@ -2052,7 +2052,7 @@ class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject # @return [Array] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def type_aliases(*args, **_arg1, &blk); end private @@ -2395,7 +2395,7 @@ class Parlour::TypeParser::IntermediateSig < ::T::Struct prop :params, T.nilable(T::Array[::Parser::AST::Node]) class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2450,7 +2450,7 @@ class Parlour::TypedObject # @param comment [String, Array] # @return [void] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def add_comments(*args, **_arg1, &blk); end # source://parlour//lib/parlour/typed_object.rb#32 @@ -2471,7 +2471,7 @@ class Parlour::TypedObject # @return [String] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def inspect(*args, **_arg1, &blk); end # source://parlour//lib/parlour/typed_object.rb#26 @@ -2480,7 +2480,7 @@ class Parlour::TypedObject # @return [String] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def to_s(*args, **_arg1, &blk); end protected diff --git a/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi b/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi index e27079cfd0..7bd1548db4 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rbi@0.1.8.rbi @@ -1820,7 +1820,7 @@ class RBI::Rewriters::Merge::Conflict < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2037,7 +2037,7 @@ class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi index 361cb21747..47bc9a1156 100644 --- a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi @@ -90,7 +90,7 @@ module RSpec::Sorbet::Doubles # @return [void] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def allow_instance_doubles!(*args, **_arg1, &blk); end # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#36 diff --git a/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi b/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi index 3911630528..efd197c01a 100644 --- a/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/spoom@1.2.4.rbi @@ -958,7 +958,7 @@ class Spoom::Coverage::D3::ColorPalette < ::T::Struct prop :strong, ::String class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -1298,7 +1298,7 @@ class Spoom::Coverage::Snapshot < ::T::Struct sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) } def from_obj(obj); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -1450,7 +1450,7 @@ class Spoom::Deadcode::Definition < ::T::Struct def module?; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2343,7 +2343,7 @@ class Spoom::Deadcode::Reference < ::T::Struct def method?; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2593,7 +2593,7 @@ class Spoom::Deadcode::Send < ::T::Struct def each_arg_assoc(&block); end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2613,7 +2613,7 @@ class Spoom::ExecResult < ::T::Struct def to_s; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2821,7 +2821,7 @@ class Spoom::FileTree::Node < ::T::Struct def path; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2887,7 +2887,7 @@ class Spoom::Git::Commit < ::T::Struct def timestamp; end class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end # Parse a line formated as `%h %at` into a `Commit` @@ -2999,7 +2999,7 @@ class Spoom::LSP::Diagnostic < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3032,7 +3032,7 @@ class Spoom::LSP::DocumentSymbol < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3090,7 +3090,7 @@ class Spoom::LSP::Hover < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3115,7 +3115,7 @@ class Spoom::LSP::Location < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3178,7 +3178,7 @@ class Spoom::LSP::Position < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3216,7 +3216,7 @@ class Spoom::LSP::Range < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -3282,7 +3282,7 @@ class Spoom::LSP::SignatureHelp < ::T::Struct sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) } def from_json(json); end - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi index 6a2146ae2d..a8e31ba854 100644 --- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.12.0.rbi @@ -204,7 +204,7 @@ class RBI::TypedParam < ::T::Struct const :type, ::String class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -1121,7 +1121,7 @@ class Tapioca::ConfigHelper::ConfigError < ::T::Struct const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart] class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -1132,7 +1132,7 @@ class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct const :colors, T::Array[::Symbol] class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end @@ -2432,7 +2432,7 @@ class Tapioca::Loaders::Loader # @param engine [T.class_of(Rails::Engine)] # @return [Array] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def eager_load_paths(*args, **_arg1, &blk); end # source://tapioca//lib/tapioca/loaders/loader.rb#198 @@ -3340,7 +3340,7 @@ module Tapioca::Static::SymbolLoader # @return [Array] # - # source://sorbet-runtime/0.5.11237/lib/types/private/methods/_methods.rb#252 + # source://sorbet-runtime/0.5.11247/lib/types/private/methods/_methods.rb#252 def engines(*args, **_arg1, &blk); end # source://tapioca//lib/tapioca/static/symbol_loader.rb#82 diff --git a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi index 6dcfa5ff8d..358a00217f 100644 --- a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi @@ -381,7 +381,7 @@ class YARDSorbet::TStructProp < ::T::Struct const :types, T::Array[::String] class << self - # source://sorbet-runtime/0.5.11237/lib/types/struct.rb#13 + # source://sorbet-runtime/0.5.11247/lib/types/struct.rb#13 def inherited(s); end end end diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb index da03f37a3b..d264f9c252 100644 --- a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb +++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb @@ -46,7 +46,7 @@ module Tapioca klass.create_method( method_name.to_s, parameters: [ - create_rest_param("node", type: "RuboCop::AST::Node"), + create_param("node", type: "RuboCop::AST::Node"), create_kw_rest_param("kwargs", type: "T.untyped"), create_block_param("block", type: "T.untyped"), ], @@ -56,7 +56,9 @@ module Tapioca klass.create_method( method_name.to_s, parameters: [ - create_rest_param("node", type: "T.untyped"), + create_param("node", type: "RuboCop::AST::Node"), + create_rest_param("pattern", type: "T.any(String, Symbol)"), + create_kw_rest_param("kwargs", type: "T.untyped"), create_block_param("block", type: "T.untyped"), ], return_type: method_name.to_s.end_with?("?") ? "T::Boolean" : "T.untyped",