From b16a865e4d936184c6b7fb79a4c7a6f4ec713035 Mon Sep 17 00:00:00 2001 From: Jamie Magee Date: Mon, 4 Mar 2024 13:18:51 -0800 Subject: [PATCH] Add and configure `rubocop-rspec` [`rubocop-rspec`][1] is a set of RuboCop rules for RSpec. This change adds a dependency on `rubocop-rspec` and configures it in our `.rubocop.yml`. 2 rules, `RSpec/FilePath` and `RSpec/SpecFilePathFormat`, were disabled to keep the diff small. They can be re-enabled later. Also, `rubocop-rspec` follows RuboCop's versioning, and newly introduced rules are not enabled by default. As you can see, the minor version is `27`, so there are quite a few rules that we should evaluate and explicitly enable. [1]: https://docs.rubocop.org/rubocop-rspec/index.html --- .rubocop.yml | 10 + Gemfile | 1 + Gemfile.lock | 9 + common/dependabot-common.gemspec | 1 + sorbet/rbi/gems/regexp_parser@2.8.3.rbi | 3745 +- sorbet/rbi/gems/rubocop-ast@1.30.0.rbi | 7197 +- sorbet/rbi/gems/rubocop-capybara@2.20.0.rbi | 1207 + .../rbi/gems/rubocop-factory_bot@2.25.1.rbi | 927 + sorbet/rbi/gems/rubocop-rspec@2.27.1.rbi | 8537 +++ sorbet/rbi/gems/rubocop@1.58.0.rbi | 57115 +++++++++++++++- updater/Gemfile.lock | 9 + 11 files changed, 78752 insertions(+), 6 deletions(-) create mode 100644 sorbet/rbi/gems/rubocop-capybara@2.20.0.rbi create mode 100644 sorbet/rbi/gems/rubocop-factory_bot@2.25.1.rbi create mode 100644 sorbet/rbi/gems/rubocop-rspec@2.27.1.rbi diff --git a/.rubocop.yml b/.rubocop.yml index af8a1386722..00118ec58e9 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -1,6 +1,7 @@ --- require: - rubocop-performance + - rubocop-rspec - rubocop-sorbet AllCops: @@ -341,6 +342,15 @@ Sorbet/StrictSigil: Sorbet/StrongSigil: Exclude: - "**/spec/**/*" +RSpec: + Include: + - "**/spec/**/*" + +# TODO: Fix these and re-enable +RSpec/FilePath: + Enabled: false +RSpec/SpecFilePathFormat: + Enabled: false # TODO these were temporarily disabled during the Ruby 2.7 -> 3.1 upgrade # in order to keep the upgrade diff small, they will be enabled/fixed in diff --git a/Gemfile b/Gemfile index 6b90fb75a6e..4ca7275adf5 100644 --- a/Gemfile +++ b/Gemfile @@ -37,6 +37,7 @@ deps_shared_with_common = %w( rspec-sorbet rubocop rubocop-performance + rubocop-rspec rubocop-sorbet stackprof turbo_tests diff --git a/Gemfile.lock b/Gemfile.lock index 6650945b7ed..b459582c04d 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -288,9 +288,17 @@ GEM unicode-display_width (>= 2.4.0, < 3.0) rubocop-ast (1.30.0) parser (>= 3.2.1.0) + rubocop-capybara (2.20.0) + rubocop (~> 1.41) + rubocop-factory_bot (2.25.1) + rubocop (~> 1.41) rubocop-performance (1.19.1) rubocop (>= 1.7.0, < 2.0) rubocop-ast (>= 0.4.0) + rubocop-rspec (2.27.1) + rubocop (~> 1.40) + rubocop-capybara (~> 2.17) + rubocop-factory_bot (~> 2.22) rubocop-sorbet (0.7.6) rubocop (>= 0.90.0) ruby-progressbar (1.13.0) @@ -381,6 +389,7 @@ DEPENDENCIES rspec-sorbet (~> 1.9.2) rubocop (~> 1.58.0) rubocop-performance (~> 1.19.0) + rubocop-rspec (~> 2.27.1) rubocop-sorbet (~> 0.7.3) sorbet (= 0.5.11274) stackprof (~> 0.2.16) diff --git a/common/dependabot-common.gemspec b/common/dependabot-common.gemspec index b07c2237e65..82559198072 100644 --- a/common/dependabot-common.gemspec +++ b/common/dependabot-common.gemspec @@ -52,6 +52,7 @@ Gem::Specification.new do |spec| spec.add_development_dependency "rspec-sorbet", "~> 1.9.2" spec.add_development_dependency "rubocop", "~> 1.58.0" spec.add_development_dependency "rubocop-performance", "~> 1.19.0" + spec.add_development_dependency "rubocop-rspec", "~> 2.27.1" spec.add_development_dependency "rubocop-sorbet", "~> 0.7.3" spec.add_development_dependency "stackprof", "~> 0.2.16" spec.add_development_dependency "turbo_tests", "~> 2.2.0" diff --git a/sorbet/rbi/gems/regexp_parser@2.8.3.rbi b/sorbet/rbi/gems/regexp_parser@2.8.3.rbi index c145daaca2c..024b8599006 100644 --- a/sorbet/rbi/gems/regexp_parser@2.8.3.rbi +++ b/sorbet/rbi/gems/regexp_parser@2.8.3.rbi @@ -4,5 +4,3746 @@ # This is an autogenerated file for types exported from the `regexp_parser` gem. # Please instead update this file by running `bin/tapioca gem regexp_parser`. -# THIS IS AN EMPTY RBI FILE. -# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem +# source://regexp_parser//lib/regexp_parser/expression/shared.rb#1 +module Regexp::Expression; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5 +class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 + def alternatives; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#6 +Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative + +# A sequence of expressions, used by Alternation as one of its alternatives. +# +# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3 +class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2 +module Regexp::Expression::Anchor; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18 +Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20 +Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3 +class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5 +class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8 +class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#19 +Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#21 +Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22 +Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6 +class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9 +class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11 +class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16 +class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14 +class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13 +class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#64 +module Regexp::Expression::Assertion; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#65 +class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#67 +class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#70 +class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#68 +class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71 +class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22 + def human_name; end +end + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#74 +Regexp::Expression::Backref = Regexp::Expression::Backreference + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#2 +module Regexp::Expression::Backreference; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3 +class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155 + def match_length; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6 + def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#140 + def referential?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34 +class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base + # @return [Name] a new instance of Name + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#38 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23 + def human_name; end + + # Returns the value of attribute name. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35 + def name; end + + # Returns the value of attribute name. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35 + def reference; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50 +class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#62 +class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name + # @return [NameRecursionLevel] a new instance of NameRecursionLevel + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#65 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute recursion_level. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#63 + def recursion_level; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24 +class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base + # @return [Number] a new instance of Number + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#28 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25 + def human_name; end + + # Returns the value of attribute number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25 + def number; end + + # Returns the value of attribute number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25 + def reference; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49 +class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#51 +class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#53 +class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative + # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute recursion_level. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54 + def recursion_level; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#44 +class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number + # Returns the value of attribute effective_number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 + def effective_number; end + + # Sets the attribute effective_number + # + # @param value the value to set the attribute effective_number to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 + def effective_number=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26 + def human_name; end + + # Returns the value of attribute effective_number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45 + def reference; end +end + +# source://regexp_parser//lib/regexp_parser/expression/base.rb#2 +class Regexp::Expression::Base + include ::Regexp::Expression::Shared + extend ::Regexp::Expression::Shared::ClassMethods + + # @return [Base] a new instance of Base + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#5 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8 + def =~(string, offset = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25 + def a?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25 + def ascii_classes?; end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#60 + def attributes; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8 + def case_insensitive?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def conditional_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def conditional_level=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20 + def d?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20 + def default_classes?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14 + def extended?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14 + def free_spacing?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#47 + def greedy?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8 + def i?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8 + def ignore_case?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#51 + def lazy?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def level=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3 + def m?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8 + def match(string, offset = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3 + def match?(string); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3 + def matches?(string); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3 + def multiline?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 + def nesting_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def options; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def options=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#56 + def possessive?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 + def quantifier; end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#17 + def quantify(*args); end + + # Deprecated. Prefer `#repetitions` which has a more uniform interface. + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#26 + def quantity; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/base.rb#51 + def reluctant?; end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#31 + def repetitions; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def set_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def set_level=(_arg0); end + + # %l Level (depth) of the expression. Returns 'root' for the root + # expression, returns zero or higher for all others. + # + # %> Indentation at expression's level. + # + # %x Index of the expression at its depth. Available when using + # the sprintf_tree method only. + # + # %s Start offset within the whole expression. + # %e End offset within the whole expression. + # %S Length of expression. + # + # %o Coded offset and length, same as '@%s+%S' + # + # %y Type of expression. + # %k Token of expression. + # %i ID, same as '%y:%k' + # %c Class name + # + # %q Quantifier info, as {m[,M]} + # %Q Quantifier text + # + # %z Quantifier min + # %Z Quantifier max + # + # %t Base text of the expression (excludes quantifier, if any) + # %~t Full text if the expression is terminal, otherwise %i + # %T Full text of the expression (includes quantifier, if any) + # + # %b Basic info, same as '%o %i' + # %m Most info, same as '%b %q' + # %a All info, same as '%m %t' + # + # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37 + def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end + + # %l Level (depth) of the expression. Returns 'root' for the root + # expression, returns zero or higher for all others. + # + # %> Indentation at expression's level. + # + # %x Index of the expression at its depth. Available when using + # the sprintf_tree method only. + # + # %s Start offset within the whole expression. + # %e End offset within the whole expression. + # %S Length of expression. + # + # %o Coded offset and length, same as '@%s+%S' + # + # %y Type of expression. + # %k Token of expression. + # %i ID, same as '%y:%k' + # %c Class name + # + # %q Quantifier info, as {m[,M]} + # %Q Quantifier text + # + # %z Quantifier min + # %Z Quantifier max + # + # %t Base text of the expression (excludes quantifier, if any) + # %~t Full text if the expression is terminal, otherwise %i + # %T Full text of the expression (includes quantifier, if any) + # + # %b Basic info, same as '%o %i' + # %m Most info, same as '%b %q' + # %a All info, same as '%m %t' + # + # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37 + def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def te; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def te=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def text; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def text=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#60 + def to_h; end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#9 + def to_re(format = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def token; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def token=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def ts; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def ts=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def type; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def type=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30 + def u?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30 + def unicode_classes?; end + + # source://regexp_parser//lib/regexp_parser/expression/base.rb#21 + def unquantified_clone; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14 + def x?; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2 +class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression + # @return [CharacterSet] a new instance of CharacterSet + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#9 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#19 + def close; end + + # Returns the value of attribute closed. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def closed; end + + # Sets the attribute closed + # + # @param value the value to set the attribute closed to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def closed=(_arg0); end + + # Returns the value of attribute closed. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def closed?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#15 + def negate; end + + # Returns the value of attribute negative. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def negated?; end + + # Returns the value of attribute negative. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def negative; end + + # Sets the attribute negative + # + # @param value the value to set the attribute negative to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def negative=(_arg0); end + + # Returns the value of attribute negative. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3 + def negative?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#15 + def parts; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3 +class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5 +class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6 +Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3 +class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#8 + def <<(exp); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#14 + def complete?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#16 + def parts; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4 + def ts; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2 +module Regexp::Expression::CharacterType; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5 +class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3 +class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6 +class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15 +class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8 +class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14 +class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7 +class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9 +class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13 +class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11 +class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12 +class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10 +class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8 +class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33 + def human_name; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#130 + def comment?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2 +module Regexp::Expression::Conditional; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25 +class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34 + def human_name; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#9 +class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 + def match_length; end + + # Name or number of the referenced capturing group that determines state. + # Returns a String if reference is by name, Integer if by number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#14 + def reference; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19 + def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#141 + def referential?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#27 +class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30 + def <<(exp); end + + # @raise [TooManyBranches] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34 + def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end + + # @raise [TooManyBranches] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34 + def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50 + def branches; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46 + def condition; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41 + def condition=(exp); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#17 + def parts; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54 + def reference; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58 + def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#142 + def referential?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3 +class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error + # @return [TooManyBranches] a new instance of TooManyBranches + # + # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#4 + def initialize; end +end + +# alias for symmetry between Token::* and Expression::* +# +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#101 +Regexp::Expression::Escape = Regexp::Expression::EscapeSequence + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#2 +module Regexp::Expression::EscapeSequence; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#63 +class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64 + def char; end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#70 + def control_sequence_to_s(control_sequence); end + + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#75 + def meta_char_to_codepoint(meta_char); end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#27 +class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28 +class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3 +class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#9 + def char; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4 + def codepoint; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29 +class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37 +class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#39 +class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base + # @raise [NoMethodError] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40 + def char; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#48 + def chars; end + + # @raise [NoMethodError] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#44 + def codepoint; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#52 + def codepoints; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#81 +class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82 + def codepoint; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30 +class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#36 +class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#21 +class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22 + def char; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#87 +class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88 + def codepoint; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#93 +class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94 + def codepoint; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31 +class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#57 +class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58 + def char; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32 +class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33 +class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34 +class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2 +class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 + def match_length; end + + # @raise [Regexp::Parser::Error] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#3 + def quantify(*_args); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#135 + def decorative?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2 +module Regexp::Expression::Group; end + +# Special case. Absence group can match 0.. chars, irrespective of content. +# TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})` +# +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#19 +class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#20 +class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3 +class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#18 + def parts; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#40 +class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#37 + def human_name; end + + # Returns the value of attribute number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + def identifier; end + + # Returns the value of attribute number. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + def number; end + + # Sets the attribute number + # + # @param value the value to set the attribute number to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + def number=(_arg0); end + + # Returns the value of attribute number_at_level. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + def number_at_level; end + + # Sets the attribute number_at_level + # + # @param value the value to set the attribute number_at_level to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41 + def number_at_level=(_arg0); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#126 + def capturing?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#60 +class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#20 + def parts; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#131 + def comment?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#136 + def decorative?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#45 +class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture + # @return [Named] a new instance of Named + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#49 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#38 + def human_name; end + + # Returns the value of attribute name. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46 + def identifier; end + + # Returns the value of attribute name. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46 + def name; end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#54 + def initialize_copy(orig); end +end + +# TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no +# longer inherit from Group because it is effectively a terminal expression. +# +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#23 +class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base + # Returns the value of attribute option_changes. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24 + def option_changes; end + + # Sets the attribute option_changes + # + # @param value the value to set the attribute option_changes to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24 + def option_changes=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#31 + def quantify(*args); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#26 + def initialize_copy(orig); end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#6 +class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base + # @return [Passive] a new instance of Passive + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#9 + def initialize(*_arg0); end + + # Sets the attribute implicit + # + # @param value the value to set the attribute implicit to. + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#7 + def implicit=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14 + def implicit?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#19 + def parts; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2 +module Regexp::Expression::Keep; end + +# TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression +# that contains all expressions to its left. +# +# source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5 +class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2 +class Regexp::Expression::Literal < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105 + def match_length; end +end + +# source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85 +Regexp::Expression::MatchLength = Regexp::MatchLength + +# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#14 +Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#121 +Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty + +# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2 +class Regexp::Expression::PosixClass < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#7 + def name; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#3 + def negative?; end +end + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#13 +Regexp::Expression::Posixclass = Regexp::Expression::PosixClass + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#120 +Regexp::Expression::Property = Regexp::Expression::UnicodeProperty + +# TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and +# call super in #initialize, but raise in #quantifier= and #quantify, +# or introduce an Expression::Quantifiable intermediate class. +# Or actually allow chaining as a more concise but tricky solution than PR#69. +# +# source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6 +class Regexp::Expression::Quantifier + include ::Regexp::Expression::Shared + extend ::Regexp::Expression::Shared::ClassMethods + + # @return [Quantifier] a new instance of Quantifier + # + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11 + def initialize(*args); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def conditional_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def conditional_level=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def custom_to_s_handling=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 + def greedy?; end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 + def lazy?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def level=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#42 + def max; end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#38 + def min; end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#46 + def mode; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 + def nesting_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def options; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def options=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def parent=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 + def possessive?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def pre_quantifier_decorations=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14 + def quantifier; end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31 + def reluctant?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def set_level; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def set_level=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def te; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def te=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def text; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def text=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#19 + def to_h; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def token; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def token=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def ts; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def ts=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def type; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def type=(_arg0); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#52 + def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#64 + def derived_data; end +end + +# source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9 +Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2 +class Regexp::Expression::Root < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41 + def human_name; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#3 + def build(options = T.unsafe(nil)); end + end +end + +# A sequence of expressions. Differs from a Subexpressions by how it handles +# quantifiers, as it applies them to its last element instead of itself as +# a whole subexpression. +# +# Used as the base class for the Alternation alternatives, Conditional +# branches, and CharacterSet::Intersection intersected sequences. +# +# source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8 +class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27 + def quantify(token, *args); end + + # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23 + def ts; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#10 + def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end + end +end + +# abstract class +# +# source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3 +class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression + # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#12 + def <<(exp); end + + # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#16 + def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 + def operands; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9 + def operator; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#22 + def parts; end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 + def sequences; end + + # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8 + def ts; end +end + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#25 +Regexp::Expression::Set = Regexp::Expression::CharacterSet + +# source://regexp_parser//lib/regexp_parser/expression/shared.rb#2 +module Regexp::Expression::Shared + mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods + + # Deep-compare two expressions for equality. + # + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 + def ==(other); end + + # Deep-compare two expressions for equality. + # + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 + def ===(other); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#51 + def base_length; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#124 + def capturing?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#96 + def coded_offset; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#128 + def comment?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#133 + def decorative?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#47 + def ends_at(include_quantifier = T.unsafe(nil)); end + + # Deep-compare two expressions for equality. + # + # When changing the conditions, please make sure to update + # #pretty_print_instance_variables so that it includes all relevant values. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101 + def eql?(other); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55 + def full_length; end + + # default implementation, e.g. "atomic group", "hex escape", "word type", .. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#4 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#3 + def inspect; end + + # Test if this expression has the given test_token, and optionally a given + # test_type. + # + # # Any expressions + # exp.is? :* # always returns true + # + # # is it a :capture + # exp.is? :capture + # + # # is it a :character and a :set + # exp.is? :character, :set + # + # # is it a :meta :dot + # exp.is? :dot, :meta + # + # # is it a :meta or :escape :dot + # exp.is? :dot, [:meta, :escape] + # + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36 + def is?(test_token, test_type = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#100 + def nesting_level=(lvl); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#92 + def offset; end + + # Test if this expression matches an entry in the given scope spec. + # + # A scope spec can be one of: + # + # . An array: Interpreted as a set of tokens, tested for inclusion + # of the expression's token. + # + # . A hash: Where the key is interpreted as the expression type + # and the value is either a symbol or an array. In this + # case, when the scope is a hash, one_of? calls itself to + # evaluate the key's value. + # + # . A symbol: matches the expression's token or type, depending on + # the level of the call. If one_of? is called directly with + # a symbol then it will always be checked against the + # type of the expression. If it's being called for a value + # from a hash, it will be checked against the token of the + # expression. + # + # # any expression + # exp.one_of?(:*) # always true + # + # # like exp.type?(:group) + # exp.one_of?(:group) + # + # # any expression of type meta + # exp.one_of?(:meta => :*) + # + # # meta dots and alternations + # exp.one_of?(:meta => [:dot, :alternation]) + # + # # meta dots and any set tokens + # exp.one_of?({meta: [:dot], set: :*}) + # + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#75 + def one_of?(scope, top = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#111 + def optional?; end + + # default implementation + # + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#4 + def parts; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#84 + def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end + + # Make pretty-print work despite #inspect implementation. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#12 + def pretty_print(q); end + + # Called by pretty_print (ruby/pp) and #inspect. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#17 + def pretty_print_instance_variables; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#115 + def quantified?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#106 + def quantifier=(qtf); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#88 + def quantifier_affix(expression_format = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#138 + def referential?; end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#43 + def starts_at; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#120 + def terminal?; end + + # #to_s reproduces the original source, as an unparser would. + # + # It takes an optional format argument. + # + # Example: + # + # lit = Regexp::Parser.parse(/a +/x)[0] + # + # lit.to_s # => 'a+' # default; with quantifier + # lit.to_s(:full) # => 'a+' # default; with quantifier + # lit.to_s(:base) # => 'a' # without quantifier + # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations + # + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72 + def to_s(format = T.unsafe(nil)); end + + # #to_s reproduces the original source, as an unparser would. + # + # It takes an optional format argument. + # + # Example: + # + # lit = Regexp::Parser.parse(/a +/x)[0] + # + # lit.to_s # => 'a+' # default; with quantifier + # lit.to_s(:full) # => 'a+' # default; with quantifier + # lit.to_s(:base) # => 'a' # without quantifier + # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations + # + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72 + def to_str(format = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#37 + def token_class; end + + # Test if this expression has the given test_type, which can be either + # a symbol or an array of symbols to check against the expression's type. + # + # # is it a :group expression + # exp.type? :group + # + # # is it a :set, or :meta + # exp.type? [:set, :meta] + # + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#13 + def type?(test_type); end + + private + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#18 + def init_from_token_and_options(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#32 + def initialize_copy(orig); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#10 + def intersperse(expressions, separator); end + + class << self + # @private + # + # source://regexp_parser//lib/regexp_parser/expression/shared.rb#5 + def included(mod); end + end +end + +# filled in ./methods/*.rb +# +# source://regexp_parser//lib/regexp_parser/expression/shared.rb#3 +module Regexp::Expression::Shared::ClassMethods + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#125 + def capturing?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#129 + def comment?; end + + # Convenience method to init a valid Expression without a Regexp::Token + # + # @raise [ArgumentError] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#5 + def construct(params = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#15 + def construct_defaults; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#134 + def decorative?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#139 + def referential?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#121 + def terminal?; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#25 + def token_class; end +end + +# source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2 +class Regexp::Expression::Subexpression < ::Regexp::Expression::Base + include ::Enumerable + + # @return [Subexpression] a new instance of Subexpression + # + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#7 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#20 + def <<(exp); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def [](*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def at(*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#33 + def dig(*indices); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def each(*args, &block); end + + # Traverses the expression, passing each recursive child to the + # given block. + # If the block takes two arguments, the indices of the children within + # their parents are also passed to it. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#8 + def each_expression(include_self = T.unsafe(nil), &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def empty?(*args, &block); end + + # Returns the value of attribute expressions. + # + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 + def expressions; end + + # Sets the attribute expressions + # + # @param value the value to set the attribute expressions to. + # + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5 + def expressions=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#50 + def extract_quantifier_target(quantifier_description); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def fetch(*args, &block); end + + # Returns a new array with the results of calling the given block once + # for every expression. If a block is not given, returns an array with + # each expression and its level index as an array. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#56 + def flat_map(include_self = T.unsafe(nil), &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def index(*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118 + def inner_match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def join(*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def last(*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def length(*args, &block); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#21 + def parts; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102 + def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102 + def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#39 + def te; end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#43 + def to_h; end + + # Traverses the subexpression (depth-first, pre-order) and calls the given + # block for each expression with three arguments; the traversal event, + # the expression, and the index of the expression within its parent. + # + # The event argument is passed as follows: + # + # - For subexpressions, :enter upon entering the subexpression, and + # :exit upon exiting it. + # + # - For terminal expressions, :visit is called once. + # + # Returns self. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32 + def traverse(include_self = T.unsafe(nil), &block); end + + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27 + def values_at(*args, &block); end + + # Traverses the subexpression (depth-first, pre-order) and calls the given + # block for each expression with three arguments; the traversal event, + # the expression, and the index of the expression within its parent. + # + # The event argument is passed as follows: + # + # - For subexpressions, :enter upon entering the subexpression, and + # :exit upon exiting it. + # + # - For terminal expressions, :visit is called once. + # + # Returns self. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32 + def walk(include_self = T.unsafe(nil), &block); end + + protected + + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#66 + def each_expression_with_index(&block); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#73 + def each_expression_without_index(&block); end + + private + + # Override base method to clone the expressions as well. + # + # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13 + def initialize_copy(orig); end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#122 + def terminal?; end + end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#2 +module Regexp::Expression::UnicodeProperty; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#112 +class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#17 +class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18 +class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#35 +class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19 +class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36 +class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3 +class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98 + def match_length; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#8 + def name; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4 + def negative?; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#12 + def shortcut; end +end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20 +class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116 +class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21 +class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#101 +module Regexp::Expression::UnicodeProperty::Codepoint; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#104 +class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102 +class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105 +class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106 +class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108 +class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107 +class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109 +class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113 +class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22 +class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114 +class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23 +class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#38 +module Regexp::Expression::UnicodeProperty::Letter; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#41 +class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39 +class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42 +class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44 +class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46 +class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47 +class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45 +class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43 +class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24 +class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#50 +module Regexp::Expression::UnicodeProperty::Mark; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#53 +class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51 +class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54 +class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57 +class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55 +class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56 +class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#33 +class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#60 +module Regexp::Expression::UnicodeProperty::Number; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#63 +class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61 +class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64 +class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65 +class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66 +class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25 +class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26 +class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#69 +module Regexp::Expression::UnicodeProperty::Punctuation; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#72 +class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70 +class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76 +class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73 +class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74 +class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78 +class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77 +class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75 +class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79 +class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115 +class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#82 +module Regexp::Expression::UnicodeProperty::Separator; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#85 +class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83 +class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87 +class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88 +class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86 +class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27 +class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#91 +module Regexp::Expression::UnicodeProperty::Symbol; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#94 +class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92 +class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96 +class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95 +class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97 +class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98 +class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28 +class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29 +class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31 +class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30 +class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11 +class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace + # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42 + def human_name; end + + # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#12 + def merge(exp); end +end + +# A very thin wrapper around the scanner that breaks quantified literal runs, +# collects emitted tokens into an array, calculates their nesting depth, and +# normalizes tokens for the parser, and checks if they are implemented by the +# given syntax flavor. +# +# source://regexp_parser//lib/regexp_parser/lexer.rb#5 +class Regexp::Lexer + # source://regexp_parser//lib/regexp_parser/lexer.rb#71 + def emit(token); end + + # source://regexp_parser//lib/regexp_parser/lexer.rb#20 + def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end + + private + + # source://regexp_parser//lib/regexp_parser/lexer.rb#91 + def ascend(type, token); end + + # Returns the value of attribute block. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def block=(_arg0); end + + # if a codepoint list is followed by a quantifier, that quantifier applies + # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc' + # c.f. #break_literal. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#143 + def break_codepoint_list(token); end + + # called by scan to break a literal run that is longer than one character + # into two separate tokens when it is followed by a quantifier + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#123 + def break_literal(token); end + + # Returns the value of attribute collect_tokens. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def collect_tokens; end + + # Sets the attribute collect_tokens + # + # @param value the value to set the attribute collect_tokens to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def collect_tokens=(_arg0); end + + # Returns the value of attribute conditional_nesting. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def conditional_nesting; end + + # Sets the attribute conditional_nesting + # + # @param value the value to set the attribute conditional_nesting to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def conditional_nesting=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/lexer.rb#106 + def descend(type, token); end + + # source://regexp_parser//lib/regexp_parser/lexer.rb#162 + def merge_condition(current, last); end + + # Returns the value of attribute nesting. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def nesting; end + + # Sets the attribute nesting + # + # @param value the value to set the attribute nesting to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def nesting=(_arg0); end + + # Returns the value of attribute preprev_token. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def preprev_token; end + + # Sets the attribute preprev_token + # + # @param value the value to set the attribute preprev_token to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def preprev_token=(_arg0); end + + # Returns the value of attribute prev_token. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def prev_token; end + + # Sets the attribute prev_token + # + # @param value the value to set the attribute prev_token to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def prev_token=(_arg0); end + + # Returns the value of attribute set_nesting. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def set_nesting; end + + # Sets the attribute set_nesting + # + # @param value the value to set the attribute set_nesting to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def set_nesting=(_arg0); end + + # Returns the value of attribute shift. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def shift; end + + # Sets the attribute shift + # + # @param value the value to set the attribute shift to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def shift=(_arg0); end + + # Returns the value of attribute tokens. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def tokens; end + + # Sets the attribute tokens + # + # @param value the value to set the attribute tokens to. + # + # source://regexp_parser//lib/regexp_parser/lexer.rb#87 + def tokens=(_arg0); end + + class << self + # source://regexp_parser//lib/regexp_parser/lexer.rb#16 + def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end + + # source://regexp_parser//lib/regexp_parser/lexer.rb#16 + def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end + end +end + +# source://regexp_parser//lib/regexp_parser/lexer.rb#12 +Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/lexer.rb#14 +Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/lexer.rb#7 +Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1 +class Regexp::MatchLength + include ::Enumerable + + # @return [MatchLength] a new instance of MatchLength + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#9 + def initialize(exp, opts = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#24 + def each(opts = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#35 + def endless_each; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#44 + def fixed?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#40 + def include?(length); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#60 + def inspect; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#52 + def max; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#48 + def min; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#56 + def minmax; end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#65 + def to_re; end + + private + + # Returns the value of attribute base_max. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def base_max; end + + # Sets the attribute base_max + # + # @param value the value to set the attribute base_max to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def base_max=(_arg0); end + + # Returns the value of attribute base_min. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def base_min; end + + # Sets the attribute base_min + # + # @param value the value to set the attribute base_min to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def base_min=(_arg0); end + + # Returns the value of attribute exp_class. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def exp_class; end + + # Sets the attribute exp_class + # + # @param value the value to set the attribute exp_class to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def exp_class=(_arg0); end + + # Returns the value of attribute max_rep. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def max_rep; end + + # Sets the attribute max_rep + # + # @param value the value to set the attribute max_rep to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def max_rep=(_arg0); end + + # Returns the value of attribute min_rep. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def min_rep; end + + # Sets the attribute min_rep + # + # @param value the value to set the attribute min_rep to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def min_rep=(_arg0); end + + # Returns the value of attribute reify. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def reify; end + + # Sets the attribute reify + # + # @param value the value to set the attribute reify to. + # + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71 + def reify=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74 + def test_regexp; end + + class << self + # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#4 + def of(obj); end + end +end + +# source://regexp_parser//lib/regexp_parser/version.rb#2 +class Regexp::Parser + include ::Regexp::Expression + + # source://regexp_parser//lib/regexp_parser/parser.rb#25 + def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + + private + + # source://regexp_parser//lib/regexp_parser/parser.rb#573 + def active_opts; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#99 + def anchor(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#262 + def assign_effective_number(exp); end + + # Assigns referenced expressions to refering expressions, e.g. if there is + # an instance of Backreference::Number, its #referenced_expression is set to + # the instance of Group::Capture that it refers to via its number. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#580 + def assign_referenced_expressions; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#227 + def backref(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#202 + def captured_group_count_at_level; end + + # Returns the value of attribute captured_group_counts. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def captured_group_counts; end + + # Sets the attribute captured_group_counts + # + # @param value the value to set the attribute captured_group_counts to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def captured_group_counts=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#569 + def close_completed_character_set_range; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#210 + def close_group; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#537 + def close_set; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#269 + def conditional(token); end + + # Returns the value of attribute conditional_nesting. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def conditional_nesting; end + + # Sets the attribute conditional_nesting + # + # @param value the value to set the attribute conditional_nesting to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def conditional_nesting=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#206 + def count_captured_group; end + + # @yield [node] + # + # source://regexp_parser//lib/regexp_parser/parser.rb#216 + def decrease_nesting; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#305 + def escape(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#60 + def extract_options(input, options); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#349 + def free_space(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#114 + def group(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#508 + def increase_group_level(exp); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#548 + def intersection(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#360 + def keep(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#364 + def literal(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#368 + def meta(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#533 + def negate_set; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#299 + def nest(exp); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#294 + def nest_conditional(exp); end + + # Returns the value of attribute nesting. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def nesting; end + + # Sets the attribute nesting + # + # @param value the value to set the attribute nesting to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def nesting=(_arg0); end + + # Returns the value of attribute node. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def node; end + + # Sets the attribute node + # + # @param value the value to set the attribute node to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def node=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#165 + def open_group(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#526 + def open_set(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#130 + def options_group(token); end + + # Returns the value of attribute options_stack. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def options_stack; end + + # Sets the attribute options_stack + # + # @param value the value to set the attribute options_stack to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def options_stack=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#76 + def parse_token(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#390 + def posixclass(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#397 + def property(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#478 + def quantifier(token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#541 + def range(token); end + + # Returns the value of attribute root. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def root; end + + # Sets the attribute root + # + # @param value the value to set the attribute root to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def root=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#379 + def sequence_operation(klass, token); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#514 + def set(token); end + + # Returns the value of attribute switching_options. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def switching_options; end + + # Sets the attribute switching_options + # + # @param value the value to set the attribute switching_options to. + # + # source://regexp_parser//lib/regexp_parser/parser.rb#56 + def switching_options=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/parser.rb#198 + def total_captured_group_count; end + + # source://regexp_parser//lib/regexp_parser/parser.rb#552 + def type(token); end + + class << self + # source://regexp_parser//lib/regexp_parser/parser.rb#21 + def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + end +end + +# source://regexp_parser//lib/regexp_parser/parser.rb#128 +Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array) + +# base class for all gem-specific errors +# +# source://regexp_parser//lib/regexp_parser/error.rb#3 +class Regexp::Parser::Error < ::StandardError; end + +# source://regexp_parser//lib/regexp_parser/parser.rb#127 +Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/parser.rb#7 +class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end + +# source://regexp_parser//lib/regexp_parser/parser.rb#394 +Regexp::Parser::UP = Regexp::Expression::UnicodeProperty + +# source://regexp_parser//lib/regexp_parser/parser.rb#395 +Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty + +# source://regexp_parser//lib/regexp_parser/parser.rb#15 +class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError + # @return [UnknownTokenError] a new instance of UnknownTokenError + # + # source://regexp_parser//lib/regexp_parser/parser.rb#16 + def initialize(type, token); end +end + +# source://regexp_parser//lib/regexp_parser/parser.rb#9 +class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError + # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError + # + # source://regexp_parser//lib/regexp_parser/parser.rb#10 + def initialize(type, token); end +end + +# source://regexp_parser//lib/regexp_parser/version.rb#3 +Regexp::Parser::VERSION = T.let(T.unsafe(nil), String) + +# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#3 +class Regexp::Scanner + # Emits an array with the details of the scanned pattern + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2406 + def emit(type, token, text); end + + # only public for #||= to work on ruby <= 2.5 + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2431 + def literal_run; end + + # only public for #||= to work on ruby <= 2.5 + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2431 + def literal_run=(_arg0); end + + # @raise [PrematureEndError] + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#24 + def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end + + private + + # Appends one or more characters to the literal buffer, to be emitted later + # by a call to emit_literal. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2468 + def append_literal(data, ts, te); end + + # Returns the value of attribute block. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def block=(_arg0); end + + # Returns the value of attribute char_pos. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def char_pos; end + + # Sets the attribute char_pos + # + # @param value the value to set the attribute char_pos to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def char_pos=(_arg0); end + + # Returns the value of attribute collect_tokens. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def collect_tokens; end + + # Sets the attribute collect_tokens + # + # @param value the value to set the attribute collect_tokens to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def collect_tokens=(_arg0); end + + # Returns the value of attribute conditional_stack. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def conditional_stack; end + + # Sets the attribute conditional_stack + # + # @param value the value to set the attribute conditional_stack to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def conditional_stack=(_arg0); end + + # Copy from ts to te from data as text + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2462 + def copy(data, ts, te); end + + # Emits the literal run collected by calls to the append_literal method. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2473 + def emit_literal; end + + # source://regexp_parser//lib/regexp_parser/scanner.rb#2508 + def emit_meta_control_sequence(data, ts, te, token); end + + # source://regexp_parser//lib/regexp_parser/scanner.rb#2479 + def emit_options(text); end + + # Returns the value of attribute free_spacing. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def free_spacing; end + + # Sets the attribute free_spacing + # + # @param value the value to set the attribute free_spacing to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def free_spacing=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2441 + def free_spacing?(input_object, options); end + + # Returns the value of attribute group_depth. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def group_depth; end + + # Sets the attribute group_depth + # + # @param value the value to set the attribute group_depth to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def group_depth=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2453 + def in_group?; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2457 + def in_set?; end + + # Returns the value of attribute prev_token. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def prev_token; end + + # Sets the attribute prev_token + # + # @param value the value to set the attribute prev_token to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def prev_token=(_arg0); end + + # Returns the value of attribute set_depth. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def set_depth; end + + # Sets the attribute set_depth + # + # @param value the value to set the attribute set_depth to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def set_depth=(_arg0); end + + # Returns the value of attribute spacing_stack. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def spacing_stack; end + + # Sets the attribute spacing_stack + # + # @param value the value to set the attribute spacing_stack to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def spacing_stack=(_arg0); end + + # Returns the value of attribute tokens. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def tokens; end + + # Sets the attribute tokens + # + # @param value the value to set the attribute tokens to. + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2435 + def tokens=(_arg0); end + + class << self + # source://regexp_parser//lib/regexp_parser/scanner.rb#2392 + def long_prop_map; end + + # source://regexp_parser//lib/regexp_parser/scanner.rb#2396 + def parse_prop_map(name); end + + # source://regexp_parser//lib/regexp_parser/scanner.rb#2400 + def posix_classes; end + + # Scans the given regular expression text, or Regexp object and collects the + # emitted token into an array that gets returned at the end. If a block is + # given, it gets called for each emitted token. + # + # This method may raise errors if a syntax error is encountered. + # -------------------------------------------------------------------------- + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#20 + def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end + + # lazy-load property maps when first needed + # + # source://regexp_parser//lib/regexp_parser/scanner.rb#2388 + def short_prop_map; end + end +end + +# Invalid back reference. Used for name a number refs/calls. +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#44 +class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError + # @return [InvalidBackrefError] a new instance of InvalidBackrefError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#45 + def initialize(what, reason); end +end + +# Invalid group. Used for named groups. +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#29 +class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError + # @return [InvalidGroupError] a new instance of InvalidGroupError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#30 + def initialize(what, reason); end +end + +# Invalid groupOption. Used for inline options. +# TODO: should become InvalidGroupOptionError in v3.0.0 for consistency +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#37 +class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError + # @return [InvalidGroupOption] a new instance of InvalidGroupOption + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#38 + def initialize(option, text); end +end + +# Invalid sequence format. Used for escape sequences, mainly. +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#22 +class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError + # @return [InvalidSequenceError] a new instance of InvalidSequenceError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#23 + def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end +end + +# Unexpected end of pattern +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#3 +class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError + # @return [PrematureEndError] a new instance of PrematureEndError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#4 + def initialize(where = T.unsafe(nil)); end +end + +# General scanner error (catch all) +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#5 +class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end + +# The POSIX class name was not recognized by the scanner. +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#58 +class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError + # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#59 + def initialize(text, _); end +end + +# The property name was not recognized by the scanner. +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#51 +class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError + # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#52 + def initialize(name, _); end +end + +# Base for all scanner validation errors +# +# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#4 +class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError + class << self + # Centralizes and unifies the handling of validation related errors. + # + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#5 + def for(type, problem, reason = T.unsafe(nil)); end + + # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#9 + def types; end + end +end + +# After loading all the tokens the map is full. Extract all tokens and types +# into the All and Types constants. +# +# source://regexp_parser//lib/regexp_parser/syntax.rb#3 +module Regexp::Syntax + private + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61 + def comparable(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44 + def const_missing(const_name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51 + def fallback_version_class(version); end + + # Returns the syntax specification class for the given syntax + # version name. The special names 'any' and '*' return Syntax::Any. + # + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22 + def for(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26 + def new(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57 + def specified_versions; end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32 + def supported?(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36 + def version_class(version); end + + class << self + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61 + def comparable(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44 + def const_missing(const_name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51 + def fallback_version_class(version); end + + # Returns the syntax specification class for the given syntax + # version name. The special names 'any' and '*' return Syntax::Any. + # + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22 + def for(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26 + def new(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57 + def specified_versions; end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32 + def supported?(name); end + + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36 + def version_class(version); end + end +end + +# A syntax that always returns true, passing all tokens as implemented. This +# is useful during development, testing, and should be useful for some types +# of transformations as well. +# +# source://regexp_parser//lib/regexp_parser/syntax/any.rb#5 +class Regexp::Syntax::Any < ::Regexp::Syntax::Base + class << self + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/syntax/any.rb#8 + def implements?(_type, _token); end + end +end + +# A lookup map of supported types and tokens in a given syntax +# +# source://regexp_parser//lib/regexp_parser/syntax/base.rb#9 +class Regexp::Syntax::Base + include ::Regexp::Syntax::Token + + # TODO: drop this backwards compatibility code in v3.0.0, do `private :new` + # + # @return [Base] a new instance of Base + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#99 + def initialize; end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#104 + def method_missing(name, *args); end + + private + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#115 + def respond_to_missing?(name, include_private = T.unsafe(nil)); end + + class << self + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#46 + def added_features; end + + # @raise [NotImplementedError] + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40 + def check!(type, token); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31 + def check?(type, token); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#26 + def excludes(type, tokens); end + + # Returns the value of attribute features. + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13 + def features; end + + # Sets the attribute features + # + # @param value the value to set the attribute features to. + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13 + def features=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#36 + def implementations(type); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#21 + def implements(type, tokens); end + + # @raise [NotImplementedError] + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40 + def implements!(type, token); end + + # @return [Boolean] + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31 + def implements?(type, token); end + + # automatically inherit features through the syntax class hierarchy + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#16 + def inherited(subclass); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#54 + def normalize(type, token); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#74 + def normalize_backref(type, token); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#65 + def normalize_group(type, token); end + + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#50 + def removed_features; end + end +end + +# source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8 +Regexp::Syntax::CURRENT = Regexp::Syntax::V3_1_0 + +# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6 +class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError + # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError + # + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#7 + def initialize(name); end +end + +# source://regexp_parser//lib/regexp_parser/syntax/base.rb#2 +class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError + # @return [NotImplementedError] a new instance of NotImplementedError + # + # source://regexp_parser//lib/regexp_parser/syntax/base.rb#3 + def initialize(syntax, type, token); end +end + +# source://regexp_parser//lib/regexp_parser/syntax.rb#4 +class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#3 +module Regexp::Syntax::Token; end + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#42 +Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array) + +# alias for symmetry between Token::* and Expression::* +# +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#15 +module Regexp::Syntax::Token::Alternation; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#16 +Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#17 +Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3 +module Regexp::Syntax::Token::Anchor; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9 +Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#4 +Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#5 +Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#7 +Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#6 +Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10 +Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3 +module Regexp::Syntax::Token::Assertion; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7 +Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#4 +Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#5 +Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8 +Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol) + +# alias for symmetry between token symbol and Expression class name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#31 +Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3 +module Regexp::Syntax::Token::Backreference; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15 +Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#7 +Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#6 +Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#5 +Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#4 +Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#9 +Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#16 +Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#11 +Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13 +Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3 +module Regexp::Syntax::Token::CharacterSet; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7 +Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#4 +Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#5 +Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8 +Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3 +module Regexp::Syntax::Token::CharacterType; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10 +Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#4 +Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#8 +Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#5 +Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#6 +Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11 +Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3 +module Regexp::Syntax::Token::Conditional; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9 +Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#6 +Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#4 +Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#7 +Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#11 +Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#3 +module Regexp::Syntax::Token::Escape; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#8 +Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#24 +Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4 +Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#6 +Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#20 +Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#13 +Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#22 +Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25 +Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#11 +Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array) + +# alias for symmetry between Token::* and Expression::* +# +# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#31 +Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#11 +module Regexp::Syntax::Token::FreeSpace; end + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#12 +Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#13 +Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3 +module Regexp::Syntax::Token::Group; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17 +Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#8 +Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#4 +Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#10 +Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#5 +Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#7 +Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#9 +Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#18 +Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#12 +Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15 +Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3 +module Regexp::Syntax::Token::Keep; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6 +Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#4 +Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7 +Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#6 +module Regexp::Syntax::Token::Literal; end + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#7 +Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#8 +Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#4 +Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3 +module Regexp::Syntax::Token::Meta; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8 +Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5 +Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#4 +Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#6 +Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#9 +Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3 +module Regexp::Syntax::Token::PosixClass; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9 +Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#7 +Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#11 +Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#4 +Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10 +Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol) + +# alias for symmetry between token symbol and Token module name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#731 +Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3 +module Regexp::Syntax::Token::Quantifier; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29 +Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#4 +Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#22 +Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#26 +Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#24 +Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#23 +Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#16 +Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#10 +Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#30 +Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#28 +Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array) + +# alias for symmetry between token symbol and Token module name +# +# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#14 +Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet + +# Type is the same as Backreference so keeping it here, for now. +# +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20 +module Regexp::Syntax::Token::SubexpressionCall; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24 +Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#21 +Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#22 +Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token.rb#43 +Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3 +module Regexp::Syntax::Token::UnicodeProperty; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64 +Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#40 +Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#44 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#46 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#48 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#50 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#52 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#54 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#56 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#58 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#60 +Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#62 +Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#721 +Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13 +module Regexp::Syntax::Token::UnicodeProperty::Category; end + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36 +Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#33 +Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#14 +Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#17 +Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#20 +Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#23 +Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#30 +Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#27 +Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#6 +Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#9 +Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#133 +Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#66 +Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#120 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#125 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#129 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706 +Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#694 +Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702 +Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#724 +Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#11 +Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332 +Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#135 +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#231 +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#237 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#247 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#273 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#282 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#291 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#298 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#308 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#315 +Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#322 +Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#723 +Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#692 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#334 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#433 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#561 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#596 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#609 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#623 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#633 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#647 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#659 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#670 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708 +Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#709 +Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#710 +Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#711 +Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#712 +Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#713 +Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#714 +Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#715 +Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#716 +Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#717 +Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#718 +Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#719 +Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12 +class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError + # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError + # + # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#13 + def initialize(name); end +end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1 +class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1 +class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1 +class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1 +class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1 +class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1 +class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1 +class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1 +class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1 +class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1 +class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1 +class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1 +class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1 +class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end + +# source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1 +class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end + +# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4 +Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#2 +Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String) + +# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#3 +Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://regexp_parser//lib/regexp_parser/token.rb#2 +Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser//lib/regexp_parser/token.rb#13 +class Regexp::Token < ::Struct + def conditional_level; end + def conditional_level=(_); end + + # source://regexp_parser//lib/regexp_parser/token.rb#20 + def length; end + + def level; end + def level=(_); end + + # Returns the value of attribute next. + # + # source://regexp_parser//lib/regexp_parser/token.rb#14 + def next; end + + # Sets the attribute next + # + # @param value the value to set the attribute next to. + # + # source://regexp_parser//lib/regexp_parser/token.rb#14 + def next=(_arg0); end + + # source://regexp_parser//lib/regexp_parser/token.rb#16 + def offset; end + + # Returns the value of attribute previous. + # + # source://regexp_parser//lib/regexp_parser/token.rb#14 + def previous; end + + # Sets the attribute previous + # + # @param value the value to set the attribute previous to. + # + # source://regexp_parser//lib/regexp_parser/token.rb#14 + def previous=(_arg0); end + + def set_level; end + def set_level=(_); end + def te; end + def te=(_); end + def text; end + def text=(_); end + def token; end + def token=(_); end + def ts; end + def ts=(_); end + def type; end + def type=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end diff --git a/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi b/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi index 2340f1806e0..a3b42f6bb73 100644 --- a/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi +++ b/sorbet/rbi/gems/rubocop-ast@1.30.0.rbi @@ -4,5 +4,7198 @@ # This is an autogenerated file for types exported from the `rubocop-ast` gem. # Please instead update this file by running `bin/tapioca gem rubocop-ast`. -# THIS IS AN EMPTY RBI FILE. -# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem +class Parser::Source::Range + include ::RuboCop::AST::Ext::Range +end + +# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#3 +module RuboCop; end + +# ... +# +# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#4 +module RuboCop::AST + extend ::RuboCop::AST::RuboCopCompatibility +end + +# A node extension for `alias` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `alias` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#11 +class RuboCop::AST::AliasNode < ::RuboCop::AST::Node + # Returns the new identifier as specified by the `alias`. + # + # @return [SymbolNode] the new identifier + # + # source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#19 + def new_identifier; end + + # Returns the old identifier as specified by the `alias`. + # + # @return [SymbolNode] the old identifier + # + # source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#12 + def old_identifier; end +end + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#11 +class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#12 + def operator; end +end + +# A node extension for `until` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `until` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#8 +class RuboCop::AST::AndNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + + # Returns the alternate operator of the `and` as a string. + # Returns `and` for `&&` and vice versa. + # + # @return [String] the alternate of the `and` operator + # + # source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#16 + def alternate_operator; end + + # Returns the inverse keyword of the `and` node as a string. + # Returns `||` for `&&` and `or` for `and`. + # + # @return [String] the inverse of the `and` operator + # + # source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#24 + def inverse_operator; end +end + +# A node extension for `arg`, `optarg`, `restarg`, `kwarg`, `kwoptarg`, +# `kwrestarg`, `blockarg`, `shadowarg` and `forward_arg` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all `arg` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#12 +class RuboCop::AST::ArgNode < ::RuboCop::AST::Node + # Checks whether the argument has a default value + # + # @return [Boolean] whether the argument has a default value + # + # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#29 + def default?; end + + # Returns the default value of the argument, if any. + # + # @return [Node, nil] the default value of the argument + # + # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#20 + def default_value; end + + # Returns the name of an argument. + # + # @return [Symbol, nil] the name of the argument + # + # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#13 + def name; end +end + +# A node extension for `args` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `args` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#8 +class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node + include ::RuboCop::AST::CollectionNode + + # Yield each argument from the collection. + # Arguments can be inside `mlhs` nodes in the case of destructuring, so this + # flattens the collection to just `arg`, `optarg`, `restarg`, `kwarg`, + # `kwoptarg`, `kwrestarg`, `blockarg`, `forward_arg` and `shadowarg`. + # + # @return [Array] array of argument nodes. + # + # source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#34 + def argument_list; end + + # It returns true if arguments are empty and delimiters do not exist. + # @example: + # # true + # def x; end + # x { } + # -> {} + # + # # false + # def x(); end + # def x a; end + # x { || } + # -> () {} + # -> a {} + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#24 + def empty_and_without_delimiters?; end +end + +# A node extension for `array` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `array` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#8 +class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node + # Checks whether the `array` literal is delimited by either percent or + # square brackets + # + # brackets + # + # @return [Boolean] whether the array is enclosed in percent or square + # + # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#60 + def bracketed?; end + + # @deprecated Use `values.each` (a.k.a. `children.each`) + # + # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#21 + def each_value(&block); end + + # Checks whether the `array` literal is delimited by percent brackets. + # + # @overload percent_literal? + # @overload percent_literal? + # @return [Boolean] whether the array is enclosed in percent brackets + # + # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#47 + def percent_literal?(type = T.unsafe(nil)); end + + # Checks whether the `array` literal is delimited by square brackets. + # + # @return [Boolean] whether the array is enclosed in square brackets + # + # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#32 + def square_brackets?; end + + # Returns an array of all value nodes in the `array` literal. + # + # @return [Array] an array of value nodes + # + # source://ast/2.4.2/lib/ast/node.rb#56 + def values; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#9 +RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash) + +# A node extension for `lvasgn`, `ivasgn`, `cvasgn`, and `gvasgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#11 +class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#19 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#12 + def name; end +end + +# Common functionality for primitive literal nodes: `sym`, `str`, +# `int`, `float`, ... +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/basic_literal_node.rb#7 +module RuboCop::AST::BasicLiteralNode + # Returns the value of the literal. + # + # @return [mixed] the value of the literal + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/basic_literal_node.rb#11 + def value; end +end + +# Common functionality for nodes that are binary operations: +# `or`, `and` ... +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#7 +module RuboCop::AST::BinaryOperatorNode + # Returns all of the conditions, including nested conditions, + # of the binary operation. + # + # operation and the let and right hand side of any nested binary + # operators + # + # @return [Array] the left and right hand side of the binary + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#28 + def conditions; end + + # Returns the left hand side node of the binary operation. + # + # @return [Node] the left hand side of the binary operation + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#11 + def lhs; end + + # Returns the right hand side node of the binary operation. + # + # @return [Node] the right hand side of the binary operation + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#18 + def rhs; end +end + +# A node extension for `block` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `send` nodes within RuboCop. +# +# A `block` node is essentially a method send with a block. Parser nests +# the `send` node inside the `block` node. +# +# source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#11 +class RuboCop::AST::BlockNode < ::RuboCop::AST::Node + include ::RuboCop::AST::MethodIdentifierPredicates + + # Returns a collection of all descendants of this node that are + # argument type nodes. See `ArgsNode#argument_list` for details. + # + # @return [Array] + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#60 + def argument_list; end + + # The arguments of this block. + # Note that if the block has destructured arguments, `arguments` will + # return a `mlhs` node, whereas `argument_list` will return only + # actual argument nodes. + # + # @return [Array] + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#48 + def arguments; end + + # Checks whether this block takes any arguments. + # + # @return [Boolean] whether this `block` node takes any arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#85 + def arguments?; end + + # The body of this block. + # + # @return [Node, nil] the body of the `block` node or `nil` + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#71 + def body; end + + # Checks whether the `block` literal is delimited by curly braces. + # + # @return [Boolean] whether the `block` literal is enclosed in braces + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#92 + def braces?; end + + # The closing delimiter for this `block` literal. + # + # @return [String] the closing delimiter for the `block` literal + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#120 + def closing_delimiter; end + + # The delimiters for this `block` literal. + # + # @return [Array] the delimiters for the `block` literal + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#106 + def delimiters; end + + # A shorthand for getting the first argument of this block. + # Equivalent to `arguments.first`. + # + # @return [Node, nil] the first argument of this block, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#29 + def first_argument; end + + # Checks whether the `block` literal is delimited by `do`-`end` keywords. + # + # @return [Boolean] whether the `block` literal is enclosed in `do`-`end` + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#99 + def keywords?; end + + # Checks whether this `block` literal belongs to a lambda. + # + # @return [Boolean] whether the `block` literal belongs to a lambda + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#143 + def lambda?; end + + # A shorthand for getting the last argument of this block. + # Equivalent to `arguments.last`. + # + # @return [Node, nil] the last argument of this block, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#38 + def last_argument; end + + # The name of the dispatched method as a symbol. + # + # @return [Symbol] the name of the dispatched method + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#78 + def method_name; end + + # Checks whether this is a multiline block. This is overridden here + # because the general version in `Node` does not work for `block` nodes. + # + # @return [Boolean] whether the `block` literal is on a several lines + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#136 + def multiline?; end + + # The opening delimiter for this `block` literal. + # + # @return [String] the opening delimiter for the `block` literal + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#113 + def opening_delimiter; end + + # The `send` node associated with this block. + # + # @return [SendNode] the `send` node associated with the `block` node + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#20 + def send_node; end + + # Checks whether this is a single line block. This is overridden here + # because the general version in `Node` does not work for `block` nodes. + # + # @return [Boolean] whether the `block` literal is on a single line + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#128 + def single_line?; end + + # Checks whether this node body is a void context. + # + # @return [Boolean] whether the `block` node body is a void context + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#150 + def void_context?; end + + private + + # Numbered arguments of this `numblock`. + # + # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#157 + def numbered_arguments; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#14 +RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array) + +# A node extension for `break` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `break` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/break_node.rb#8 +class RuboCop::AST::BreakNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser` +# generate ASTs with {RuboCop::AST::Node}. +# +# @example +# buffer = Parser::Source::Buffer.new('(string)') +# buffer.source = 'puts :foo' +# +# builder = RuboCop::AST::Builder.new +# require 'parser/ruby25' +# parser = Parser::Ruby25.new(builder) +# root_node = parser.parse(buffer) +# +# source://rubocop-ast//lib/rubocop/ast/builder.rb#16 +class RuboCop::AST::Builder < ::Parser::Builders::Default + # Generates {Node} from the given information. + # + # @return [Node] the generated node + # + # source://rubocop-ast//lib/rubocop/ast/builder.rb#98 + def n(type, children, source_map); end + + # TODO: Figure out what to do about literal encoding handling... + # More details here https://github.com/whitequark/parser/issues/283 + # + # source://rubocop-ast//lib/rubocop/ast/builder.rb#104 + def string_value(token); end + + private + + # source://rubocop-ast//lib/rubocop/ast/builder.rb#110 + def node_klass(type); end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/builder.rb#21 +RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash) + +# A node extension for `case_match` nodes. This will be used in place of +# a plain node when the builder constructs the AST, making its methods +# available to all `case_match` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#8 +class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + + # Returns an array of all the when branches in the `case` statement. + # + # and the `else` (if any). Note that these bodies could be nil. + # + # @return [Array] an array of the bodies of the `in` branches + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#38 + def branches; end + + # @deprecated Use `in_pattern_branches.each` + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#19 + def each_in_pattern(&block); end + + # Checks whether this case statement has an `else` branch. + # + # @return [Boolean] whether the `case` statement has an `else` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#59 + def else?; end + + # Returns the else branch of the `case` statement, if any. + # + # @return [Node] the else branch node of the `case` statement + # @return [EmptyElse] the empty else branch node of the `case` statement + # @return [nil] if the case statement does not have an else branch. + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#52 + def else_branch; end + + # Returns an array of all the `in` pattern branches in the `case` statement. + # + # @return [Array] an array of `in_pattern` nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#30 + def in_pattern_branches; end + + # Returns the keyword of the `case` statement as a string. + # + # @return [String] the keyword of the `case` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#14 + def keyword; end +end + +# A node extension for `case` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `case` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#8 +class RuboCop::AST::CaseNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + + # Returns an array of all the when branches in the `case` statement. + # + # and the else (if any). Note that these bodies could be nil. + # + # @return [Array] an array of the bodies of the when branches + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#38 + def branches; end + + # @deprecated Use `when_branches.each` + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#19 + def each_when(&block); end + + # Checks whether this case statement has an `else` branch. + # + # @return [Boolean] whether the `case` statement has an `else` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#55 + def else?; end + + # Returns the else branch of the `case` statement, if any. + # + # @return [Node] the else branch node of the `case` statement + # @return [nil] if the case statement does not have an else branch. + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#48 + def else_branch; end + + # Returns the keyword of the `case` statement as a string. + # + # @return [String] the keyword of the `case` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#14 + def keyword; end + + # Returns an array of all the when branches in the `case` statement. + # + # @return [Array] an array of `when` nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#30 + def when_branches; end +end + +# A node extension for `casgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#11 +class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#26 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#19 + def name; end + + # The namespace of the constant being assigned. + # + # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...) + # + # source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#12 + def namespace; end +end + +# A node extension for `class` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `class` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#11 +class RuboCop::AST::ClassNode < ::RuboCop::AST::Node + # The body of this `class` node. + # + # @return [Node, nil] the body of the class + # + # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#26 + def body; end + + # The identifier for this `class` node. + # + # @return [Node] the identifier of the class + # + # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#12 + def identifier; end + + # The parent class for this `class` node. + # + # @return [Node, nil] the parent class of the class + # + # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#19 + def parent_class; end +end + +# A mixin that helps give collection nodes array polymorphism. +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/collection_node.rb#6 +module RuboCop::AST::CollectionNode + extend ::Forwardable + + # source://forwardable/1.3.2/forwardable.rb#229 + def &(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def *(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def +(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def -(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def <<(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def [](*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def []=(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def all?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def any?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def append(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def assoc(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def at(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def bsearch(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def bsearch_index(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def chain(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def chunk(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def chunk_while(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def clear(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def collect(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def collect!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def collect_concat(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def combination(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def compact(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def compact!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def concat(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def count(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def cycle(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def deconstruct(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def delete(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def delete_at(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def delete_if(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def detect(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def difference(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def dig(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def drop(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def drop_while(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_cons(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_entry(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_index(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_slice(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_with_index(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_with_object(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def empty?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def entries(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def fetch(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def fill(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def filter(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def filter!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def filter_map(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def find(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def find_all(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def find_index(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def first(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def flat_map(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def flatten(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def flatten!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def grep(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def grep_v(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def group_by(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def include?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def index(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def inject(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def insert(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def intersect?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def intersection(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def join(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def keep_if(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def last(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def lazy(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def length(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def map(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def map!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def max(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def max_by(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def member?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def min(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def min_by(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def minmax(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def minmax_by(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def none?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def one?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def pack(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def partition(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def permutation(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def place(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def pop(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def prepend(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def product(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def push(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def rassoc(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reduce(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reject(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reject!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def repeated_combination(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def repeated_permutation(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def replace(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reverse(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reverse!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def reverse_each(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def rindex(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def rotate(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def rotate!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sample(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def select(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def select!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def shelljoin(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def shift(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def shuffle(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def shuffle!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def size(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def slice(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def slice!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def slice_after(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def slice_before(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def slice_when(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sort(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sort!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sort_by(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sort_by!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def sum(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def take(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def take_while(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def tally(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_ary(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_csv(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_h(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_set(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def transpose(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def union(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def uniq(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def uniq!(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def unshift(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def values_at(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def zip(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def |(*args, **_arg1, &block); end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/collection_node.rb#9 +RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array) + +# Common functionality for nodes that have conditions: +# `if`, `while`, `until`, `case`. +# This currently doesn't include `when` nodes, because they have multiple +# conditions, and need to be checked for that. +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#9 +module RuboCop::AST::ConditionalNode + # Returns the body associated with the condition. This works together with + # each node's custom destructuring method to select the correct part of + # the node. + # + # @note For `if` nodes, this is the truthy branch. + # @return [Node, nil] the body of the node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#40 + def body; end + + # Returns the condition of the node. This works together with each node's + # custom destructuring method to select the correct part of the node. + # + # @return [Node, nil] the condition of the node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#29 + def condition; end + + # Checks whether the condition of the node is written on more than + # one line. + # + # @return [Boolean] whether the condition is on more than one line + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#21 + def multiline_condition?; end + + # Checks whether the condition of the node is written on a single line. + # + # @return [Boolean] whether the condition is on a single line + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#13 + def single_line_condition?; end +end + +# A node extension for `const` nodes. +# +# source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#7 +class RuboCop::AST::ConstNode < ::RuboCop::AST::Node + # @return [Boolean] if the constant starts with `::` (aka s(:cbase)) + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#26 + def absolute?; end + + # @return [Boolean] if the constant is a Module / Class, according to the standard convention. + # Note: some classes might have uppercase in which case this method + # returns false + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#20 + def class_name?; end + + # Yield nodes for the namespace + # + # For `::Foo::Bar::BAZ` => yields: + # s(:cbase), then + # s(:const, :Foo), then + # s(:const, s(:const, :Foo), :Bar) + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#43 + def each_path(&block); end + + # @return [Boolean] if the constant is a Module / Class, according to the standard convention. + # Note: some classes might have uppercase in which case this method + # returns false + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#20 + def module_name?; end + + # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...) + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#8 + def namespace; end + + # @return [Boolean] if the constant does not start with `::` (aka s(:cbase)) + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#33 + def relative?; end + + # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar + # + # source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#13 + def short_name; end +end + +# A node extension for `csend` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `csend` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/csend_node.rb#8 +class RuboCop::AST::CsendNode < ::RuboCop::AST::SendNode + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/csend_node.rb#9 + def send_type?; end +end + +# A node extension for `def` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `def` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#8 +class RuboCop::AST::DefNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + + # Checks whether this method definition node forwards its arguments + # as per the feature added in Ruby 2.7. + # + # @note This is written in a way that may support lead arguments + # which are rumored to be added in a later version of Ruby. + # @return [Boolean] whether the `def` node uses argument forwarding + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#26 + def argument_forwarding?; end + + # An array containing the arguments of the method definition. + # + # @return [Array] the arguments of the method definition + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#40 + def arguments; end + + # The body of the method definition. + # + # @note this can be either a `begin` node, if the method body contains + # multiple expressions, or any other node, if it contains a single + # expression. + # @return [Node] the body of the method definition + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#51 + def body; end + + # @return [Boolean] if the definition is without an `end` or not. + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#63 + def endless?; end + + # The name of the defined method as a symbol. + # + # @return [Symbol] the name of the defined method + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#33 + def method_name; end + + # The receiver of the method definition, if any. + # + # @return [Node, nil] the receiver of the method definition, or `nil`. + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#58 + def receiver; end + + # Checks whether this node body is a void context. + # + # @return [Boolean] whether the `def` node body is a void context + # + # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#15 + def void_context?; end +end + +# A node extension for `defined?` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `send` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/defined_node.rb#8 +class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast/2.4.2/lib/ast/node.rb#56 + def arguments; end + + # source://rubocop-ast//lib/rubocop/ast/node/defined_node.rb#12 + def node_parts; end +end + +# Common functionality for primitive literal nodes: `sym`, `str`, +# `int`, `float`, ... +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#7 +module RuboCop::AST::Descendence + # Returns an array of child nodes. + # This is a shorthand for `node.each_child_node.to_a`. + # + # @return [Array] an array of child nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#38 + def child_nodes; end + + # Returns an array of descendant nodes. + # This is a shorthand for `node.each_descendant.to_a`. + # + # @return [Array] an array of descendant nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#72 + def descendants; end + + # Calls the given block for each child node. + # If no block is given, an `Enumerator` is returned. + # + # Note that this is different from `node.children.each { |child| ... }` + # which yields all children including non-node elements. + # + # @overload each_child_node + # @overload each_child_node + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each child node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#22 + def each_child_node(*types); end + + # Calls the given block for each descendant node with depth first order. + # If no block is given, an `Enumerator` is returned. + # + # @overload each_descendant + # @overload each_descendant + # @overload each_descendant + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each descendant node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#60 + def each_descendant(*types, &block); end + + # Calls the given block for the receiver and each descendant node in + # depth-first order. + # If no block is given, an `Enumerator` is returned. + # + # This method would be useful when you treat the receiver node as the root + # of a tree and want to iterate over all nodes in the tree. + # + # @overload each_node + # @overload each_node + # @overload each_node + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#95 + def each_node(*types, &block); end + + protected + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#107 + def visit_descendants(types, &block); end +end + +# A node extension for `dstr` nodes. This will be used +# in place of a plain node when the builder constructs the AST, making +# its methods available to all `dstr` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/dstr_node.rb#8 +class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode + # source://rubocop-ast//lib/rubocop/ast/node/dstr_node.rb#9 + def value; end +end + +# A node extension for `ensure` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `ensure` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#11 +class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node + # Returns the body of the `ensure` clause. + # + # @return [Node, nil] The body of the `ensure`. + # + # source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#12 + def body; end +end + +# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#5 +module RuboCop::AST::Ext; end + +# Extensions to Parser::AST::Range +# +# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#7 +module RuboCop::AST::Ext::Range + # If `exclude_end` is `true`, then the range will be exclusive. + # + # Assume that `node` corresponds to the following array literal: + # + # [ + # :foo, + # :bar + # ] + # + # node.loc.begin.line_span # => 1..1 + # node.source_range.line_span(exclude_end: true) # => 1...4 + # + # @return [Range] the range of line numbers for the node + # + # source://rubocop-ast//lib/rubocop/ast/ext/range.rb#20 + def line_span(exclude_end: T.unsafe(nil)); end +end + +# Refinement to circumvent broken `Range#minmax` for infinity ranges in 2.6- +# +# source://rubocop-ast//lib/rubocop/ast/ext/range_min_max.rb#7 +module RuboCop::AST::Ext::RangeMinMax; end + +# A node extension for `float` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available to +# all `float` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/float_node.rb#8 +class RuboCop::AST::FloatNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + include ::RuboCop::AST::NumericNode +end + +# A node extension for `for` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `for` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#11 +class RuboCop::AST::ForNode < ::RuboCop::AST::Node + # Returns the body of the `for` loop. + # + # @return [Node, nil] The body of the `for` loop. + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#48 + def body; end + + # Returns the collection the `for` loop is iterating over. + # + # @return [Node] The collection the `for` loop is iterating over + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#41 + def collection; end + + # Checks whether the `for` node has a `do` keyword. + # + # @return [Boolean] whether the `for` node has a `do` keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#19 + def do?; end + + # Returns the keyword of the `for` statement as a string. + # + # @return [String] the keyword of the `until` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#12 + def keyword; end + + # Returns the iteration variable of the `for` loop. + # + # @return [Node] The iteration variable of the `for` loop + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#34 + def variable; end + + # Checks whether this node body is a void context. + # Always `true` for `for`. + # + # @return [true] whether the `for` node body is a void context + # + # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#27 + def void_context?; end +end + +# A node extension for `forward-args` nodes. This will be used in place +# of a plain node when the builder constructs the AST, making its methods +# available to all `forward-args` nodes within RuboCop. +# +# Not used with modern emitters: +# +# $ ruby-parse -e "def foo(...); end" +# (def :foo +# (args +# (forward-arg)) nil) +# $ ruby-parse --legacy -e "->(foo) { bar }" +# (def :foo +# (forward-args) nil) +# +# Note the extra 's' with legacy form. +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true` +# +# source://rubocop-ast//lib/rubocop/ast/node/forward_args_node.rb#23 +class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node + include ::RuboCop::AST::CollectionNode + + # Node wraps itself in an array to be compatible with other + # enumerable argument types. + # + # source://rubocop-ast//lib/rubocop/ast/node/forward_args_node.rb#28 + def to_a; end +end + +# Common functionality for nodes that can be used as hash elements: +# `pair`, `kwsplat` +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#7 +module RuboCop::AST::HashElementNode + # Returns the delta between this element's delimiter and the argument's. + # + # @note Pairs with different delimiter styles return a delta of 0 + # @return [Integer] the delta between the two delimiters + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#61 + def delimiter_delta(other); end + + # Returns the key of this `hash` element. + # + # @note For keyword splats, this returns the whole node + # @return [Node] the key of the hash element + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#13 + def key; end + + # Returns the delta between this pair's key and the argument pair's. + # + # @note Keys on the same line always return a delta of 0 + # @note Keyword splats always return a delta of 0 for right alignment + # @param alignment [Symbol] whether to check the left or right side + # @return [Integer] the delta between the two keys + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#43 + def key_delta(other, alignment = T.unsafe(nil)); end + + # Checks whether this `hash` element is on the same line as `other`. + # + # @note A multiline element is considered to be on the same line if it + # shares any of its lines with `other` + # @return [Boolean] whether this element is on the same line as `other` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#32 + def same_line?(other); end + + # Returns the value of this `hash` element. + # + # @note For keyword splats, this returns the whole node + # @return [Node] the value of the hash element + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#22 + def value; end + + # Returns the delta between this element's value and the argument's. + # + # @note Keyword splats always return a delta of 0 + # @return [Integer] the delta between the two values + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#52 + def value_delta(other); end +end + +# A helper class for comparing the positions of different parts of a +# `pair` node. +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#67 +class RuboCop::AST::HashElementNode::HashElementDelta + # @raise [ArgumentError] + # @return [HashElementDelta] a new instance of HashElementDelta + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#68 + def initialize(first, second); end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#89 + def delimiter_delta; end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#75 + def key_delta(alignment = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#82 + def value_delta; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#106 + def delta(first, second, alignment = T.unsafe(nil)); end + + # Returns the value of attribute first. + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#98 + def first; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#117 + def keyword_splat?; end + + # Returns the value of attribute second. + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#98 + def second; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#100 + def valid_argument_types?; end +end + +# A node extension for `hash` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `hash` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#14 +class RuboCop::AST::HashNode < ::RuboCop::AST::Node + # Checks whether the `hash` literal is delimited by curly braces. + # + # @return [Boolean] whether the `hash` literal is enclosed in braces + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#117 + def braces?; end + + # Calls the given block for each `key` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#59 + def each_key(&block); end + + # Calls the given block for each `pair` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#33 + def each_pair; end + + # Calls the given block for each `value` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#83 + def each_value(&block); end + + # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes. + # + # @return[Boolean] whether the `hash` is empty + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#22 + def empty?; end + + # Returns an array of all the keys in the `hash` literal. + # + # @note `kwsplat` nodes are ignored. + # @return [Array] an array of keys in the `hash` literal + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#48 + def keys; end + + # Checks whether this `hash` uses a mix of hash rocket and colon + # delimiters for its pairs. + # + # @note `kwsplat` nodes are ignored. + # @return [Boolean] whether the `hash` uses mixed delimiters + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#110 + def mixed_delimiters?; end + + # Returns an array of all the key value pairs in the `hash` literal. + # + # ignored. + # + # @note this may be different from children as `kwsplat` nodes are + # @return [Array] an array of `pair` nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#15 + def pairs; end + + # Checks whether any of the key value pairs in the `hash` literal are on + # the same line. + # + # @note A multiline `pair` is considered to be on the same line if it + # shares any of its lines with another `pair` + # @note `kwsplat` nodes are ignored. + # @return [Boolean] whether any `pair` nodes are on the same line + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#100 + def pairs_on_same_line?; end + + # Returns an array of all the values in the `hash` literal. + # + # @note `kwsplat` nodes are ignored. + # @return [Array] an array of values in the `hash` literal + # + # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#72 + def values; end +end + +# A node extension for `if` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `if` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#8 +class RuboCop::AST::IfNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Returns an array of all the branches in the conditional statement. + # + # @return [Array] an array of branch nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#147 + def branches; end + + # @deprecated Use `branches.each` + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#164 + def each_branch(&block); end + + # Checks whether the `if` node has an `else` clause. + # + # @note This returns `true` for nodes containing an `elsif` clause. + # This is legacy behavior, and many cops rely on it. + # @return [Boolean] whether the node has an `else` clause + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#42 + def else?; end + + # Returns the branch of the `if` node that gets evaluated when its + # condition is falsey. + # + # @note This is normalized for `unless` nodes. + # @return [Node] the falsey branch node of the `if` node + # @return [nil] when there is no else branch + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#126 + def else_branch; end + + # Checks whether the `if` is an `elsif`. Parser handles these by nesting + # `if` nodes in the `else` branch. + # + # @return [Boolean] whether the node is an `elsif` + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#32 + def elsif?; end + + # Checks whether the `if` node has at least one `elsif` branch. Returns + # true if this `if` node itself is an `elsif`. + # + # @return [Boolean] whether the `if` node has at least one `elsif` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#104 + def elsif_conditional?; end + + # Checks whether this node is an `if` statement. (This is not true of + # ternary operators and `unless` statements.) + # + # @return [Boolean] whether the node is an `if` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#16 + def if?; end + + # Returns the branch of the `if` node that gets evaluated when its + # condition is truthy. + # + # @note This is normalized for `unless` nodes. + # @return [Node] the truthy branch node of the `if` node + # @return [nil] if the truthy branch is empty + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#115 + def if_branch; end + + # Returns the inverse keyword of the `if` node as a string. Returns `if` + # for `unless` nodes and vice versa. Returns an empty string for ternary + # operators. + # + # @return [String] the inverse keyword of the `if` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#66 + def inverse_keyword; end + + # Returns the keyword of the `if` statement as a string. Returns an empty + # string for ternary operators. + # + # @return [String] the keyword of the `if` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#57 + def keyword; end + + # Checks whether the `if` node is in a modifier form, i.e. a condition + # trailing behind an expression. Only `if` and `unless` nodes without + # other branches can be modifiers. + # + # @return [Boolean] whether the `if` node is a modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#80 + def modifier_form?; end + + # Checks whether the `if` node has nested `if` nodes in any of its + # branches. + # + # @note This performs a shallow search. + # @return [Boolean] whether the `if` node contains nested conditionals + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#90 + def nested_conditional?; end + + # Custom destructuring method. This is used to normalize the branches + # for `if` and `unless` nodes, to aid comparisons and conversions. + # + # @return [Array] the different parts of the `if` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#134 + def node_parts; end + + # Checks whether the `if` node is a ternary operator. + # + # @return [Boolean] whether the `if` node is a ternary operator + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#49 + def ternary?; end + + # Checks whether this node is an `unless` statement. (This is not true + # of ternary operators and `if` statements.) + # + # @return [Boolean] whether the node is an `unless` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#24 + def unless?; end +end + +# A node extension for `in` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `in` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#11 +class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node + # Returns the body of the `in` node. + # + # @return [Node, nil] the body of the `in` node + # + # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#33 + def body; end + + # Returns the index of the `in` branch within the `case` statement. + # + # @return [Integer] the index of the `in` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#19 + def branch_index; end + + # Returns a node of the pattern in the `in` branch. + # + # @return [Node] a pattern node + # + # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#12 + def pattern; end + + # Checks whether the `in` node has a `then` keyword. + # + # @return [Boolean] whether the `in` node has a `then` keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#26 + def then?; end +end + +# Used for modern support only! +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "foo[:bar]" +# (index +# (send nil :foo) +# (sym :bar)) +# $ ruby-parse --legacy -e "foo[:bar]" +# (send +# (send nil :foo) :[] +# (sym :bar)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true` +# +# source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#19 +class RuboCop::AST::IndexNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#29 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#24 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#34 + def method_name; end + + private + + # An array containing the arguments of the dispatched method. + # + # @return [Array] the arguments of the dispatched method + # + # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#43 + def first_argument_index; end +end + +# Used for modern support only! +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "foo[:bar] = :baz" +# (indexasgn +# (send nil :foo) +# (sym :bar) +# (sym :baz)) +# $ ruby-parse --legacy -e "foo[:bar] = :baz" +# (send +# (send nil :foo) :[]= +# (sym :bar) +# (sym :baz)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true` +# +# source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#21 +class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#31 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#26 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#36 + def method_name; end + + private + + # An array containing the arguments of the dispatched method. + # + # @return [Array] the arguments of the dispatched method + # + # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#45 + def first_argument_index; end +end + +# A node extension for `int` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available to +# all `int` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/int_node.rb#8 +class RuboCop::AST::IntNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + include ::RuboCop::AST::NumericNode +end + +# A node extension for `kwsplat` and `forwarded_kwrestarg` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its methods available to +# all `kwsplat` and `forwarded_kwrestarg` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#8 +class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node + include ::RuboCop::AST::HashElementNode + + # This is used for duck typing with `pair` nodes which also appear as + # `hash` elements. + # + # @return [false] + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#26 + def colon?; end + + # This is used for duck typing with `pair` nodes which also appear as + # `hash` elements. + # + # @return [false] + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#18 + def hash_rocket?; end + + # This provides `forwarded_kwrestarg` node to return true to be compatible with `kwsplat` node. + # + # @return [true] + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#48 + def kwsplat_type?; end + + # Custom destructuring method. This is used to normalize the branches + # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements. + # + # @return [Array] the different parts of the `kwsplat` + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#41 + def node_parts; end + + # Returns the operator for the `kwsplat` as a string. + # + # @return [String] the double splat operator + # + # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#33 + def operator; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#11 +RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String) + +# Used for modern support only: +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "->(foo) { bar }" +# (block +# (lambda) +# (args +# (arg :foo)) +# (send nil :bar)) +# $ ruby-parse --legacy -e "->(foo) { bar }" +# (block +# (send nil :lambda) +# (args +# (arg :foo)) +# (send nil :bar)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true` +# +# source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#23 +class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#43 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#38 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#28 + def lambda?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#33 + def lambda_literal?; end + + # For similarity with legacy mode + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#53 + def method_name; end + + # For similarity with legacy mode + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#48 + def receiver; end + + private + + # For similarity with legacy mode + # + # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#60 + def first_argument_index; end +end + +# Common functionality for nodes that are a kind of method dispatch: +# `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`, +# and (modern only): `index`, `indexasgn`, `lambda` +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#8 +module RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + extend ::RuboCop::AST::NodePattern::Macros + + # Checks whether the dispatched method is an access modifier. + # + # @return [Boolean] whether the dispatched method is an access modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#64 + def access_modifier?; end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#273 + def adjacent_def_modifier?(param0 = T.unsafe(nil)); end + + # Checks whether this node is an arithmetic operation + # + # @return [Boolean] whether the dispatched method is an arithmetic + # operation + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#175 + def arithmetic_operation?; end + + # Checks whether the dispatched method is a setter method. + # + # @return [Boolean] whether the dispatched method is a setter + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107 + def assignment?; end + + # Checks whether the dispatched method is a bare access modifier that + # affects all methods defined after the macro. + # + # @return [Boolean] whether the dispatched method is a bare + # access modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#73 + def bare_access_modifier?; end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#278 + def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end + + # Checks whether this is a binary operation. + # + # @example + # + # foo + bar + # @return [Boolean] whether this method is a binary operation + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#248 + def binary_operation?; end + + # Whether this method dispatch has an explicit block. + # + # @return [Boolean] whether the dispatched method has a block + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#167 + def block_literal?; end + + # The `block` or `numblock` node associated with this method dispatch, if any. + # + # @return [BlockNode, nil] the `block` or `numblock` node associated with this method + # call or `nil` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#46 + def block_node; end + + # Checks whether the name of the dispatched method matches the argument + # and has an implicit receiver. + # + # @param name [Symbol, String] the method name to check for + # @return [Boolean] whether the method name matches the argument + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#100 + def command?(name); end + + # Checks whether the *explicit* receiver of this method dispatch is a + # `const` node. + # + # @return [Boolean] whether the receiver of this method dispatch + # is a `const` node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#152 + def const_receiver?; end + + # Checks if this node is part of a chain of `def` or `defs` modifiers. + # + # or `nil` if it isn't a def modifier + # + # @example + # + # private def foo; end + # @return [Node | nil] returns the `def|defs` node this is a modifier for, + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#199 + def def_modifier(node = T.unsafe(nil)); end + + # Checks if this node is part of a chain of `def` or `defs` modifiers. + # + # See also `def_modifier` that returns the node or `nil` + # + # @example + # + # private def foo; end + # @return [Boolean] whether the `def|defs` node is a modifier or not. + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#187 + def def_modifier?(node = T.unsafe(nil)); end + + # Checks whether the dispatched method uses a dot to connect the + # receiver and the method name. + # + # This is useful for comparison operators, which can be called either + # with or without a dot, i.e. `foo == bar` or `foo.== bar`. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#119 + def dot?; end + + # Checks whether the dispatched method uses a double colon to connect the + # receiver and the method name. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#127 + def double_colon?; end + + # Checks whether the method dispatch is the implicit form of `#call`, + # e.g. `foo.(bar)`. + # + # @return [Boolean] whether the method is the implicit form of `#call` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#160 + def implicit_call?; end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#257 + def in_macro_scope?(param0 = T.unsafe(nil)); end + + # Checks whether this is a lambda. Some versions of parser parses + # non-literal lambdas as a method send. + # + # @return [Boolean] whether this method is a lambda + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#213 + def lambda?; end + + # Checks whether this is a lambda literal (stabby lambda.) + # + # @example + # + # -> (foo) { bar } + # @return [Boolean] whether this method is a lambda literal + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#224 + def lambda_literal?; end + + # Checks whether the dispatched method is a macro method. A macro method + # is defined as a method that sits in a class, module, or block body and + # has an implicit receiver. + # + # @note This does not include DSLs that use nested blocks, like RSpec + # @return [Boolean] whether the dispatched method is a macro method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#57 + def macro?; end + + # The name of the dispatched method as a symbol. + # + # @return [Symbol] the name of the dispatched method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#27 + def method_name; end + + # Checks whether the dispatched method is a non-bare access modifier that + # affects only the method it receives. + # + # @return [Boolean] whether the dispatched method is a non-bare + # access modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#82 + def non_bare_access_modifier?; end + + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#283 + def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end + + # The receiving node of the method dispatch. + # + # @return [Node, nil] the receiver of the dispatched method or `nil` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#20 + def receiver; end + + # Checks whether the dispatched method uses a safe navigation operator to + # connect the receiver and the method name. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#135 + def safe_navigation?; end + + # The source range for the method name or keyword that dispatches this call. + # + # @return [Parser::Source::Range] the source range for the method name or keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#34 + def selector; end + + # Checks whether the *explicit* receiver of this method dispatch is + # `self`. + # + # @return [Boolean] whether the receiver of this method dispatch is `self` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#143 + def self_receiver?; end + + # Checks whether the dispatched method is a setter method. + # + # @return [Boolean] whether the dispatched method is a setter + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107 + def setter_method?; end + + # Checks whether the dispatched method is a bare `private` or `protected` + # access modifier that affects all methods defined after the macro. + # + # @return [Boolean] whether the dispatched method is a bare + # `private` or `protected` access modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#91 + def special_modifier?; end + + # Checks whether this is a unary operation. + # + # @example + # + # -foo + # @return [Boolean] whether this method is a unary operation + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#235 + def unary_operation?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#12 +RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#14 +RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array) + +# Common predicates for nodes that reference method identifiers: +# `send`, `csend`, `def`, `defs`, `super`, `zsuper` +# +# @note this mixin expects `#method_name` and `#receiver` to be implemented +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#9 +module RuboCop::AST::MethodIdentifierPredicates + # Checks whether the method is an assignment method. + # + # @return [Boolean] whether the method is an assignment + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#142 + def assignment_method?; end + + # Checks whether the method is a bang method. + # + # @return [Boolean] whether the method is a bang method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#171 + def bang_method?; end + + # Checks whether the method is a camel case method, + # e.g. `Integer()`. + # + # @return [Boolean] whether the method is a camel case method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#179 + def camel_case_method?; end + + # Checks whether the method is a comparison method. + # + # @return [Boolean] whether the method is a comparison + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#135 + def comparison_method?; end + + # Checks whether the *explicit* receiver of node is a `const` node. + # + # @return [Boolean] whether the receiver of this node is a `const` node + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#193 + def const_receiver?; end + + # Checks whether the method is an Enumerable method. + # + # @return [Boolean] whether the method is an Enumerable method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#157 + def enumerable_method?; end + + # Checks whether the method is an enumerator method. + # + # @return [Boolean] whether the method is an enumerator + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#149 + def enumerator_method?; end + + # Checks whether the method name matches the argument. + # + # @param name [Symbol, String] the method name to check for + # @return [Boolean] whether the method name matches the argument + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#79 + def method?(name); end + + # Checks whether this is a negation method, i.e. `!` or keyword `not`. + # + # @return [Boolean] whether this method is a negation method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#200 + def negation_method?; end + + # Checks whether the method is a nonmutating Array method. + # + # @return [Boolean] whether the method is a nonmutating Array method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#114 + def nonmutating_array_method?; end + + # Checks whether the method is a nonmutating binary operator method. + # + # @return [Boolean] whether the method is a nonmutating binary operator method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#93 + def nonmutating_binary_operator_method?; end + + # Checks whether the method is a nonmutating Hash method. + # + # @return [Boolean] whether the method is a nonmutating Hash method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#121 + def nonmutating_hash_method?; end + + # Checks whether the method is a nonmutating operator method. + # + # @return [Boolean] whether the method is a nonmutating operator method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#107 + def nonmutating_operator_method?; end + + # Checks whether the method is a nonmutating String method. + # + # @return [Boolean] whether the method is a nonmutating String method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#128 + def nonmutating_string_method?; end + + # Checks whether the method is a nonmutating unary operator method. + # + # @return [Boolean] whether the method is a nonmutating unary operator method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#100 + def nonmutating_unary_operator_method?; end + + # Checks whether the method is an operator method. + # + # @return [Boolean] whether the method is an operator + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#86 + def operator_method?; end + + # Checks whether the method is a predicate method. + # + # @return [Boolean] whether the method is a predicate method + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#164 + def predicate_method?; end + + # Checks whether this is a prefix bang method, e.g. `!foo`. + # + # @return [Boolean] whether this method is a prefix bang + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#214 + def prefix_bang?; end + + # Checks whether this is a prefix not method, e.g. `not foo`. + # + # @return [Boolean] whether this method is a prefix not + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#207 + def prefix_not?; end + + # Checks whether the *explicit* receiver of this node is `self`. + # + # @return [Boolean] whether the receiver of this node is `self` + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#186 + def self_receiver?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#16 +RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#10 +RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#32 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#24 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#48 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#28 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#59 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#26 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# http://phrogz.net/programmingruby/language.html#table_18.4 +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#20 +RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# Common functionality for nodes that can be used as modifiers: +# `if`, `while`, `until` +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/modifier_node.rb#7 +module RuboCop::AST::ModifierNode + # Checks whether the node is in a modifier form, i.e. a condition + # trailing behind an expression. + # + # @return [Boolean] whether the node is a modifier + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/modifier_node.rb#12 + def modifier_form?; end +end + +# A node extension for `module` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `module` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#11 +class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node + # The body of this `module` node. + # + # @return [Node, nil] the body of the module + # + # source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#19 + def body; end + + # The identifier for this `module` node. + # + # @return [Node] the identifier of the module + # + # source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#12 + def identifier; end +end + +# A node extension for `next` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `next` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/next_node.rb#8 +class RuboCop::AST::NextNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# `RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides +# access to parent nodes and an object-oriented way to traverse an AST with +# the power of `Enumerable`. +# +# It has predicate methods for every node type, like this: +# +# @example +# node.send_type? # Equivalent to: `node.type == :send` +# node.op_asgn_type? # Equivalent to: `node.type == :op_asgn` +# +# # Non-word characters (other than a-zA-Z0-9_) in type names are omitted. +# node.defined_type? # Equivalent to: `node.type == :defined?` +# +# # Find the first lvar node under the receiver node. +# lvar_node = node.each_descendant.find(&:lvar_type?) +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#21 +class RuboCop::AST::Node < ::Parser::AST::Node + include ::RuboCop::AST::Sexp + include ::RuboCop::AST::Descendence + extend ::RuboCop::AST::NodePattern::Macros + + # @return [Node] a new instance of Node + # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#92 + def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def __ENCODING___type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def __FILE___type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def __LINE___type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def alias_type?; end + + # Returns an array of ancestor nodes. + # This is a shorthand for `node.each_ancestor.to_a`. + # + # @return [Array] an array of ancestor nodes + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#247 + def ancestors; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def and_asgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def and_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def arg_expr_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def arg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def args_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#464 + def argument?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#468 + def argument_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def array_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def array_pattern_with_tail_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def array_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#416 + def assignment?; end + + # Some cops treat the shovel operator as a kind of assignment. + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#355 + def assignment_or_similar?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def back_ref_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#420 + def basic_conditional?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#363 + def basic_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def begin_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def block_pass_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def block_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def blockarg_expr_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def blockarg_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#472 + def boolean_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def break_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#456 + def call_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def case_match_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def case_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def casgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def cbase_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#460 + def chained?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#512 + def class_constructor?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#530 + def class_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def class_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#144 + def complete!; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#149 + def complete?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def complex_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#424 + def conditional?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#293 + def const_name; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def const_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def const_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def csend_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def cvar_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def cvasgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def def_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#314 + def defined_module; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#319 + def defined_module_name; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def defined_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def defs_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def dstr_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def dsym_type?; end + + # Calls the given block for each ancestor node from parent to root. + # If no block is given, an `Enumerator` is returned. + # + # @overload each_ancestor + # @overload each_ancestor + # @overload each_ancestor + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each ancestor node + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#235 + def each_ancestor(*types, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def eflipflop_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def empty_else_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#349 + def empty_source?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def ensure_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#408 + def equals_asgn?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def erange_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def false_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#371 + def falsey_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def find_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#261 + def first_line; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def float_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def for_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def forward_arg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def forward_args_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def forwarded_args_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def forwarded_kwrestarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def forwarded_restarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#509 + def global_const?(param0 = T.unsafe(nil), param1); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#484 + def guard_clause?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def gvar_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def gvasgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def hash_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def hash_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def ident_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def if_guard_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def if_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def iflipflop_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#379 + def immutable_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def in_match_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def in_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def index_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def indexasgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def int_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def irange_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def ivar_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def ivasgn_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#437 + def keyword?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwargs_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwbegin_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwnilarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwoptarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwrestarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def kwsplat_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#503 + def lambda?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#506 + def lambda_or_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def lambda_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#265 + def last_line; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Node, nil] the left (aka previous) sibling + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#187 + def left_sibling; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Array] the left (aka previous) siblings + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#197 + def left_siblings; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#269 + def line_count; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#359 + def literal?; end + + # NOTE: `loop { }` is a normal method call and thus not a loop keyword. + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#433 + def loop_keyword?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def lvar_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def lvasgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def masgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_alt_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_as_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_current_line_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#491 + def match_guard_clause?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_nil_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_pattern_p_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_pattern_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_rest_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_var_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_with_lvasgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def match_with_trailing_comma_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def mlhs_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#537 + def module_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def module_type?; end + + # Predicates + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#341 + def multiline?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#375 + def mutable_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#671 + def new_class_or_module_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def next_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def nil_type?; end + + # Common destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # Some node types override this with their own custom + # destructuring method. + # + # @return [Array] the different parts of the ndde + # + # source://ast/2.4.2/lib/ast/node.rb#56 + def node_parts; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#275 + def nonempty_line_count; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def not_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def nth_ref_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def numargs_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def numblock_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#476 + def numeric_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def objc_kwarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def objc_restarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def objc_varargs_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def op_asgn_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#448 + def operator_keyword?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def optarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def or_asgn_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def or_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def pair_type?; end + + # Returns the parent node, or `nil` if the receiver is a root node. + # + # @return [Node, nil] the parent node or `nil` + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#126 + def parent; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#135 + def parent?; end + + # Searching the AST + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#325 + def parent_module_name; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#452 + def parenthesized_call?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def pin_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#428 + def post_condition_loop?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def postexe_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def preexe_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#496 + def proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def procarg0_type?; end + + # Some expressions are evaluated for their value, some for their side + # effects, and some for both. + # If we know that expressions are useful only for their return values, + # and have no side effects, that means we can reorder them, change the + # number of times they are evaluated, or replace them with other + # expressions which are equivalent in value. + # So, is evaluation of this node free of side effects? + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#582 + def pure?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#480 + def range_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def rational_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#286 + def receiver(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#386 + def recursive_basic_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#386 + def recursive_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def redo_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#404 + def reference?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def regexp_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def regopt_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def resbody_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def rescue_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def restarg_expr_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def restarg_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def retry_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def return_type?; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Node, nil] the right (aka next) sibling + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#178 + def right_sibling; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Array] the right (aka next) siblings + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#206 + def right_siblings; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#140 + def root?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def sclass_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def self_type?; end + + # Most nodes are of 'send' type, so this method is defined + # separately to make this check as fast as possible. + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#119 + def send_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def shadowarg_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#412 + def shorthand_asgn?; end + + # Returns the index of the receiver node in its siblings. (Sibling index + # uses zero based numbering.) + # Use is discouraged, this is a potentially slow method. + # + # @return [Integer, nil] the index of the receiver node in its siblings + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#171 + def sibling_index; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#345 + def single_line?; end + + # NOTE: Some rare nodes may have no source, like `s(:args)` in `foo {}` + # + # @return [String, nil] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#253 + def source; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#279 + def source_length; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#257 + def source_range; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#444 + def special_keyword?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def splat_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#291 + def str_content(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def str_type?; end + + # @deprecated Use `:class_constructor?` + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#525 + def struct_constructor?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def super_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def sym_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def true_type?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#367 + def truthy_literal?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def undef_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def unless_guard_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def until_post_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def until_type?; end + + # Override `AST::Node#updated` so that `AST::Processor` does not try to + # mutate our ASTs. Since we keep references from children to parents and + # not just the other way around, we cannot update an AST and share + # identical subtrees. Rather, the entire AST must be copied any time any + # part of it is changed. + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#160 + def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end + + # Some expressions are evaluated for their value, some for their side + # effects, and some for both + # If we know that an expression is useful only for its side effects, that + # means we can transform it in ways which preserve the side effects, but + # change the return value + # So, does the return value of this node matter? If we changed it to + # `(...; nil)`, might that affect anything? + # + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#551 + def value_used?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#400 + def variable?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def when_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def while_post_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def while_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def xstr_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def yield_type?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#111 + def zsuper_type?; end + + protected + + # source://rubocop-ast//lib/rubocop/ast/node.rb#130 + def parent=(node); end + + private + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#610 + def begin_value_used?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#621 + def case_if_value_used?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#305 + def defined_module0(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#615 + def for_value_used?; end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#657 + def parent_module_name_for_block(ancestor); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#645 + def parent_module_name_for_sclass(sclass_node); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#632 + def parent_module_name_part(node); end + + # source://rubocop-ast//lib/rubocop/ast/node.rb#600 + def visit_ancestors(types); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node.rb#627 + def while_until_value_used?; end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#80 +RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#55 +RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#58 +RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#42 +RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set) + +# <=> isn't included here, because it doesn't return a boolean. +# +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#28 +RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#39 +RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#60 +RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node.rb#87 +RuboCop::AST::Node::EMPTY_CHILDREN = T.let(T.unsafe(nil), Array) + +# source://rubocop-ast//lib/rubocop/ast/node.rb#88 +RuboCop::AST::Node::EMPTY_PROPERTIES = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#50 +RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#35 +RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#47 +RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#70 +RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#37 +RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node.rb#83 +RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node.rb#84 +RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#64 +RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#44 +RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#76 +RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#62 +RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#68 +RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#53 +RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#78 +RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#31 +RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node.rb#66 +RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set) + +# This class performs a pattern-matching operation on an AST node. +# +# Detailed syntax: /docs/modules/ROOT/pages/node_pattern.adoc +# +# Initialize a new `NodePattern` with `NodePattern.new(pattern_string)`, then +# pass an AST node to `NodePattern#match`. Alternatively, use one of the class +# macros in `NodePattern::Macros` to define your own pattern-matching method. +# +# If the match fails, `nil` will be returned. If the match succeeds, the +# return value depends on whether a block was provided to `#match`, and +# whether the pattern contained any "captures" (values which are extracted +# from a matching AST.) +# +# - With block: #match yields the captures (if any) and passes the return +# value of the block through. +# - With no block, but one capture: the capture is returned. +# - With no block, but multiple captures: captures are returned as an array. +# - With no block and no captures: #match returns `true`. +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#5 +class RuboCop::AST::NodePattern + include ::RuboCop::AST::NodePattern::MethodDefiner + extend ::Forwardable + + # @return [NodePattern] a new instance of NodePattern + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#77 + def initialize(str, compiler: T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#90 + def ==(other); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#107 + def as_json(_options = T.unsafe(nil)); end + + # Returns the value of attribute ast. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 + def ast; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def captures(*args, **_arg1, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#111 + def encode_with(coder); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#90 + def eql?(other); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#119 + def freeze; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#115 + def init_with(coder); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#103 + def marshal_dump; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#99 + def marshal_load(pattern); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#85 + def match(*args, **rest, &block); end + + # Returns the value of attribute match_code. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 + def match_code; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def named_parameters(*args, **_arg1, &block); end + + # Returns the value of attribute pattern. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73 + def pattern; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def positional_parameters(*args, **_arg1, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#95 + def to_s; end + + class << self + # Yields its argument and any descendants, depth-first. + # + # @yield [element] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#59 + def descend(element, &block); end + end +end + +# Responsible to build the AST nodes for `NodePattern` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#10 +class RuboCop::AST::NodePattern::Builder + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#17 + def emit_atom(type, value); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#29 + def emit_call(type, selector, args = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#11 + def emit_capture(capture_token, node); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#25 + def emit_list(type, _begin, children, _end); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#41 + def emit_subsequence(node_list); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#21 + def emit_unary_op(type, _operator = T.unsafe(nil), *children); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#34 + def emit_union(begin_t, pattern_lists, end_t); end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#53 + def n(type, *args); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#49 + def optimizable_as_set?(children); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#57 + def union_children(pattern_lists); end +end + +# A NodePattern comment, simplified version of ::Parser::Source::Comment +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#7 +class RuboCop::AST::NodePattern::Comment + # @param range [Parser::Source::Range] + # @return [Comment] a new instance of Comment + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#14 + def initialize(range); end + + # Compares comments. Two comments are equal if they + # correspond to the same source range. + # + # @param other [Object] + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#31 + def ==(other); end + + # @return [String] a human-readable representation of this comment + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#39 + def inspect; end + + # Returns the value of attribute location. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#8 + def loc; end + + # Returns the value of attribute location. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#8 + def location; end + + # @return [String] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#20 + def text; end +end + +# The top-level compiler holding the global state +# Defers work to its subcompilers +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#11 +class RuboCop::AST::NodePattern::Compiler + extend ::Forwardable + + # @return [Compiler] a new instance of Compiler + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#15 + def initialize; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def bind(*args, **_arg1, &block); end + + # Returns the value of attribute binding. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13 + def binding; end + + # Returns the value of attribute captures. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13 + def captures; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#42 + def compile_as_atom(node); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#46 + def compile_as_node_pattern(node, **options); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#50 + def compile_sequence(sequence, var:); end + + # Enumerates `enum` while keeping track of state across + # union branches (captures and unification). + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#38 + def each_union(enum, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#74 + def freeze; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#31 + def named_parameter(name); end + + # Returns the value of attribute named_parameters. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13 + def named_parameters; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#70 + def next_capture; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#54 + def parser; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#26 + def positional_parameter(number); end + + # Returns the value of attribute positional_parameters. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13 + def positional_parameters; end + + # Utilities + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#60 + def with_temp_variables(*names, &block); end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#81 + def enforce_same_captures(enum); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#96 + def new_capture; end +end + +# Generates code that evaluates to a value (Ruby object) +# This value responds to `===`. +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#12 +class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#28 + def visit_const; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#32 + def visit_named_parameter; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21 + def visit_number; end + + # Assumes other types are node patterns. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#46 + def visit_other_type; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#36 + def visit_positional_parameter; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21 + def visit_regexp; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#40 + def visit_set; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21 + def visit_string; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21 + def visit_symbol; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#15 + def visit_unify; end +end + +# Holds the list of bound variable names +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#8 +class RuboCop::AST::NodePattern::Compiler::Binding + # @return [Binding] a new instance of Binding + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#9 + def initialize; end + + # Yields the first time a given name is bound + # + # @return [String] bound variable name + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#16 + def bind(name); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#30 + def union_bind(enum); end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#69 + def forbid(names); end +end + +# Variant of the Compiler with tracing information for nodes +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#12 +class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler + # @return [Debug] a new instance of Debug + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#123 + def initialize; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def comments(*args, **_arg1, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#128 + def named_parameters; end + + # Returns the value of attribute node_ids. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#33 + def node_ids; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#132 + def parser; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def tokens(*args, **_arg1, &block); end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#36 +class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer + # @api private + # @return [Colorizer] a new instance of Colorizer + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#96 + def initialize(pattern, compiler: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94 + def compiler; end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94 + def node_pattern; end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94 + def pattern; end + + # @api private + # @return [Node] the Ruby AST + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#103 + def test(ruby, trace: T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#111 + def ruby_ast(ruby); end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#116 + def ruby_parser; end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#37 +RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#92 +RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug + +# Result of a NodePattern run against a particular AST +# Consider constructor is private +# +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#46 +class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct + # @api private + # @return [Hash] a map for {character_position => color} + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#56 + def color_map(color_scheme = T.unsafe(nil)); end + + # @api private + # @return [String] a Rainbow colorized version of ruby + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#48 + def colorize(color_scheme = T.unsafe(nil)); end + + # Returns the value of attribute colorizer + # + # @return [Object] the current value of colorizer + def colorizer; end + + # Sets the attribute colorizer + # + # @param value [Object] the value to set the attribute colorizer to. + # @return [Object] the newly set value + def colorizer=(_); end + + # @api private + # @return [Hash] a map for {node => matched?}, depth-first + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#66 + def match_map; end + + # @api private + # @return [Boolean] a value of `Trace#matched?` or `:not_visitable` + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#74 + def matched?(node); end + + # Returns the value of attribute returned + # + # @return [Object] the current value of returned + def returned; end + + # Sets the attribute returned + # + # @param value [Object] the value to set the attribute returned to. + # @return [Object] the newly set value + def returned=(_); end + + # Returns the value of attribute ruby_ast + # + # @return [Object] the current value of ruby_ast + def ruby_ast; end + + # Sets the attribute ruby_ast + # + # @param value [Object] the value to set the attribute ruby_ast to. + # @return [Object] the newly set value + def ruby_ast=(_); end + + # Returns the value of attribute trace + # + # @return [Object] the current value of trace + def trace; end + + # Sets the attribute trace + # + # @param value [Object] the value to set the attribute trace to. + # @return [Object] the newly set value + def trace=(_); end + + private + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#87 + def ast; end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#81 + def color_map_for(node, color); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#139 +module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#140 + def do_compile; end + + private + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#150 + def node_id; end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#146 + def tracer(kind); end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#156 +class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler + include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#161 +class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler + include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler +end + +# Compiled node pattern requires a named parameter `trace`, +# which should be an instance of this class +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#13 +class RuboCop::AST::NodePattern::Compiler::Debug::Trace + # @return [Trace] a new instance of Trace + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#14 + def initialize; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#18 + def enter(node_id); end + + # return nil (not visited), false (not matched) or true (matched) + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#28 + def matched?(node_id); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#23 + def success(node_id); end +end + +# Compiles code that evalues to true or false +# for a given value `var` (typically a RuboCop::AST::Node) +# or it's `node.type` if `seq_head` is true +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#13 +class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + # @return [NodePatternSubcompiler] a new instance of NodePatternSubcompiler + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#16 + def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end + + # Returns the value of attribute access. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#14 + def access; end + + # Returns the value of attribute seq_head. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#14 + def seq_head; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#119 + def access_element; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#123 + def access_node; end + + # @param [Array, nil] + # @return [String, nil] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#113 + def compile_args(arg_list, first: T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#129 + def compile_guard_clause; end + + # Compiling helpers + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#107 + def compile_value_match(value); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#133 + def multiple_access(kind); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#30 + def visit_ascend; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#58 + def visit_capture; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#37 + def visit_descend; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#84 + def visit_function_call; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#73 + def visit_intersection; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#25 + def visit_negation; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#88 + def visit_node_type; end + + # Assumes other types are atoms. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#100 + def visit_other_type; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#80 + def visit_predicate; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#92 + def visit_sequence; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#49 + def visit_unify; end + + # Lists + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#64 + def visit_union; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#45 + def visit_wildcard; end +end + +# Compiles terms within a sequence to code that evalues to true or false. +# Compilation of the nodes that can match only a single term is deferred to +# `NodePatternSubcompiler`; only nodes that can match multiple terms are +# compiled here. +# Assumes the given `var` is a `::RuboCop::AST::Node` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#17 +class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + # Calls `compile_sequence`; the actual `compile` method + # will be used for the different terms of the sequence. + # The only case of re-entrant call to `compile` is `visit_capture` + # + # @return [SequenceSubcompiler] a new instance of SequenceSubcompiler + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#25 + def initialize(compiler, sequence:, var:); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#31 + def compile_sequence; end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#251 + def in_sync; end + + protected + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#226 + def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#251 + def cur_index; end + + # yield `sync_code` iff not already in sync + # + # @yield [code] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#242 + def sync; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#20 + def compile(node); end + + # Compilation helpers + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#165 + def compile_and_advance(term); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#128 + def compile_any_order_branches(matched_var); end + + # @return [Array] Else code, and init code (if any) + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#137 + def compile_any_order_else; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#180 + def compile_captured_repetition(child_code, child_captures); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#119 + def compile_case(when_branches, else_code); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#361 + def compile_child_nb_guard(arity_range); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#319 + def compile_cur_index; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#325 + def compile_index(cur = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#353 + def compile_loop(term); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#347 + def compile_loop_advance(to = T.unsafe(nil)); end + + # Assumes `@cur_index` is already updated + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#198 + def compile_matched(kind); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#304 + def compile_max_matched; end + + # @return [String] code that evaluates to `false` if the matched arity is too small + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#270 + def compile_min_check; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#285 + def compile_remaining; end + + # @return [Hash] of {subcompiler => code} + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#373 + def compile_union_forks; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#313 + def empty_loop; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#214 + def handle_prev; end + + # Modifies in place `forks` + # Syncs our state + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#400 + def merge_forks!(forks); end + + # Modifies in place `forks` to insure that `cur_{child|index}_var` are ok + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#384 + def preserve_union_start(forks); end + + # E.g. For sequence `(_ _? <_ _>)`, arities are: 1, 0..1, 2 + # and remaining arities are: 3..4, 2..3, 2..2, 0..0 + # + # @return [Array] total arities (as Ranges) of remaining children nodes + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#259 + def remaining_arities(children, last_arity); end + + # returns truthy iff `@cur_index` switched to relative from end mode (i.e. < 0) + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#341 + def use_index_from_end; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#88 + def visit_any_order; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#150 + def visit_capture; end + + # Single node patterns are all handled here + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#62 + def visit_other_type; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#78 + def visit_repetition; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#159 + def visit_rest; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#104 + def visit_union; end + + # NOTE: assumes `@cur_index != :seq_head`. Node types using `within_loop` must + # have `def in_sequence_head; :raise; end` + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#333 + def within_loop; end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#18 +RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#19 +RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc) + +# Base class for subcompilers +# Implements visitor pattern +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#12 +class RuboCop::AST::NodePattern::Compiler::Subcompiler + # @return [Subcompiler] a new instance of Subcompiler + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#15 + def initialize(compiler); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#20 + def compile(node); end + + # Returns the value of attribute compiler. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#13 + def compiler; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#34 + def do_compile; end + + # Returns the value of attribute node. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#32 + def node; end + + class << self + # @private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#47 + def inherited(base); end + + # @private + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#42 + def method_added(method); end + + # Returns the value of attribute registry. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#40 + def registry; end + end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#53 +class RuboCop::AST::NodePattern::Invalid < ::StandardError; end + +# Lexer class for `NodePattern` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#18 +class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex + # @return [Lexer] a new instance of Lexer + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#31 + def initialize(source); end + + # Returns the value of attribute comments. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29 + def comments; end + + # Returns the value of attribute source_buffer. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29 + def source_buffer; end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29 + def tokens; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#60 + def do_parse; end + + # @return [token] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#40 + def emit(type); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#48 + def emit_comment; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#52 + def emit_regexp; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#64 + def token(type, value); end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#19 +RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#21 +RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash) + +# The generated lexer RuboCop::AST::NodePattern::LexerRex +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#23 +class RuboCop::AST::NodePattern::LexerRex + # Yields on the current action. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#69 + def action; end + + # The file name / path + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#43 + def filename; end + + # The file name / path + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#43 + def filename=(_arg0); end + + # The current location in the parse. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#104 + def location; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48 + def match; end + + # The match groups for the current scan. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#60 + def matches; end + + # Lex the next token. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#113 + def next_token; end + + # Parse the given string. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#84 + def parse(str); end + + # Read in and parse the file at +path+. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#94 + def parse_file(path); end + + # The current scanner class. Must be overridden in subclasses. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#77 + def scanner_class; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48 + def ss; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48 + def ss=(_arg0); end + + # The current lexical state. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#53 + def state; end + + # The current lexical state. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#53 + def state=(_arg0); end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#31 +RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp) + +# :stopdoc: +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#27 +RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#29 +RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +# :startdoc: +# :stopdoc: +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#36 +class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#30 +RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#33 +RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#32 +RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#28 +RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#37 +class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end + +# Helpers for defining methods based on a pattern string +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#28 +module RuboCop::AST::NodePattern::Macros + # Define a method which applies a pattern to an AST node + # + # The new method will return nil if the node does not match. + # If the node matches, and a block is provided, the new method will + # yield to the block (passing any captures as block arguments). + # If the node matches, and no block is provided, the new method will + # return the captures, or `true` if there were none. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#36 + def def_node_matcher(method_name, pattern_str, **keyword_defaults); end + + # Define a method which recurses over the descendants of an AST node, + # checking whether any of them match the provided pattern + # + # If the method name ends with '?', the new method will return `true` + # as soon as it finds a descendant which matches. Otherwise, it will + # yield all descendants which match. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#46 + def def_node_search(method_name, pattern_str, **keyword_defaults); end +end + +# Functionality to turn `match_code` into methods/lambda +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#7 +module RuboCop::AST::NodePattern::MethodDefiner + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#37 + def as_lambda; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#27 + def compile_as_lambda; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#8 + def def_node_matcher(base, method_name, **defaults); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#21 + def def_node_search(base, method_name, **defaults); end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#139 + def compile_init; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#50 + def def_helper(base, method_name, **defaults); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#114 + def emit_keyword_list(forwarding: T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#132 + def emit_lambda_code; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#125 + def emit_method_code; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#63 + def emit_node_search(method_name); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#74 + def emit_node_search_body(method_name, prelude:, on_match:); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#110 + def emit_param_list; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#119 + def emit_params(*first, forwarding: T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#100 + def emit_retval; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#89 + def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end + + # This method minimizes the closure for our method + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#44 + def wrapping_block(method_name, **defaults); end +end + +# Base class for AST Nodes of a `NodePattern` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#7 +class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node + include ::RuboCop::AST::Descendence + extend ::Forwardable + + # Note: `arity.end` may be `Float::INFINITY` + # + # @return [Integer, Range] An Integer for fixed length terms, otherwise a Range. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#29 + def arity; end + + # @return [Range] arity as a Range + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#69 + def arity_range; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#23 + def capture?; end + + # @return [Node] most nodes have only one child + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#48 + def child; end + + # @return [Array] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#43 + def children_nodes; end + + # @return [Array, nil] replace node with result, or `nil` if no change requested. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#34 + def in_sequence_head; end + + # that matches within a Set (e.g. `42`, `:sym` but not `/regexp/`) + # + # @return [Boolean] returns true for nodes having a Ruby literal equivalent + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#64 + def matches_within_set?; end + + # @return [Integer] nb of captures of that node and its descendants + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#53 + def nb_captures; end + + # To be overridden by subclasses + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#19 + def rest?; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#78 + def source_range; end + + # @return [Boolean] returns whether it matches a variable number of elements + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#58 + def variadic?; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#74 + def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end +end + +# Node class for `` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#180 +class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#198 + def arity; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#190 + def ends_with_rest?; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#194 + def rest_node; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#186 + def term_nodes; end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#183 +RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash) + +# Node class for `$something` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#98 +class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node + # source://forwardable/1.3.2/forwardable.rb#229 + def arity(*args, **_arg1, &block); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#101 + def capture?; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#109 + def in_sequence_head; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#105 + def nb_captures; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def rest?(*args, **_arg1, &block); end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#86 +module RuboCop::AST::NodePattern::Node::ForbidInSeqHead + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#87 + def in_sequence_head; end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#140 +RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#82 +RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash) + +# Registry +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#250 +RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#12 +RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set) + +# Node class for `predicate?(:arg, :list)` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#131 +class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#136 + def arg_list; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#132 + def method_name; end +end + +# Node class for `int+` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#143 +class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#156 + def arity; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#146 + def operator; end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#150 +RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash) + +# Node class for `...` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#162 +class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#170 + def arity; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#174 + def in_sequence_head; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#166 + def rest?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#163 +RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range) + +# Node class for `(type first second ...)` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#118 +class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # @return [Sequence] a new instance of Sequence + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#121 + def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end +end + +# A list (potentially empty) of nodes; part of a Union +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#206 +class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#209 + def arity; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#214 + def in_sequence_head; end +end + +# Node class for `{ ... }` +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#224 +class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#225 + def arity; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#232 + def in_sequence_head; end +end + +# Parser for NodePattern +# Note: class reopened in `parser.racc` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#13 +class RuboCop::AST::NodePattern::Parser < ::Racc::Parser + extend ::Forwardable + + # @return [Parser] a new instance of Parser + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#19 + def initialize(builder = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#335 + def _reduce_10(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#339 + def _reduce_11(val, _values); end + + # reduce 12 omitted + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#345 + def _reduce_13(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#349 + def _reduce_14(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#353 + def _reduce_15(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#357 + def _reduce_16(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#361 + def _reduce_17(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#365 + def _reduce_18(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#369 + def _reduce_19(val, _values); end + + # reduce 1 omitted + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#303 + def _reduce_2(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#373 + def _reduce_20(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#377 + def _reduce_21(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#381 + def _reduce_22(val, _values); end + + # reduce 24 omitted + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#389 + def _reduce_25(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#395 + def _reduce_26(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#307 + def _reduce_3(val, _values); end + + # reduce 32 omitted + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#415 + def _reduce_33(val, _values); end + + # reduce 36 omitted + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#425 + def _reduce_37(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#429 + def _reduce_38(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#433 + def _reduce_39(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#311 + def _reduce_4(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#437 + def _reduce_40(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#441 + def _reduce_41(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#445 + def _reduce_42(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#449 + def _reduce_43(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#453 + def _reduce_44(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#457 + def _reduce_45(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#461 + def _reduce_46(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#315 + def _reduce_5(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#319 + def _reduce_6(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#323 + def _reduce_7(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#327 + def _reduce_8(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#331 + def _reduce_9(val, _values); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#465 + def _reduce_none(val, _values); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_atom(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_call(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_capture(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_list(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_unary_op(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def emit_union(*args, **_arg1, &block); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#40 + def inspect; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def next_token(*args, **_arg1, &block); end + + # (Similar API to `parser` gem) + # Parses a source and returns the AST. + # + # @param source_buffer [Parser::Source::Buffer, String] The source buffer to parse. + # @return [NodePattern::Node] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#31 + def parse(source); end + + private + + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#50 + def enforce_unary(node); end + + # Overrides Racc::Parser's method: + # + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#59 + def on_error(token, val, _vstack); end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#16 +RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#17 +RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#227 +RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#295 +RuboCop::AST::NodePattern::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#244 +RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) + +# Overrides Parser to use `WithMeta` variants and provide additional methods +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#9 +class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser + # Returns the value of attribute comments. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#98 + def comments; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#100 + def do_parse; end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#98 + def tokens; end +end + +# Overrides Builder to emit nodes with locations +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#39 +class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#40 + def emit_atom(type, token); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#61 + def emit_call(type, selector_t, args = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#55 + def emit_list(type, begin_t, children, end_t); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#49 + def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end + + private + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#81 + def join_exprs(left_expr, right_expr); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#75 + def loc(token_or_range); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#71 + def n(type, children, source_map); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#85 + def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end +end + +# Overrides Lexer to token locations and comments +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#10 +class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer + # @return [Lexer] a new instance of Lexer + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#13 + def initialize(str_or_buffer); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#27 + def emit_comment; end + + # @return [::Parser::Source::Range] last match's position + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#33 + def pos; end + + # Returns the value of attribute source_buffer. + # + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#11 + def source_buffer; end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#23 + def token(type, value); end +end + +# Utility to assign a set of values to a constant +# +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#7 +module RuboCop::AST::NodePattern::Sets + class << self + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#31 + def [](set); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#15 + def name(set); end + + # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#22 + def uniq(name); end + end +end + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#14 +RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#8 +RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ALL_ANY_CLASS_OF_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY_NONE_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_EMPTY_ASSERT_NOT_EMPTY_REFUTE_EMPTY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_EQUAL_ASSERT_NOT_EQUAL_REFUTE_EQUAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_FALSE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_INCLUDES_ASSERT_NOT_INCLUDES_REFUTE_INCLUDES = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_INSTANCE_OF_ASSERT_NOT_INSTANCE_OF_REFUTE_INSTANCE_OF = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_IN_DELTA_ASSERT_NOT_IN_DELTA_REFUTE_IN_DELTA = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_KIND_OF_ASSERT_NOT_KIND_OF_REFUTE_KIND_OF = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_MATCH_REFUTE_MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_NIL_ASSERT_NOT_NIL_REFUTE_NIL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_PREDICATE_ASSERT_NOT_PREDICATE_REFUTE_PREDICATE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ASSERT_TRUE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CLONE_DUP_FREEZE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_CONTEXT_FEATURE_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ENV = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EXIST_EXISTS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FACTORY_TRAIT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FILETEST_FILE_DIR_SHELL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FILE_DIR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FILE_FILETEST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FILE_TEMPFILE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FILE_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_GETHOSTBYADDR_GETHOSTBYNAME = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_MATCH___MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_MODULE_FUNCTION_RUBY2_KEYWORDS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PRESENT_ANY_BLANK_EMPTY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PRIVATE_CLASS_METHOD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_READ_BINREAD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_REJECT_DELETE_IF_REJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SEND___SEND__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SIG_HELPERS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SORT_SORT_MIN_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_STATUS_CODE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_STRUCT_IMMUTABLESTRUCT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_STRUCT_IMMUTABLESTRUCT_INEXACTSTRUCT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TEXT_EXACT_TEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C_TO_R = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TO_TO_NOT_NOT_TO = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__EQL_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__FETCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___9 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___EQL_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___EQL_INCLUDE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET____ETC_4 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10 +RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#55 +RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String) + +# Common functionality for primitive numeric nodes: `int`, `float`, ... +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#6 +module RuboCop::AST::NumericNode + # Checks whether this is literal has a sign. + # + # @example + # + # +42 + # @return [Boolean] whether this literal has a sign. + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#17 + def sign?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#7 +RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp) + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#9 +class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node + # @return [AsgnNode] the assignment node + # + # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#10 + def assignment_node; end + + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#31 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#17 + def name; end + + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#24 + def operator; end +end + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#11 +class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#12 + def operator; end +end + +# A node extension for `or` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `or` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#8 +class RuboCop::AST::OrNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + + # Returns the alternate operator of the `or` as a string. + # Returns `or` for `||` and vice versa. + # + # @return [String] the alternate of the `or` operator + # + # source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#16 + def alternate_operator; end + + # Returns the inverse keyword of the `or` node as a string. + # Returns `and` for `or` and `&&` for `||`. + # + # @return [String] the inverse of the `or` operator + # + # source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#24 + def inverse_operator; end +end + +# A node extension for `pair` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `pair` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#8 +class RuboCop::AST::PairNode < ::RuboCop::AST::Node + include ::RuboCop::AST::HashElementNode + + # Checks whether the `pair` uses a colon delimiter. + # + # @return [Boolean] whether this `pair` uses a colon delimiter + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#30 + def colon?; end + + # Returns the delimiter of the `pair` as a string. Returns `=>` for a + # colon delimited `pair` and `:` for a hash rocket delimited `pair`. + # + # @param with_spacing [Boolean] whether to include spacing + # @return [String] the delimiter of the `pair` + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#39 + def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end + + # Checks whether the `pair` uses a hash rocket delimiter. + # + # @return [Boolean] whether this `pair` uses a hash rocket delimiter + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#23 + def hash_rocket?; end + + # Returns the inverse delimiter of the `pair` as a string. + # + # @param with_spacing [Boolean] whether to include spacing + # @return [String] the inverse delimiter of the `pair` + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#51 + def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end + + # Checks whether the `pair` uses hash value omission. + # + # @return [Boolean] whether this `pair` uses hash value omission + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#69 + def value_omission?; end + + # Checks whether the value starts on its own line. + # + # @return [Boolean] whether the value in the `pair` starts its own line + # + # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#62 + def value_on_new_line?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#15 +RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#11 +RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#17 +RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#13 +RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String) + +# Requires implementing `arguments`. +# +# Common functionality for nodes that are parameterized: +# `send`, `super`, `zsuper`, `def`, `defs` +# and (modern only): `index`, `indexasgn`, `lambda` +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#10 +module RuboCop::AST::ParameterizedNode + # Checks whether this node has any arguments. + # + # @return [Boolean] whether this node has any arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#40 + def arguments?; end + + # Whether the last argument of the node is a block pass, + # i.e. `&block`. + # + # @return [Boolean] whether the last argument of the node is a block pass + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#58 + def block_argument?; end + + # A shorthand for getting the first argument of the node. + # Equivalent to `arguments.first`. + # + # @return [Node, nil] the first argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#24 + def first_argument; end + + # A shorthand for getting the last argument of the node. + # Equivalent to `arguments.last`. + # + # @return [Node, nil] the last argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#33 + def last_argument; end + + # Checks whether this node's arguments are wrapped in parentheses. + # + # @return [Boolean] whether this node's arguments are + # wrapped in parentheses + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#15 + def parenthesized?; end + + # Checks whether any argument of the node is a splat + # argument, i.e. `*splat`. + # + # @return [Boolean] whether the node is a splat argument + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#48 + def rest_argument?; end + + # Checks whether any argument of the node is a splat + # argument, i.e. `*splat`. + # + # @return [Boolean] whether the node is a splat argument + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#48 + def splat_argument?; end +end + +# A specialized `ParameterizedNode`. +# Requires implementing `first_argument_index` +# Implements `arguments` as `children[first_argument_index..-1]` +# and optimizes other calls +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#83 +module RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::ParameterizedNode + + # @return [Array] arguments, if any + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#89 + def arguments; end + + # Checks whether this node has any arguments. + # + # @return [Boolean] whether this node has any arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#119 + def arguments?; end + + # A shorthand for getting the first argument of the node. + # Equivalent to `arguments.first`. + # + # @return [Node, nil] the first argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#103 + def first_argument; end + + # A shorthand for getting the last argument of the node. + # Equivalent to `arguments.last`. + # + # @return [Node, nil] the last argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#112 + def last_argument; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#86 +RuboCop::AST::ParameterizedNode::RestArguments::EMPTY_ARGUMENTS = T.let(T.unsafe(nil), Array) + +# A specialized `ParameterizedNode` for node that have a single child +# containing either `nil`, an argument, or a `begin` node with all the +# arguments +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#66 +module RuboCop::AST::ParameterizedNode::WrappedArguments + include ::RuboCop::AST::ParameterizedNode + + # @return [Array] The arguments of the node. + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#69 + def arguments; end +end + +# Common functionality for nodes that are predicates: +# `or`, `and` ... +# +# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#7 +module RuboCop::AST::PredicateOperatorNode + # Checks whether this is a logical operator. + # + # @return [Boolean] whether this is a logical operator + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#27 + def logical_operator?; end + + # Returns the operator as a string. + # + # @return [String] the operator + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#20 + def operator; end + + # Checks whether this is a semantic operator. + # + # @return [Boolean] whether this is a semantic operator + # + # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#34 + def semantic_operator?; end +end + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#8 +RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#12 +RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#10 +RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String) + +# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#14 +RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String) + +# A node extension for `procarg0` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all `arg` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#11 +class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode + # Returns the name of an argument. + # + # @return [Symbol, nil] the name of the argument + # + # source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#12 + def name; end +end + +# ProcessedSource contains objects which are generated by Parser +# and other information such as disabled lines for cops. +# It also provides a convenient way to access source lines. +# +# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#11 +class RuboCop::AST::ProcessedSource + # @return [ProcessedSource] a new instance of ProcessedSource + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#26 + def initialize(source, ruby_version, path = T.unsafe(nil)); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#63 + def [](*args); end + + # Returns the value of attribute ast. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def ast; end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#41 + def ast_with_comments; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#102 + def blank?; end + + # Returns the value of attribute buffer. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def buffer; end + + # Raw source checksum for tracking infinite loops. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#74 + def checksum; end + + # @return [Comment, nil] the comment at that line, if any. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#107 + def comment_at_line(line); end + + # Consider using `each_comment_in_lines` instead + # + # @deprecated use contains_comment? + # @return [Boolean] if any of the lines in the given `source_range` has a comment. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#129 + def commented?(source_range); end + + # Returns the value of attribute comments. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def comments; end + + # Should have been called `comments_before_or_at_line`. Doubtful it has of any valid use. + # + # @deprecated Use `each_comment_in_lines` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#137 + def comments_before_line(line); end + + # Consider using `each_comment_in_lines` instead + # + # @return [Boolean] if any of the lines in the given `source_range` has a comment. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#129 + def contains_comment?(source_range); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#151 + def current_line(token); end + + # Returns the value of attribute diagnostics. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def diagnostics; end + + # @deprecated Use `comments.each` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#79 + def each_comment(&block); end + + # Enumerates on the comments contained with the given `line_range` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#117 + def each_comment_in_lines(line_range); end + + # @deprecated Use `tokens.each` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#89 + def each_token(&block); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#98 + def file_path; end + + # @deprecated Use `comment_at_line`, `each_comment_in_lines`, or `comments.find` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#84 + def find_comment(&block); end + + # @deprecated Use `tokens.find` + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#94 + def find_token(&block); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#172 + def first_token_of(range_or_node); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#155 + def following_line(token); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#176 + def last_token_of(range_or_node); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#159 + def line_indentation(line_number); end + + # @return [Boolean] if the given line number has a comment. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#112 + def line_with_comment?(line); end + + # Returns the source lines, line break characters removed, excluding a + # possible __END__ and everything that comes after. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#49 + def lines; end + + # Returns the value of attribute parser_error. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def parser_error; end + + # Returns the value of attribute path. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def path; end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#147 + def preceding_line(token); end + + # Returns the value of attribute raw_source. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def raw_source; end + + # Returns the value of attribute ruby_version. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def ruby_version; end + + # The tokens list is always sorted by token position, except for cases when heredoc + # is passed as a method argument. In this case tokens are interleaved by + # heredoc contents' tokens. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#183 + def sorted_tokens; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#141 + def start_with?(string); end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#18 + def tokens; end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#166 + def tokens_within(range_or_node); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#67 + def valid_syntax?; end + + private + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#190 + def comment_index; end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#278 + def create_parser(ruby_version); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#294 + def first_token_index(range_or_node); end + + # 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 + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#304 + def source_range(range_or_node); end + + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#213 + def tokenize(parser); end + + class << self + # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#21 + def from_file(path, ruby_version); end + end +end + +# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#15 +RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#13 +RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String) + +# A node extension for `irange` and `erange` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its +# methods available to all `irange` and `erange` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#8 +class RuboCop::AST::RangeNode < ::RuboCop::AST::Node + # source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#9 + def begin; end + + # source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#13 + def end; end +end + +# A node extension for `regexp` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `regexp` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#8 +class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node + # @return [String] a string of regexp content + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#37 + def content; end + + # @return [Bool] if char is one of the delimiters + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#57 + def delimiter?(char); end + + # @return [String] the regexp delimiters (without %r) + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#52 + def delimiters; end + + # @return [Bool] if regexp uses the extended regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#72 + def extended?; end + + # @return [Bool] if regexp uses the fixed-encoding regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#92 + def fixed_encoding?; end + + # @return [Bool] if regexp uses the ignore-case regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#77 + def ignore_case?; end + + # @return [Bool] if regexp contains interpolation + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#62 + def interpolation?; end + + # @return [Bool] if regexp uses the multiline regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#67 + def multiline_mode?; end + + # @return [Bool] if regexp uses the no-encoding regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#87 + def no_encoding?; end + + # NOTE: The 'o' option is ignored. + # + # @return [Integer] the Regexp option bits as returned by Regexp#options + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#32 + def options; end + + # @return [Bool] if the regexp is a %r{...} literal (using any delimiters) + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#47 + def percent_r_literal?; end + + # @return [RuboCop::AST::Node] a regopt node + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#25 + def regopt; end + + # @return [Bool] if regexp uses the single-interpolation regopt + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#82 + def single_interpolation?; end + + # @return [Bool] if the regexp is a /.../ literal + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#42 + def slash_literal?; end + + # @return [Regexp] a regexp of this node + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#20 + def to_regexp; end + + private + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#98 + def regopt_include?(option); end +end + +# source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#9 +RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash) + +# A node extension for `resbody` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `resbody` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#11 +class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node + # Returns the body of the `rescue` clause. + # + # @return [Node, nil] The body of the `resbody`. + # + # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#12 + def body; end + + # Returns the index of the `resbody` branch within the exception handling statement. + # + # @return [Integer] the index of the `resbody` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#40 + def branch_index; end + + # Returns the exception variable of the `rescue` clause. + # + # @return [Node, nil] The exception variable of the `resbody`. + # + # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#33 + def exception_variable; end + + # Returns an array of all the exceptions in the `rescue` clause. + # + # @return [Array] an array of exception nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#19 + def exceptions; end +end + +# A node extension for `rescue` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `rescue` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#11 +class RuboCop::AST::RescueNode < ::RuboCop::AST::Node + # Returns the body of the rescue node. + # + # @return [Node, nil] The body of the rescue node. + # + # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#12 + def body; end + + # Returns an array of all the rescue branches in the exception handling statement. + # + # and the else (if any). Note that these bodies could be nil. + # + # @return [Array] an array of the bodies of the rescue branches + # + # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#27 + def branches; end + + # Checks whether this exception handling statement has an `else` branch. + # + # @return [Boolean] whether the exception handling statement has an `else` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#44 + def else?; end + + # Returns the else branch of the exception handling statement, if any. + # + # @return [Node] the else branch node of the exception handling statement + # @return [nil] if the exception handling statement does not have an else branch. + # + # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#37 + def else_branch; end + + # Returns an array of all the rescue branches in the exception handling statement. + # + # @return [Array] an array of `resbody` nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#19 + def resbody_branches; end +end + +# A node extension for `return` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `return` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/return_node.rb#8 +class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# Responsible for compatibility with main gem +# +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#8 +module RuboCop::AST::RuboCopCompatibility + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#13 + def rubocop_loaded; end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#9 +RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash) + +# A node extension for `sclass` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `sclass` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#11 +class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node + # The body of this `sclass` node. + # + # @return [Node, nil] the body of the class + # + # source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#19 + def body; end + + # The identifier for this `sclass` node. (Always `self`.) + # + # @return [Node] the identifier of the class + # + # source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#12 + def identifier; end +end + +# A node extension for `send` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `send` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#8 +class RuboCop::AST::SendNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#13 + def attribute_accessor?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#18 + def send_type?; end + + private + + # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#24 + def first_argument_index; end +end + +# This module provides a shorthand method to create a {Node} like +# `Parser::AST::Sexp`. +# +# @see https://www.rubydoc.info/gems/ast/AST/Sexp +# +# source://rubocop-ast//lib/rubocop/ast/sexp.rb#9 +module RuboCop::AST::Sexp + # Creates a {Node} with type `type` and children `children`. + # + # source://rubocop-ast//lib/rubocop/ast/sexp.rb#11 + def s(type, *children); end +end + +# A node extension for `str`, `dstr`, and `xstr` nodes. This will be used +# in place of a plain node when the builder constructs the AST, making +# its methods available to all `str` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#8 +class RuboCop::AST::StrNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#11 + def character_literal?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#15 + def heredoc?; end +end + +# A node extension for `super`- and `zsuper` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its +# methods available to all `super`- and `zsuper` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/super_node.rb#8 +class RuboCop::AST::SuperNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast/2.4.2/lib/ast/node.rb#56 + def arguments; end + + # Custom destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # + # @return [Array] the different parts of the `super` node + # + # source://rubocop-ast//lib/rubocop/ast/node/super_node.rb#16 + def node_parts; end +end + +# A node extension for `sym` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `sym` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/symbol_node.rb#8 +class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode +end + +# A basic wrapper around Parser's tokens. +# +# source://rubocop-ast//lib/rubocop/ast/token.rb#6 +class RuboCop::AST::Token + # @return [Token] a new instance of Token + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#17 + def initialize(pos, type, text); end + + # source://rubocop-ast//lib/rubocop/ast/token.rb#32 + def begin_pos; end + + # source://rubocop-ast//lib/rubocop/ast/token.rb#28 + def column; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#101 + def comma?; end + + # Type Predicates + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#57 + def comment?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#105 + def dot?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#117 + def end?; end + + # source://rubocop-ast//lib/rubocop/ast/token.rb#36 + def end_pos; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#121 + def equal_sign?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#65 + def left_array_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#81 + def left_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#73 + def left_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#85 + def left_curly_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#93 + def left_parens?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#69 + def left_ref_bracket?; end + + # source://rubocop-ast//lib/rubocop/ast/token.rb#24 + def line; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#125 + def new_line?; end + + # Returns the value of attribute pos. + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#9 + def pos; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#109 + def regexp_dots?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#113 + def rescue_modifier?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#77 + def right_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#89 + def right_curly_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#97 + def right_parens?; end + + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#61 + def semicolon?; end + + # Checks if there is whitespace after token + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#45 + def space_after?; end + + # Checks if there is whitespace before token + # + # @return [Boolean] + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#50 + def space_before?; end + + # Returns the value of attribute text. + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#9 + def text; end + + # source://rubocop-ast//lib/rubocop/ast/token.rb#40 + def to_s; end + + # Returns the value of attribute type. + # + # source://rubocop-ast//lib/rubocop/ast/token.rb#9 + def type; end + + class << self + # source://rubocop-ast//lib/rubocop/ast/token.rb#11 + def from_parser_token(parser_token); end + end +end + +# source://rubocop-ast//lib/rubocop/ast/token.rb#7 +RuboCop::AST::Token::LEFT_PAREN_TYPES = T.let(T.unsafe(nil), Array) + +# Provides methods for traversing an AST. +# Does not transform an AST; for that, use Parser::AST::Processor. +# Override methods to perform custom processing. Remember to call `super` +# if you want to recursively process descendant nodes. +# +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#9 +module RuboCop::AST::Traversal + extend ::RuboCop::AST::Traversal::CallbackCompiler + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#173 + def on_(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on___ENCODING__(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on___FILE__(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on___LINE__(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_alias(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_and(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_and_asgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_arg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_arg_expr(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_args(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_array(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_array_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_array_pattern_with_tail(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_back_ref(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_begin(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#151 + def on_block(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129 + def on_block_pass(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_blockarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_break(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_case(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_case_match(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#146 + def on_casgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_cbase(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#147 + def on_class(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_complex(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#145 + def on_const(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_const_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#155 + def on_csend(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_cvar(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131 + def on_cvasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#148 + def on_def(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_defined?(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#153 + def on_defs(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_dstr(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_dsym(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_eflipflop(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_empty_else(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_ensure(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_erange(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_false(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_find_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_float(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_for(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_forward_arg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_forward_args(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_forwarded_args(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_forwarded_kwrestarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_forwarded_restarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_gvar(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131 + def on_gvasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_hash(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_hash_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#150 + def on_if(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_if_guard(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_iflipflop(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_in_match(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_in_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_index(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_indexasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_int(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_irange(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_ivar(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131 + def on_ivasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_kwarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_kwargs(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_kwbegin(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_kwnilarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#132 + def on_kwoptarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#124 + def on_kwrestarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125 + def on_kwsplat(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_lambda(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_lvar(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131 + def on_lvasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_masgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_match_alt(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_match_as(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_match_current_line(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_match_nil_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_match_pattern(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_match_pattern_p(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125 + def on_match_rest(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_match_var(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_match_with_lvasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_match_with_trailing_comma(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_mlhs(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133 + def on_module(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_mrasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_next(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_nil(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_not(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_nth_ref(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#152 + def on_numblock(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#149 + def on_op_asgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#132 + def on_optarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_or(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_or_asgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_pair(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_pin(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129 + def on_postexe(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129 + def on_preexe(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_procarg0(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_rasgn(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_rational(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_redo(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_regexp(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#135 + def on_regopt(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_resbody(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_rescue(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#124 + def on_restarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_retry(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_return(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133 + def on_sclass(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_self(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#155 + def on_send(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_shadowarg(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125 + def on_splat(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_str(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_super(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127 + def on_sym(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_true(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_undef(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128 + def on_unless_guard(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133 + def on_until(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_until_post(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139 + def on_when(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133 + def on_while(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_while_post(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_xstr(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136 + def on_yield(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123 + def on_zsuper(node); end + + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#17 + def walk(node); end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#25 +module RuboCop::AST::Traversal::CallbackCompiler + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#61 + def arity_check(range); end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#52 + def body(signature, prelude); end + + # @api private + # + # source://rubocop-ast//lib/rubocop/ast/traversal.rb#35 + def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end +end + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#26 +RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#29 +RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash) + +# Only for debugging. +# +# @api private +# +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#12 +class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end + +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#100 +RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast//lib/rubocop/ast/traversal.rb#15 +RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash) + +# A node extension for `until` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `until` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#8 +class RuboCop::AST::UntilNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Checks whether the `until` node has a `do` keyword. + # + # @return [Boolean] whether the `until` node has a `do` keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#30 + def do?; end + + # Returns the inverse keyword of the `until` node as a string. + # Returns `while` for `until` nodes and vice versa. + # + # @return [String] the inverse keyword of the `until` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#23 + def inverse_keyword; end + + # Returns the keyword of the `until` statement as a string. + # + # @return [String] the keyword of the `until` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#15 + def keyword; end +end + +# source://rubocop-ast//lib/rubocop/ast/version.rb#5 +module RuboCop::AST::Version; end + +# source://rubocop-ast//lib/rubocop/ast/version.rb#6 +RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String) + +# A node extension for `when` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `when` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#11 +class RuboCop::AST::WhenNode < ::RuboCop::AST::Node + # Returns the body of the `when` node. + # + # @return [Node, nil] the body of the `when` node + # + # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#42 + def body; end + + # Returns the index of the `when` branch within the `case` statement. + # + # @return [Integer] the index of the `when` branch + # + # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#28 + def branch_index; end + + # Returns an array of all the conditions in the `when` branch. + # + # @return [Array] an array of condition nodes + # + # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#12 + def conditions; end + + # @deprecated Use `conditions.each` + # + # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#17 + def each_condition(&block); end + + # Checks whether the `when` node has a `then` keyword. + # + # @return [Boolean] whether the `when` node has a `then` keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#35 + def then?; end +end + +# A node extension for `while` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `while` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#8 +class RuboCop::AST::WhileNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Checks whether the `until` node has a `do` keyword. + # + # @return [Boolean] whether the `until` node has a `do` keyword + # + # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#30 + def do?; end + + # Returns the inverse keyword of the `while` node as a string. + # Returns `until` for `while` nodes and vice versa. + # + # @return [String] the inverse keyword of the `while` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#23 + def inverse_keyword; end + + # Returns the keyword of the `while` statement as a string. + # + # @return [String] the keyword of the `while` statement + # + # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#15 + def keyword; end +end + +# A node extension for `yield` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `yield` nodes within RuboCop. +# +# source://rubocop-ast//lib/rubocop/ast/node/yield_node.rb#8 +class RuboCop::AST::YieldNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast/2.4.2/lib/ast/node.rb#56 + def arguments; end + + # Custom destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # + # @return [Array] the different parts of the `send` node + # + # source://rubocop-ast//lib/rubocop/ast/node/yield_node.rb#16 + def node_parts; end +end diff --git a/sorbet/rbi/gems/rubocop-capybara@2.20.0.rbi b/sorbet/rbi/gems/rubocop-capybara@2.20.0.rbi new file mode 100644 index 00000000000..58bd00f91a7 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-capybara@2.20.0.rbi @@ -0,0 +1,1207 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-capybara` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-capybara`. + +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#3 +module RuboCop; end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#4 +module RuboCop::Cop; end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#5 +module RuboCop::Cop::Capybara; end + +# Help methods for capybara. +# +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#8 +module RuboCop::Cop::Capybara::CapybaraHelp + private + + # @api private + # @example + # common_attributes?('a[focused]') # => true + # common_attributes?('button[focused][visible]') # => true + # common_attributes?('table[id=some-id]') # => true + # common_attributes?('h1[invalid]') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#61 + def common_attributes?(selector); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param option [Symbol] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#125 + def include_option?(node, option); end + + # @api private + # @example + # replaceable_attributes?('table[id=some-id]') # => true + # replaceable_attributes?('a[focused]') # => false + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#70 + def replaceable_attributes?(attrs); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param element [String] + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#108 + def replaceable_element?(node, element, attrs); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param locator [String] + # @param element [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#45 + def replaceable_option?(node, locator, element); end + + # @api private + # @param pseudo_class [String] + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#85 + def replaceable_pseudo_class?(pseudo_class, locator); end + + # @api private + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#96 + def replaceable_pseudo_class_not?(locator); end + + # @api private + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#76 + def replaceable_pseudo_classes?(locator); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#118 + def replaceable_to_link?(node, attrs); end + + class << self + # @api private + # @example + # common_attributes?('a[focused]') # => true + # common_attributes?('button[focused][visible]') # => true + # common_attributes?('table[id=some-id]') # => true + # common_attributes?('h1[invalid]') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#61 + def common_attributes?(selector); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param option [Symbol] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#125 + def include_option?(node, option); end + + # @api private + # @example + # replaceable_attributes?('table[id=some-id]') # => true + # replaceable_attributes?('a[focused]') # => false + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#70 + def replaceable_attributes?(attrs); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param element [String] + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#108 + def replaceable_element?(node, element, attrs); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param locator [String] + # @param element [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#45 + def replaceable_option?(node, locator, element); end + + # @api private + # @param pseudo_class [String] + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#85 + def replaceable_pseudo_class?(pseudo_class, locator); end + + # @api private + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#96 + def replaceable_pseudo_class_not?(locator); end + + # @api private + # @param locator [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#76 + def replaceable_pseudo_classes?(locator); end + + # @api private + # @param node [RuboCop::AST::SendNode] + # @param attrs [Array] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#118 + def replaceable_to_link?(node, attrs); end + end +end + +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#9 +RuboCop::Cop::Capybara::CapybaraHelp::COMMON_OPTIONS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#12 +RuboCop::Cop::Capybara::CapybaraHelp::SPECIFIC_OPTIONS = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/capybara_help.rb#35 +RuboCop::Cop::Capybara::CapybaraHelp::SPECIFIC_PSEUDO_CLASSES = T.let(T.unsafe(nil), Array) + +# Checks for methods of button or link clicks. +# +# By default, prefer to use `click_link_or_button` or `click_on`. +# These methods offer a weaker coupling between the test and HTML, +# allowing for a more faithful reflection of how the user behaves. +# +# You can set `EnforcedStyle: strict` to prefer the use of +# `click_link` and `click_button`, but this is a deprecated setting. +# +# @example EnforcedStyle: link_or_button (default) +# # bad +# click_link('foo') +# click_button('foo') +# +# # good +# click_link_or_button('foo') +# click_on('foo') +# @example EnforcedStyle: strict +# # bad +# click_link_or_button('foo') +# click_on('foo') +# +# # good +# click_link('foo') +# click_button('foo') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#33 +class RuboCop::Cop::Capybara::ClickLinkOrButtonStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#44 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#69 + def link_or_button_method?(node); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#52 + def offense?(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#57 + def offense_message(node); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#65 + def strict_method?(node); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#41 +RuboCop::Cop::Capybara::ClickLinkOrButtonStyle::CLICK_LINK_OR_BUTTON = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#38 +RuboCop::Cop::Capybara::ClickLinkOrButtonStyle::MSG_CLICK_LINK_OR_BUTTON = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#36 +RuboCop::Cop::Capybara::ClickLinkOrButtonStyle::MSG_STRICT = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#42 +RuboCop::Cop::Capybara::ClickLinkOrButtonStyle::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/click_link_or_button_style.rb#40 +RuboCop::Cop::Capybara::ClickLinkOrButtonStyle::STRICT_METHODS = T.let(T.unsafe(nil), Array) + +# Css selector parser. +# +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#8 +class RuboCop::Cop::Capybara::CssAttributesParser + # @api private + # @return [CssAttributesParser] a new instance of CssAttributesParser + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#9 + def initialize(selector); end + + # @api private + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#18 + def parse; end + + private + + # @api private + # @example + # normalize_value('true') # => true + # normalize_value('false') # => false + # normalize_value(nil) # => nil + # normalize_value("foo") # => "'foo'" + # @param value [String] + # @return [Boolean, String] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#61 + def normalize_value(value); end + + # @api private + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#42 + def on_bracket_end; end + + # @api private + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb#33 + def on_bracket_start; end +end + +# Helps parsing css selector. +# +# @api private +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#8 +module RuboCop::Cop::Capybara::CssSelector + private + + # @api private + # @example + # attribute?('[attribute]') # => true + # attribute?('attribute') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#48 + def attribute?(selector); end + + # @api private + # @example + # attributes('a[foo-bar_baz]') # => {"foo-bar_baz=>nil} + # attributes('button[foo][bar=baz]') # => {"foo"=>nil, "bar"=>"'baz'"} + # attributes('table[foo=bar]') # => {"foo"=>"'bar'"} + # attributes('[foo="bar[baz][qux]"]') # => {"foo"=>"'bar[baz][qux]'"} + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#59 + def attributes(selector); end + + # @api private + # @example + # classes('#some-id') # => [] + # classes('.some-cls') # => ['some-cls'] + # classes('#some-id.some-cls') # => ['some-cls'] + # classes('#some-id.cls1.cls2') # => ['cls1', 'cls2'] + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#39 + def classes(selector); end + + # @api private + # @example + # id('#some-id') # => some-id + # id('.some-cls') # => nil + # id('#some-id.cls') # => some-id + # @param selector [String] + # @return [String] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#17 + def id(selector); end + + # @api private + # @example + # id?('#some-id') # => true + # id?('.some-cls') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#28 + def id?(selector); end + + # @api private + # @example + # multiple_selectors?('a.cls b#id') # => true + # multiple_selectors?('a.cls') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#82 + def multiple_selectors?(selector); end + + # @api private + # @example + # pseudo_classes('button:not([disabled])') # => ['not()'] + # pseudo_classes('a:enabled:not([valid])') # => ['enabled', 'not()'] + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#68 + def pseudo_classes(selector); end + + class << self + # @api private + # @example + # attribute?('[attribute]') # => true + # attribute?('attribute') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#48 + def attribute?(selector); end + + # @api private + # @example + # attributes('a[foo-bar_baz]') # => {"foo-bar_baz=>nil} + # attributes('button[foo][bar=baz]') # => {"foo"=>nil, "bar"=>"'baz'"} + # attributes('table[foo=bar]') # => {"foo"=>"'bar'"} + # attributes('[foo="bar[baz][qux]"]') # => {"foo"=>"'bar[baz][qux]'"} + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#59 + def attributes(selector); end + + # @api private + # @example + # classes('#some-id') # => [] + # classes('.some-cls') # => ['some-cls'] + # classes('#some-id.some-cls') # => ['some-cls'] + # classes('#some-id.cls1.cls2') # => ['cls1', 'cls2'] + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#39 + def classes(selector); end + + # @api private + # @example + # id('#some-id') # => some-id + # id('.some-cls') # => nil + # id('#some-id.cls') # => some-id + # @param selector [String] + # @return [String] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#17 + def id(selector); end + + # @api private + # @example + # id?('#some-id') # => true + # id?('.some-cls') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#28 + def id?(selector); end + + # @api private + # @example + # multiple_selectors?('a.cls b#id') # => true + # multiple_selectors?('a.cls') # => false + # @param selector [String] + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#82 + def multiple_selectors?(selector); end + + # @api private + # @example + # pseudo_classes('button:not([disabled])') # => ['not()'] + # pseudo_classes('a:enabled:not([valid])') # => ['enabled', 'not()'] + # @param selector [String] + # @return [Array] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/mixin/css_selector.rb#68 + def pseudo_classes(selector); end + end +end + +# Checks that no expectations are set on Capybara's `current_path`. +# +# The +# https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher] +# should be used on `page` to set expectations on Capybara's +# current path, since it uses +# https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality] +# which ensures that preceding actions (like `click_link`) have +# completed. +# +# This cop does not support autocorrection in some cases. +# +# @example +# # bad +# expect(current_path).to eq('/callback') +# expect(page.current_path).to eq('/callback') +# +# # good +# expect(page).to have_current_path('/callback', ignore_query: true) +# +# # bad (does not support autocorrection when `match` with a variable) +# expect(page).to match(variable) +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#29 +class RuboCop::Cop::Capybara::CurrentPathExpectation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Supported matchers: eq(...) / match(/regexp/) / match('regexp') + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#46 + def as_is_matcher(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#40 + def expectation_set_on_current_path(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#63 + def on_send(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#53 + def regexp_node_matcher(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#113 + def add_argument_parentheses(corrector, arg_node); end + + # `have_current_path` with no options will include the querystring + # while `page.current_path` does not. + # This ensures the option `ignore_query: true` is added + # except when `match` matcher. + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#131 + def add_ignore_query_options(corrector, node, matcher_node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#75 + def autocorrect(corrector, node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#99 + def convert_regexp_node_to_literal(corrector, matcher_node, regexp_node); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#123 + def method_call_with_no_parentheses?(arg_node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#105 + def regexp_node_to_regexp_expr(regexp_node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#86 + def rewrite_expectation(corrector, node, to_symbol, matcher_node); end + + class << self + # source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#59 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#33 +RuboCop::Cop::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/current_path_expectation.rb#37 +RuboCop::Cop::Capybara::CurrentPathExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for usage of deprecated style methods. +# +# @example when using `assert_style` +# # bad +# page.find(:css, '#first').assert_style(display: 'block') +# +# # good +# page.find(:css, '#first').assert_matches_style(display: 'block') +# @example when using `has_style?` +# # bad +# expect(page.find(:css, 'first') +# .has_style?(display: 'block')).to be true +# +# # good +# expect(page.find(:css, 'first') +# .matches_style?(display: 'block')).to be true +# @example when using `have_style` +# # bad +# expect(page).to have_style(display: 'block') +# +# # good +# expect(page).to match_style(display: 'block') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#31 +class RuboCop::Cop::Capybara::MatchStyle < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#42 + def on_send(node); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#52 + def message(node); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#34 +RuboCop::Cop::Capybara::MatchStyle::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#36 +RuboCop::Cop::Capybara::MatchStyle::PREFERRED_METHOD = T.let(T.unsafe(nil), Hash) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/match_style.rb#35 +RuboCop::Cop::Capybara::MatchStyle::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces use of `have_no_*` or `not_to` for negated expectations. +# +# @example EnforcedStyle: have_no (default) +# # bad +# expect(page).not_to have_selector +# expect(page).not_to have_css('a') +# +# # good +# expect(page).to have_no_selector +# expect(page).to have_no_css('a') +# @example EnforcedStyle: not_to +# # bad +# expect(page).to have_no_selector +# expect(page).to have_no_css('a') +# +# # good +# expect(page).not_to have_selector +# expect(page).not_to have_css('a') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#26 +class RuboCop::Cop::Capybara::NegationMatcher < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#50 + def have_no?(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#44 + def not_to?(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#55 + def on_send(node); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#78 + def message(matcher); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#69 + def offense?(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#74 + def offense_range(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#93 + def replaced_matcher(matcher); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#84 + def replaced_runner; end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#31 +RuboCop::Cop::Capybara::NegationMatcher::CAPYBARA_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#30 +RuboCop::Cop::Capybara::NegationMatcher::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#38 +RuboCop::Cop::Capybara::NegationMatcher::NEGATIVE_MATCHERS = T.let(T.unsafe(nil), Set) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#36 +RuboCop::Cop::Capybara::NegationMatcher::POSITIVE_MATCHERS = T.let(T.unsafe(nil), Set) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/negation_matcher.rb#41 +RuboCop::Cop::Capybara::NegationMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#6 +module RuboCop::Cop::Capybara::RSpec; end + +# A helper for `explicit` style +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#108 +module RuboCop::Cop::Capybara::RSpec::ExplicitHelper + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#138 + def predicate_matcher?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#124 + def allowed_explicit_matchers; end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#128 + def check_explicit(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#162 + def corrector_explicit(corrector, to_node, actual, matcher); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#156 + def message_explicit(matcher); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#169 + def move_predicate(corrector, actual, matcher); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#149 + def predicate_matcher_name?(name); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#180 + def replacement_matcher(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#176 + def to_predicate_method(matcher); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#113 +RuboCop::Cop::Capybara::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#118 +RuboCop::Cop::Capybara::RSpec::ExplicitHelper::INFLECTED_MATCHER = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#111 +RuboCop::Cop::Capybara::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +# Use `have_css` or `have_xpath` instead of `have_selector`. +# +# @example +# # bad +# expect(foo).to have_selector(:css, 'bar') +# +# # good +# expect(foo).to have_css('bar') +# +# # bad +# expect(foo).to have_selector(:xpath, 'bar') +# +# # good +# expect(foo).to have_xpath('bar') +# @example DefaultSelector: css (default) +# # bad +# expect(foo).to have_selector('bar') +# +# # good +# expect(foo).to have_css('bar') +# @example DefaultSelector: xpath +# # bad +# expect(foo).to have_selector('bar') +# +# # good +# expect(foo).to have_xpath('bar') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#36 +class RuboCop::Cop::Capybara::RSpec::HaveSelector < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#44 + def on_send(node); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#80 + def default_selector; end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#65 + def deletion_range(first_argument, second_argument); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#61 + def message_typed(type); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#76 + def message_untyped; end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#52 + def on_select_with_type(node, type); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#70 + def on_select_without_type(node); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#40 +RuboCop::Cop::Capybara::RSpec::HaveSelector::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#41 +RuboCop::Cop::Capybara::RSpec::HaveSelector::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/have_selector.rb#42 +RuboCop::Cop::Capybara::RSpec::HaveSelector::SELECTORS = T.let(T.unsafe(nil), Array) + +# A helper for `inflected` style +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#8 +module RuboCop::Cop::Capybara::RSpec::InflectedHelper + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#46 + def be_bool?(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#51 + def be_boolthy?(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#32 + def predicate_in_actual?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#55 + def boolean_matcher?(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#19 + def check_inflected(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#67 + def message_inflected(predicate); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#63 + def predicate?(sym); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#77 + def remove_predicate(corrector, predicate); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#85 + def rewrite_matcher(corrector, predicate, matcher); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#73 + def to_predicate_matcher(name); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#94 + def true?(to_symbol, matcher); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#11 +RuboCop::Cop::Capybara::RSpec::InflectedHelper::EXPLICIT_MATCHER = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#14 +RuboCop::Cop::Capybara::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String) + +# Prefer using predicate matcher over using predicate method directly. +# +# Capybara defines magic matchers for predicate methods. +# This cop recommends to use the predicate matcher instead of using +# predicate method directly. +# +# @example Strict: true, EnforcedStyle: inflected (default) +# # bad +# expect(foo.matches_css?(bar: 'baz')).to be_truthy +# expect(foo.matches_selector?(bar: 'baz')).to be_truthy +# expect(foo.matches_style?(bar: 'baz')).to be_truthy +# expect(foo.matches_xpath?(bar: 'baz')).to be_truthy +# +# # good +# expect(foo).to match_css(bar: 'baz') +# expect(foo).to match_selector(bar: 'baz') +# expect(foo).to match_style(bar: 'baz') +# expect(foo).to match_xpath(bar: 'baz') +# +# # also good - It checks "true" strictly. +# expect(foo.matches_style?(bar: 'baz')).to be(true) +# @example Strict: false, EnforcedStyle: inflected +# # bad +# expect(foo.matches_style?(bar: 'baz')).to be_truthy +# expect(foo.matches_style?(bar: 'baz')).to be(true) +# +# # good +# expect(foo).to match_style(bar: 'baz') +# @example Strict: true, EnforcedStyle: explicit +# # bad +# expect(foo).to match_style(bar: 'baz') +# +# # good - the above code is rewritten to it by this cop +# expect(foo.matches_style?(bar: 'baz')).to be(true) +# @example Strict: false, EnforcedStyle: explicit +# # bad +# expect(foo).to match_style(bar: 'baz') +# +# # good - the above code is rewritten to it by this cop +# expect(foo.matches_style?(bar: 'baz')).to be_truthy +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#238 +class RuboCop::Cop::Capybara::RSpec::PredicateMatcher < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Capybara::RSpec::InflectedHelper + include ::RuboCop::Cop::Capybara::RSpec::ExplicitHelper + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#246 + def on_send(node); end + + private + + # returns args location with whitespace + # + # @example + # foo 1, 2 + # ^^^^^ + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#260 + def args_loc(send_node); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/rspec/predicate_matcher.rb#244 +RuboCop::Cop::Capybara::RSpec::PredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant `within find(...)` calls. +# +# @example +# # bad +# within find('foo.bar') do +# # ... +# end +# +# # good +# within 'foo.bar' do +# # ... +# end +# +# # bad +# within find_by_id('foo') do +# # ... +# end +# +# # good +# within '#foo' do +# # ... +# end +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#29 +class RuboCop::Cop::Capybara::RedundantWithinFind < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#41 + def on_send(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#36 + def within_find(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#51 + def msg(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#55 + def replaced(node); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#33 +RuboCop::Cop::Capybara::RedundantWithinFind::FIND_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#31 +RuboCop::Cop::Capybara::RedundantWithinFind::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/redundant_within_find.rb#32 +RuboCop::Cop::Capybara::RedundantWithinFind::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for there is a more specific actions offered by Capybara. +# +# @example +# +# # bad +# find('a').click +# find('button.cls').click +# find('a', exact_text: 'foo').click +# find('div button').click +# +# # good +# click_link +# click_button(class: 'cls') +# click_link(exact_text: 'foo') +# find('div').click_button +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#22 +class RuboCop::Cop::Capybara::SpecificActions < ::RuboCop::Cop::Base + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#31 + def click_on_selector(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#35 + def on_send(node); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#87 + def good_action(action); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#73 + def last_selector(arg); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#81 + def message(action, selector); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#77 + def offense_range(node, receiver); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#57 + def replaceable?(node, arg, action); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#63 + def replaceable_attributes?(selector); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#53 + def specific_action(selector); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#69 + def supported_selector?(selector); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#23 +RuboCop::Cop::Capybara::SpecificActions::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#24 +RuboCop::Cop::Capybara::SpecificActions::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_actions.rb#25 +RuboCop::Cop::Capybara::SpecificActions::SPECIFIC_ACTION = T.let(T.unsafe(nil), Hash) + +# Checks if there is a more specific finder offered by Capybara. +# +# @example +# # bad +# find('#some-id') +# find('[id=some-id]') +# find(:css, '#some-id') +# +# # good +# find_by_id('some-id') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#17 +class RuboCop::Cop::Capybara::SpecificFinders < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#30 + def class_options(param0); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#25 + def find_argument(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#34 + def on_send(node); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#93 + def append_options(classes, options); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#62 + def attribute?(arg); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#83 + def autocorrect_classes(corrector, node, classes); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#78 + def deletion_range(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#120 + def end_pos(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#98 + def keyword_argument_class(classes); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#116 + def offense_range(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#46 + def on_attr(node, sym, arg); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#54 + def on_id(node, sym, arg); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#67 + def register_offense(node, sym, id, classes = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#103 + def replaced_arguments(arg, id); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#108 + def to_options(attrs); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#21 +RuboCop::Cop::Capybara::SpecificFinders::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_finders.rb#22 +RuboCop::Cop::Capybara::SpecificFinders::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for there is a more specific matcher offered by Capybara. +# +# @example +# +# # bad +# expect(page).to have_selector('button') +# expect(page).to have_no_selector('button.cls') +# expect(page).to have_css('button') +# expect(page).to have_no_css('a.cls', href: 'http://example.com') +# expect(page).to have_css('table.cls') +# expect(page).to have_css('select') +# expect(page).to have_css('input', exact_text: 'foo') +# +# # good +# expect(page).to have_button +# expect(page).to have_no_button(class: 'cls') +# expect(page).to have_button +# expect(page).to have_no_link('foo', class: 'cls', href: 'http://example.com') +# expect(page).to have_table(class: 'cls') +# expect(page).to have_select +# expect(page).to have_field('foo') +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#28 +class RuboCop::Cop::Capybara::SpecificMatcher < ::RuboCop::Cop::Base + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#41 + def first_argument(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#50 + def on_send(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#46 + def text_with_regexp?(param0); end + + private + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#86 + def good_matcher(node, matcher); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#80 + def message(node, matcher); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#67 + def replaceable?(node, arg, matcher); end + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#74 + def replaceable_attributes?(selector); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#62 + def specific_matcher(arg); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#29 +RuboCop::Cop::Capybara::SpecificMatcher::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#30 +RuboCop::Cop::Capybara::SpecificMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/specific_matcher.rb#32 +RuboCop::Cop::Capybara::SpecificMatcher::SPECIFIC_MATCHER = T.let(T.unsafe(nil), Hash) + +# Checks for boolean visibility in Capybara finders. +# +# Capybara lets you find elements that match a certain visibility using +# the `:visible` option. `:visible` accepts both boolean and symbols as +# values, however using booleans can have unwanted effects. `visible: +# false` does not find just invisible elements, but both visible and +# invisible elements. For expressiveness and clarity, use one of the +# symbol values, `:all`, `:hidden` or `:visible`. +# Read more in +# https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation]. +# +# @example +# # bad +# expect(page).to have_selector('.foo', visible: false) +# expect(page).to have_css('.foo', visible: true) +# expect(page).to have_link('my link', visible: false) +# +# # good +# expect(page).to have_selector('.foo', visible: :visible) +# expect(page).to have_css('.foo', visible: :all) +# expect(page).to have_link('my link', visible: :hidden) +# +# source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#28 +class RuboCop::Cop::Capybara::VisibilityMatcher < ::RuboCop::Cop::Base + # source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#58 + def on_send(node); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#54 + def visible_false?(param0 = T.unsafe(nil)); end + + # source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#49 + def visible_true?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#65 + def capybara_matcher?(method_name); end +end + +# source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#31 +RuboCop::Cop::Capybara::VisibilityMatcher::CAPYBARA_MATCHER_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#29 +RuboCop::Cop::Capybara::VisibilityMatcher::MSG_FALSE = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#30 +RuboCop::Cop::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil), String) + +# source://rubocop-capybara//lib/rubocop/cop/capybara/visibility_matcher.rb#46 +RuboCop::Cop::Capybara::VisibilityMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) diff --git a/sorbet/rbi/gems/rubocop-factory_bot@2.25.1.rbi b/sorbet/rbi/gems/rubocop-factory_bot@2.25.1.rbi new file mode 100644 index 00000000000..2f5d5df2172 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-factory_bot@2.25.1.rbi @@ -0,0 +1,927 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-factory_bot` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-factory_bot`. + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#3 +module RuboCop; end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb#4 +module RuboCop::Cop; end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb#5 +module RuboCop::Cop::FactoryBot; end + +# Use a consistent style to define associations. +# +# @example EnforcedStyle: implicit (default) +# # bad +# factory :post do +# association :user +# end +# +# # good +# factory :post do +# user +# end +# +# # bad +# factory :post do +# association :user, :author +# end +# +# # good +# factory :post do +# user factory: %i[user author] +# end +# @example EnforcedStyle: explicit +# # bad +# factory :post do +# user +# end +# +# # good +# factory :post do +# association :user +# end +# +# # bad +# factory :post do +# user factory: %i[user author] +# end +# +# # good +# factory :post do +# association :user, :author +# end +# +# # good (NonImplicitAssociationMethodNames: ['email']) +# sequence :email do |n| +# "person#{n}@example.com" +# end +# +# factory :user do +# email +# end +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#63 +class RuboCop::Cop::FactoryBot::AssociationStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#139 + def association_names(param0); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#96 + def explicit_association?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#113 + def factory_option_matcher(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#108 + def implicit_association?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#82 + def on_send(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#144 + def trait_name(param0); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#134 + def trait_names_from_explicit(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#101 + def with_strategy_build_option?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#148 + def autocorrect(corrector, node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#156 + def autocorrect_to_explicit_style(corrector, node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#164 + def autocorrect_to_implicit_style(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#174 + def bad?(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#195 + def bad_associations_in(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#201 + def children_of_factory_block(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#213 + def factory_names_from_explicit(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#185 + def keyword?(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#223 + def non_implicit_association_method_name?(method_name); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#227 + def non_implicit_association_method_names; end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#240 + def options_for_autocorrect_to_implicit_style(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#232 + def options_from_explicit(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#249 + def trait_within_trait?(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#68 +RuboCop::Cop::FactoryBot::AssociationStyle::DEFAULT_NON_IMPLICIT_ASSOCIATION_METHOD_NAMES = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#76 +RuboCop::Cop::FactoryBot::AssociationStyle::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/association_style.rb#75 +RuboCop::Cop::FactoryBot::AssociationStyle::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Always declare attribute values as blocks. +# +# @example +# # bad +# kind [:active, :rejected].sample +# +# # good +# kind { [:active, :rejected].sample } +# +# # bad +# closed_at 1.day.from_now +# +# # good +# closed_at { 1.day.from_now } +# +# # bad +# count 1 +# +# # good +# count { 1 } +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#27 +class RuboCop::Cop::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#85 + def association?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#38 + def factory_attributes(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#42 + def on_block(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#33 + def value_matcher(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#119 + def attribute_defining_method?(method_name); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#58 + def autocorrect(corrector, node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#87 + def autocorrect_replacing_parens(corrector, node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#94 + def autocorrect_without_parens(corrector, node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#103 + def braces(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#66 + def offensive_receiver?(receiver, node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#80 + def proc?(attribute); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#72 + def receiver_matches_first_block_argument?(receiver, node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#115 + def reserved_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#111 + def value_hash_without_braces?(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/attribute_defined_statically.rb#30 +RuboCop::Cop::FactoryBot::AttributeDefinedStatically::MSG = T.let(T.unsafe(nil), String) + +# Handles `ExplicitOnly` configuration parameters. +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb#7 +module RuboCop::Cop::FactoryBot::ConfigurableExplicitOnly + include ::RuboCop::FactoryBot::Language + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb#16 + def explicit_only?; end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/mixin/configurable_explicit_only.rb#10 + def factory_call?(node); end +end + +# Use a consistent style for parentheses in factory_bot calls. +# +# @example `EnforcedStyle: require_parentheses` (default) +# +# # bad +# create :user +# build :login +# +# # good +# create(:user) +# build(:login) +# @example `EnforcedStyle: omit_parentheses` +# +# # bad +# create(:user) +# build(:login) +# +# # good +# create :user +# build :login +# +# # also good +# # when method name and first argument are not on same line +# create( +# :user +# ) +# build( +# :user, +# name: 'foo' +# ) +# @example `ExplicitOnly: false` (default) +# +# # bad - with `EnforcedStyle: require_parentheses` +# FactoryBot.create :user +# build :user +# +# # good - with `EnforcedStyle: require_parentheses` +# FactoryBot.create(:user) +# build(:user) +# @example `ExplicitOnly: true` +# +# # bad - with `EnforcedStyle: require_parentheses` +# FactoryBot.create :user +# FactoryBot.build :user +# +# # good - with `EnforcedStyle: require_parentheses` +# FactoryBot.create(:user) +# FactoryBot.build(:user) +# create :user +# build :user +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#60 +class RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::FactoryBot::Language + include ::RuboCop::Cop::FactoryBot::ConfigurableExplicitOnly + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#71 + def factory_call(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#79 + def omit_hash_value?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#93 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#130 + def ambiguous_without_parentheses?(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#101 + def register_offense(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#108 + def register_offense_with_parentheses(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#119 + def register_offense_without_parentheses(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#134 + def remove_parentheses(corrector, node); end + + class << self + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#89 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#128 +RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle::AMBIGUOUS_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#67 +RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle::FACTORY_CALLS = T.let(T.unsafe(nil), Set) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#66 +RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle::MSG_OMIT_PARENS = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#65 +RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle::MSG_REQUIRE_PARENS = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb#68 +RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks for create_list usage. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: create_list` (default) +# # bad +# 3.times { create :user } +# 3.times.map { create :user } +# [create(:user), create(:user), create(:user)] +# Array.new(3) { create :user } +# +# # good +# create_list :user, 3 +# +# # bad +# 3.times { create :user, age: 18 } +# +# # good - index is used to alter the created models attributes +# 3.times { |n| create :user, age: n } +# +# # good - contains a method call, may return different values +# 3.times { create :user, age: rand } +# @example `EnforcedStyle: n_times` +# # bad +# create_list :user, 3 +# [create(:user), create(:user), create(:user)] +# +# # good +# 3.times.map { create :user } +# @example `ExplicitOnly: false` (default) +# +# # bad - with `EnforcedStyle: create_list` +# 3.times { FactoryBot.create :user } +# 3.times { create :user } +# +# # good - with `EnforcedStyle: create_list` +# FactoryBot.create_list :user, 3 +# create_list :user, 3 +# @example `ExplicitOnly: true` +# +# # bad - with `EnforcedStyle: create_list` +# 3.times { FactoryBot.create :user } +# +# # good - with `EnforcedStyle: create_list` +# FactoryBot.create_list :user, 3 +# create_list :user, 3 +# 3.times { create :user } +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#61 +class RuboCop::Cop::FactoryBot::CreateList < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::FactoryBot::Language + include ::RuboCop::Cop::FactoryBot::ConfigurableExplicitOnly + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#92 + def arguments_include_method_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#83 + def block_with_arg_and_used?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#97 + def factory_call(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#107 + def factory_calls_in_array?(param0); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#102 + def factory_list_call(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#111 + def on_array(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#123 + def on_block(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#136 + def on_send(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#72 + def repeat_count(param0 = T.unsafe(nil)); end + + private + + # For ease of modification, it is replaced with the `n_times` style, + # but if it is not appropriate for the configured style, + # it will be replaced in the subsequent autocorrection. + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#160 + def autocorrect_same_factory_calls_in_array(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#171 + def contains_only_factory?(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#179 + def preferred_message_for_array(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#151 + def repeat_multiple_time?(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#188 + def same_factory_calls_in_array?(node); end +end + +# :nodoc +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#194 +module RuboCop::Cop::FactoryBot::CreateList::Corrector + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#197 + def build_options_string(options); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#201 + def format_method_call(node, method, arguments); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#209 + def format_receiver(receiver); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#254 +class RuboCop::Cop::FactoryBot::CreateList::CreateListCorrector + include ::RuboCop::Cop::FactoryBot::CreateList::Corrector + + # @return [CreateListCorrector] a new instance of CreateListCorrector + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#257 + def initialize(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#261 + def call(corrector); end + + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#284 + def build_arguments(node, count); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#293 + def call_replacement(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#275 + def call_with_block_replacement(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#306 + def count_from(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#319 + def format_block(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#327 + def format_multiline_block(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#335 + def format_singleline_block(node); end + + # Returns the value of attribute node. + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#273 + def node; end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#67 +RuboCop::Cop::FactoryBot::CreateList::MSG_CREATE_LIST = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#68 +RuboCop::Cop::FactoryBot::CreateList::MSG_N_TIMES = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#69 +RuboCop::Cop::FactoryBot::CreateList::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# :nodoc +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#217 +class RuboCop::Cop::FactoryBot::CreateList::TimesCorrector + include ::RuboCop::Cop::FactoryBot::CreateList::Corrector + + # @return [TimesCorrector] a new instance of TimesCorrector + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#220 + def initialize(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#224 + def call(corrector); end + + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#246 + def factory_call_block_source; end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#233 + def generate_n_times_block(node); end + + # Returns the value of attribute node. + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/create_list.rb#231 + def node; end +end + +# Check for excessive model creation in a list. +# +# @example MaxAmount: 10 (default) +# # We do not allow more than 10 items to be created +# +# # bad +# create_list(:merge_request, 1000, state: :opened) +# +# # good +# create_list(:merge_request, 10, state: :opened) +# @example MaxAmount: 20 +# # We do not allow more than 20 items to be created +# +# # bad +# create_list(:merge_request, 1000, state: :opened) +# +# # good +# create_list(:merge_request, 15, state: :opened) +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/excessive_create_list.rb#26 +class RuboCop::Cop::FactoryBot::ExcessiveCreateList < ::RuboCop::Cop::Base + include ::RuboCop::FactoryBot::Language + include ::RuboCop::Cop::FactoryBot::ConfigurableExplicitOnly + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/excessive_create_list.rb#33 + def create_list?(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/excessive_create_list.rb#39 + def on_send(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/excessive_create_list.rb#29 +RuboCop::Cop::FactoryBot::ExcessiveCreateList::MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/excessive_create_list.rb#37 +RuboCop::Cop::FactoryBot::ExcessiveCreateList::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Use definition in factory association instead of hard coding a strategy. +# +# @example +# # bad - only works for one strategy +# factory :foo do +# profile { create(:profile) } +# end +# +# # good - implicit +# factory :foo do +# profile +# end +# +# # good - explicit +# factory :foo do +# association :profile +# end +# +# # good - inline +# factory :foo do +# profile { association :profile } +# end +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#29 +class RuboCop::Cop::FactoryBot::FactoryAssociationWithStrategy < ::RuboCop::Cop::Base + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#36 + def factory_declaration(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#43 + def factory_strategy_association(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#51 + def on_block(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#33 +RuboCop::Cop::FactoryBot::FactoryAssociationWithStrategy::HARDCODED = T.let(T.unsafe(nil), Set) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_association_with_strategy.rb#30 +RuboCop::Cop::FactoryBot::FactoryAssociationWithStrategy::MSG = T.let(T.unsafe(nil), String) + +# Use string value when setting the class attribute explicitly. +# +# This cop would promote faster tests by lazy-loading of +# application files. Also, this could help you suppress potential bugs +# in combination with external libraries by avoiding a preload of +# application files from the factory files. +# +# @example +# # bad +# factory :foo, class: Foo do +# end +# +# # good +# factory :foo, class: 'Foo' do +# end +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#22 +class RuboCop::Cop::FactoryBot::FactoryClassName < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#31 + def class_name(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#48 + def allowed?(const_name); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#27 +RuboCop::Cop::FactoryBot::FactoryClassName::ALLOWED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#25 +RuboCop::Cop::FactoryBot::FactoryClassName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_class_name.rb#28 +RuboCop::Cop::FactoryBot::FactoryClassName::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for name style for argument of FactoryBot::Syntax::Methods. +# +# @example EnforcedStyle: symbol (default) +# # bad +# create('user') +# build "user", username: "NAME" +# +# # good +# create(:user) +# build :user, username: "NAME" +# +# # good - namespaced models +# create('users/internal') +# @example EnforcedStyle: string +# # bad +# create(:user) +# build :user, username: "NAME" +# +# # good +# create('user') +# build "user", username: "NAME" +# @example `ExplicitOnly: false` (default) +# +# # bad - with `EnforcedStyle: symbol` +# FactoryBot.create('user') +# create('user') +# +# # good - with `EnforcedStyle: symbol` +# FactoryBot.create(:user) +# create(:user) +# @example `ExplicitOnly: true` +# +# # bad - with `EnforcedStyle: symbol` +# FactoryBot.create(:user) +# FactoryBot.build "user", username: "NAME" +# +# # good - with `EnforcedStyle: symbol` +# FactoryBot.create('user') +# FactoryBot.build "user", username: "NAME" +# FactoryBot.create(:user) +# create(:user) +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#51 +class RuboCop::Cop::FactoryBot::FactoryNameStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::FactoryBot::Language + include ::RuboCop::Cop::FactoryBot::ConfigurableExplicitOnly + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#62 + def factory_call(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#69 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#89 + def namespaced?(name); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#85 + def offense_for_string_style?(name); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#81 + def offense_for_symbol_style?(name); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#93 + def register_offense(name, prefer); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#58 +RuboCop::Cop::FactoryBot::FactoryNameStyle::FACTORY_CALLS = T.let(T.unsafe(nil), Set) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#57 +RuboCop::Cop::FactoryBot::FactoryNameStyle::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/factory_name_style.rb#59 +RuboCop::Cop::FactoryBot::FactoryNameStyle::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Do not create a FactoryBot sequence for an id column. +# +# @example +# # bad - can lead to conflicts between FactoryBot and DB sequences +# factory :foo do +# sequence :id +# end +# +# # good - a non-id column +# factory :foo do +# sequence :some_non_id_column +# end +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/id_sequence.rb#19 +class RuboCop::Cop::FactoryBot::IdSequence < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::FactoryBot::Language + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/id_sequence.rb#27 + def on_send(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/id_sequence.rb#24 +RuboCop::Cop::FactoryBot::IdSequence::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/id_sequence.rb#25 +RuboCop::Cop::FactoryBot::IdSequence::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant `factory` option. +# +# @example +# # bad +# association :user, factory: :user +# +# # good +# association :user +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#14 +class RuboCop::Cop::FactoryBot::RedundantFactoryOption < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#24 + def association_with_a_factory_option(param0 = T.unsafe(nil)); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#42 + def on_send(node); end + + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#55 + def autocorrect(corrector, node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#19 +RuboCop::Cop::FactoryBot::RedundantFactoryOption::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/redundant_factory_option.rb#21 +RuboCop::Cop::FactoryBot::RedundantFactoryOption::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Use shorthands from `FactoryBot::Syntax::Methods` in your specs. +# +# @example +# # bad +# FactoryBot.create(:bar) +# FactoryBot.build(:bar) +# FactoryBot.attributes_for(:bar) +# +# # good +# create(:bar) +# build(:bar) +# attributes_for(:bar) +# +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#48 +class RuboCop::Cop::FactoryBot::SyntaxMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::FactoryBot::Language + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#73 + def on_send(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#58 + def spec_group?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#87 + def crime_scene(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#109 + def example_group_root?(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#113 + def example_group_root_with_siblings?(node); end + + # @return [Boolean] + # + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#101 + def inside_example_group?(node); end + + # source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#94 + def offense(node); end +end + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#53 +RuboCop::Cop::FactoryBot::SyntaxMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-factory_bot//lib/rubocop/cop/factory_bot/syntax_methods.rb#55 +RuboCop::Cop::FactoryBot::SyntaxMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# RuboCop factory_bot project namespace +# +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#5 +module RuboCop::FactoryBot + class << self + # source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#54 + def attribute_defining_methods; end + + # source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#58 + def reserved_methods; end + end +end + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#6 +RuboCop::FactoryBot::ATTRIBUTE_DEFINING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#29 +RuboCop::FactoryBot::DEFINITION_PROXY_METHODS = T.let(T.unsafe(nil), Array) + +# Contains node matchers for common factory_bot DSL. +# +# source://rubocop-factory_bot//lib/rubocop/factory_bot/language.rb#6 +module RuboCop::FactoryBot::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-factory_bot//lib/rubocop/factory_bot/language.rb#30 + def factory_bot?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/language.rb#9 +RuboCop::FactoryBot::Language::METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#42 +RuboCop::FactoryBot::RESERVED_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-factory_bot//lib/rubocop/factory_bot/factory_bot.rb#14 +RuboCop::FactoryBot::UNPROXIED_METHODS = T.let(T.unsafe(nil), Array) diff --git a/sorbet/rbi/gems/rubocop-rspec@2.27.1.rbi b/sorbet/rbi/gems/rubocop-rspec@2.27.1.rbi new file mode 100644 index 00000000000..d85317d5f48 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-rspec@2.27.1.rbi @@ -0,0 +1,8537 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-rspec` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-rspec`. + +# source://rubocop-rspec//lib/rubocop/rspec.rb#3 +module RuboCop; end + +class RuboCop::AST::Node < ::Parser::AST::Node + include ::RuboCop::RSpec::Node +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#4 +module RuboCop::Cop; end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#5 +module RuboCop::Cop::RSpec; end + +# Checks that left braces for adjacent single line lets are aligned. +# +# @example +# # bad +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# # good +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#19 +class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#28 + def on_new_investigation; end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#43 + def token_aligner; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#24 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#22 +RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String) + +# Checks that right braces for adjacent single line lets are aligned. +# +# @example +# # bad +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# # good +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#19 +class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#28 + def on_new_investigation; end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#43 + def token_aligner; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#24 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#22 +RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String) + +# Check that instances are not being stubbed globally. +# +# Prefer instance doubles over stubbing any instance of a class +# +# @example +# # bad +# describe MyClass do +# before { allow_any_instance_of(MyClass).to receive(:foo) } +# end +# +# # good +# describe MyClass do +# let(:my_instance) { instance_double(MyClass) } +# +# before do +# allow(MyClass).to receive(:new).and_return(my_instance) +# allow(my_instance).to receive(:foo) +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#26 +class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#34 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#27 +RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#28 +RuboCop::Cop::RSpec::AnyInstance::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that around blocks actually run the test. +# +# @example +# # bad +# around do +# some_method +# end +# +# around do |test| +# some_method +# end +# +# # good +# around do |test| +# some_method +# test.call +# end +# +# around do |test| +# some_method +# test.run +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#29 +class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#45 + def find_arg_usage(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#35 + def hook_block(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#40 + def hook_numblock(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#49 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#59 + def on_numblock(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#67 + def add_no_arg_offense(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#84 + def check_for_numblock(block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#71 + def check_for_unused_proxy(block, proxy); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#30 +RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#31 +RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String) + +# @abstract parent class to RSpec cops +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#7 +class RuboCop::Cop::RSpec::Base < ::RuboCop::Cop::Base + include ::RuboCop::RSpec::Language + extend ::RuboCop::RSpec::Language::NodePattern + + # Set the config for dynamic DSL configuration-aware helpers + # that have no other means of accessing the configuration. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#20 + def on_new_investigation; end + + class << self + # Invoke the original inherited hook so our cops are recognized + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#14 + def inherited(subclass); end + end +end + +# Check for expectations where `be` is used without argument. +# +# The `be` matcher is too generic, as it pass on everything that is not +# nil or false. If that is the exact intend, use `be_truthy`. In all other +# cases it's better to specify what exactly is the expected value. +# +# @example +# # bad +# expect(foo).to be +# +# # good +# expect(foo).to be_truthy +# expect(foo).to be 1.0 +# expect(foo).to be(true) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#21 +class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#27 + def be_without_args(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#31 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#22 +RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#24 +RuboCop::Cop::RSpec::Be::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Prefer using `be_empty` when checking for an empty array. +# +# @example +# # bad +# expect(array).to contain_exactly +# expect(array).to match_array([]) +# +# # good +# expect(array).to be_empty +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#16 +class RuboCop::Cop::RSpec::BeEmpty < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#23 + def expect_array_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#35 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#19 +RuboCop::Cop::RSpec::BeEmpty::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#20 +RuboCop::Cop::RSpec::BeEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for expectations where `be(...)` can replace `eq(...)`. +# +# The `be` matcher compares by identity while the `eq` matcher compares +# using `==`. Booleans and nil can be compared by identity and therefore +# the `be` matcher is preferable as it is a more strict test. +# +# @example +# # bad +# expect(foo).to eq(true) +# expect(foo).to eq(false) +# expect(foo).to eq(nil) +# +# # good +# expect(foo).to be(true) +# expect(foo).to be(false) +# expect(foo).to be(nil) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#26 +class RuboCop::Cop::RSpec::BeEq < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#33 + def eq_type_with_identity?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#37 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#29 +RuboCop::Cop::RSpec::BeEq::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#30 +RuboCop::Cop::RSpec::BeEq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for expectations where `be(...)` can replace `eql(...)`. +# +# The `be` matcher compares by identity while the `eql` matcher +# compares using `eql?`. Integers, floats, booleans, symbols, and nil +# can be compared by identity and therefore the `be` matcher is +# preferable as it is a more strict test. +# +# This cop only looks for instances of `expect(...).to eql(...)`. We +# do not check `to_not` or `not_to` since `!eql?` is more strict +# than `!equal?`. We also do not try to flag `eq` because if +# `a == b`, and `b` is comparable by identity, `a` is still not +# necessarily the same type as `b` since the `#==` operator can +# coerce objects for comparison. +# +# @example +# # bad +# expect(foo).to eql(1) +# expect(foo).to eql(1.0) +# expect(foo).to eql(true) +# expect(foo).to eql(false) +# expect(foo).to eql(:bar) +# expect(foo).to eql(nil) +# +# # good +# expect(foo).to be(1) +# expect(foo).to be(1.0) +# expect(foo).to be(true) +# expect(foo).to be(false) +# expect(foo).to be(:bar) +# expect(foo).to be(nil) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#40 +class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#47 + def eql_type_with_identity(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#51 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#43 +RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#44 +RuboCop::Cop::RSpec::BeEql::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Ensures a consistent style is used when matching `nil`. +# +# You can either use the more specific `be_nil` matcher, or the more +# generic `be` matcher with a `nil` argument. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: be_nil` (default) +# # bad +# expect(foo).to be(nil) +# +# # good +# expect(foo).to be_nil +# @example `EnforcedStyle: be` +# # bad +# expect(foo).to be_nil +# +# # good +# expect(foo).to be(nil) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#27 +class RuboCop::Cop::RSpec::BeNil < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#36 + def be_nil_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#41 + def nil_value_expectation?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#45 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#64 + def check_be_nil_style(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#56 + def check_be_style(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#31 +RuboCop::Cop::RSpec::BeNil::BE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#32 +RuboCop::Cop::RSpec::BeNil::BE_NIL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#33 +RuboCop::Cop::RSpec::BeNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that before/after(:all/:context) isn't being used. +# +# @example +# # bad - Faster but risk of state leaking between examples +# describe MyClass do +# before(:all) { Widget.create } +# after(:context) { Widget.delete_all } +# end +# +# # good - Slower but examples are properly isolated +# describe MyClass do +# before(:each) { Widget.create } +# after(:each) { Widget.delete_all } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#21 +class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#30 + def before_or_after_all(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#34 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#22 +RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#27 +RuboCop::Cop::RSpec::BeforeAfterAll::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/current_path_expectation.rb#6 +module RuboCop::Cop::RSpec::Capybara; end + +# Checks that no expectations are set on Capybara's `current_path`. +# +# The +# https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher] +# should be used on `page` to set expectations on Capybara's +# current path, since it uses +# https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality] +# which ensures that preceding actions (like `click_link`) have +# completed. +# +# This cop does not support autocorrection in some cases. +# +# @example +# # bad +# expect(current_path).to eq('/callback') +# +# # good +# expect(page).to have_current_path('/callback') +# +# # bad (does not support autocorrection) +# expect(page.current_path).to match(variable) +# +# # good +# expect(page).to have_current_path('/callback') +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/current_path_expectation.rb#34 +RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation = RuboCop::Cop::Capybara::CurrentPathExpectation + +# Checks for consistent method usage in feature specs. +# +# By default, the cop disables all Capybara-specific methods that have +# the same native RSpec method (e.g. are just aliases). Some teams +# however may prefer using some of the Capybara methods (like `feature`) +# to make it obvious that the test uses Capybara, while still disable +# the rest of the methods, like `given` (alias for `let`), `background` +# (alias for `before`), etc. You can configure which of the methods to +# be enabled by using the EnabledMethods configuration option. +# +# @example +# # bad +# feature 'User logs in' do +# given(:user) { User.new } +# +# background do +# visit new_session_path +# end +# +# scenario 'with OAuth' do +# # ... +# end +# end +# +# # good +# describe 'User logs in' do +# let(:user) { User.new } +# +# before do +# visit new_session_path +# end +# +# it 'with OAuth' do +# # ... +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#44 +class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#61 + def capybara_speak(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#66 + def feature_method(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#84 + def message(range); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#72 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#91 + def enabled?(method_name); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#95 + def enabled_methods; end +end + +# https://github.com/teamcapybara/capybara/blob/e283c1aeaa72441f5403963577e16333bf111a81/lib/capybara/rspec/features.rb#L31-L36 +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#51 +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MAP = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/feature_methods.rb#48 +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of deprecated style methods. +# +# @example when using `assert_style` +# # bad +# page.find(:css, '#first').assert_style(display: 'block') +# +# # good +# page.find(:css, '#first').assert_matches_style(display: 'block') +# @example when using `has_style?` +# # bad +# expect(page.find(:css, 'first') +# .has_style?(display: 'block')).to be true +# +# # good +# expect(page.find(:css, 'first') +# .matches_style?(display: 'block')).to be true +# @example when using `have_style` +# # bad +# expect(page).to have_style(display: 'block') +# +# # good +# expect(page).to match_style(display: 'block') +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/match_style.rb#34 +RuboCop::Cop::RSpec::Capybara::MatchStyle = RuboCop::Cop::Capybara::MatchStyle + +# Enforces use of `have_no_*` or `not_to` for negated expectations. +# +# @example EnforcedStyle: not_to (default) +# # bad +# expect(page).to have_no_selector +# expect(page).to have_no_css('a') +# +# # good +# expect(page).not_to have_selector +# expect(page).not_to have_css('a') +# @example EnforcedStyle: have_no +# # bad +# expect(page).not_to have_selector +# expect(page).not_to have_css('a') +# +# # good +# expect(page).to have_no_selector +# expect(page).to have_no_css('a') +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/negation_matcher.rb#29 +RuboCop::Cop::RSpec::Capybara::NegationMatcher = RuboCop::Cop::Capybara::NegationMatcher + +# Checks for there is a more specific actions offered by Capybara. +# +# @example +# +# # bad +# find('a').click +# find('button.cls').click +# find('a', exact_text: 'foo').click +# find('div button').click +# +# # good +# click_link +# click_button(class: 'cls') +# click_link(exact_text: 'foo') +# find('div').click_button +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/specific_actions.rb#25 +RuboCop::Cop::RSpec::Capybara::SpecificActions = RuboCop::Cop::Capybara::SpecificActions + +# Checks if there is a more specific finder offered by Capybara. +# +# @example +# # bad +# find('#some-id') +# find('[visible][id=some-id]') +# +# # good +# find_by_id('some-id') +# find_by_id('some-id', visible: true) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/specific_finders.rb#20 +RuboCop::Cop::RSpec::Capybara::SpecificFinders = RuboCop::Cop::Capybara::SpecificFinders + +# Checks for there is a more specific matcher offered by Capybara. +# +# @example +# +# # bad +# expect(page).to have_selector('button') +# expect(page).to have_no_selector('button.cls') +# expect(page).to have_css('button') +# expect(page).to have_no_css('a.cls', href: 'http://example.com') +# expect(page).to have_css('table.cls') +# expect(page).to have_css('select') +# expect(page).to have_css('input', exact_text: 'foo') +# +# # good +# expect(page).to have_button +# expect(page).to have_no_button(class: 'cls') +# expect(page).to have_button +# expect(page).to have_no_link('foo', class: 'cls', href: 'http://example.com') +# expect(page).to have_table(class: 'cls') +# expect(page).to have_select +# expect(page).to have_field('foo') +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/specific_matcher.rb#31 +RuboCop::Cop::RSpec::Capybara::SpecificMatcher = RuboCop::Cop::Capybara::SpecificMatcher + +# Checks for boolean visibility in Capybara finders. +# +# Capybara lets you find elements that match a certain visibility +# using the `:visible` option. `:visible` accepts both boolean and +# symbols as values, however using booleans can have unwanted +# effects. `visible: false` does not find just invisible elements, +# but both visible and invisible elements. For expressiveness and +# clarity, use one of the # symbol values, `:all`, `:hidden` or +# `:visible`. +# Read more in +# https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation]. +# +# @example +# # bad +# expect(page).to have_selector('.foo', visible: false) +# expect(page).to have_css('.foo', visible: true) +# expect(page).to have_link('my link', visible: false) +# +# # good +# expect(page).to have_selector('.foo', visible: :visible) +# expect(page).to have_css('.foo', visible: :all) +# expect(page).to have_link('my link', visible: :hidden) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/capybara/visibility_matcher.rb#32 +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher = RuboCop::Cop::Capybara::VisibilityMatcher + +# Prefer negated matchers over `to change.by(0)`. +# +# In the case of composite expectations, cop suggest using the +# negation matchers of `RSpec::Matchers#change`. +# +# By default the cop does not support autocorrect of +# compound expectations, but if you set the +# negated matcher for `change`, e.g. `not_change` with +# the `NegatedMatcher` option, the cop will perform the autocorrection. +# +# @example NegatedMatcher: ~ (default) +# # bad +# expect { run }.to change(Foo, :bar).by(0) +# expect { run }.to change { Foo.bar }.by(0) +# +# # bad - compound expectations (does not support autocorrection) +# expect { run } +# .to change(Foo, :bar).by(0) +# .and change(Foo, :baz).by(0) +# expect { run } +# .to change { Foo.bar }.by(0) +# .and change { Foo.baz }.by(0) +# +# # good +# expect { run }.not_to change(Foo, :bar) +# expect { run }.not_to change { Foo.bar } +# +# # good - compound expectations +# define_negated_matcher :not_change, :change +# expect { run } +# .to not_change(Foo, :bar) +# .and not_change(Foo, :baz) +# expect { run } +# .to not_change { Foo.bar } +# .and not_change { Foo.baz } +# @example NegatedMatcher: not_change +# # bad (support autocorrection to good case) +# expect { run } +# .to change(Foo, :bar).by(0) +# .and change(Foo, :baz).by(0) +# expect { run } +# .to change { Foo.bar }.by(0) +# .and change { Foo.baz }.by(0) +# +# # good +# define_negated_matcher :not_change, :change +# expect { run } +# .to not_change(Foo, :bar) +# .and not_change(Foo, :baz) +# expect { run } +# .to not_change { Foo.bar } +# .and not_change { Foo.baz } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#60 +class RuboCop::Cop::RSpec::ChangeByZero < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#88 + def change_nodes(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#71 + def expect_change_with_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#78 + def expect_change_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#92 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#133 + def autocorrect(corrector, node, change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#140 + def autocorrect_compound(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#120 + def compound_expectations?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#150 + def insert_operator(corrector, node, change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#124 + def message(change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#128 + def message_compound(change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#174 + def negated_matcher; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#178 + def preferred_method; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#105 + def register_offense(node, change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#163 + def remove_by_zero(corrector, node, change_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#159 + def replace_node(node, change_node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#67 +RuboCop::Cop::RSpec::ChangeByZero::CHANGE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#64 +RuboCop::Cop::RSpec::ChangeByZero::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#65 +RuboCop::Cop::RSpec::ChangeByZero::MSG_COMPOUND = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#68 +RuboCop::Cop::RSpec::ChangeByZero::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Enforces consistent use of `be_a` or `be_kind_of`. +# +# @example EnforcedStyle: be_a (default) +# # bad +# expect(object).to be_kind_of(String) +# expect(object).to be_a_kind_of(String) +# +# # good +# expect(object).to be_a(String) +# expect(object).to be_an(String) +# @example EnforcedStyle: be_kind_of +# # bad +# expect(object).to be_a(String) +# expect(object).to be_an(String) +# +# # good +# expect(object).to be_kind_of(String) +# expect(object).to be_a_kind_of(String) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#26 +class RuboCop::Cop::RSpec::ClassCheck < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#54 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#67 + def autocorrect(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#71 + def format_message(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#79 + def offending?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#87 + def preferred_method_name; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#83 + def preferred_method_name?(method_name); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#91 + def preferred_method_names; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#32 +RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_BE_A = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#37 +RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_KIND_OF = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#30 +RuboCop::Cop::RSpec::ClassCheck::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#42 +RuboCop::Cop::RSpec::ClassCheck::PREFERRED_METHOD_NAME_BY_STYLE = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#47 +RuboCop::Cop::RSpec::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Help methods for working with nodes containing comments. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#7 +module RuboCop::Cop::RSpec::CommentsHelp + include ::RuboCop::Cop::RSpec::FinalEndLocation + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#17 + def begin_pos_with_comment(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#32 + def buffer; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#27 + def end_line_position(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#10 + def source_range_with_comment(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#23 + def start_line_position(node); end +end + +# Checks where `contain_exactly` is used. +# +# This cop checks for the following: +# - Prefer `match_array` when matching array values. +# - Prefer `be_empty` when using `contain_exactly` with no arguments. +# +# @example +# # bad +# it { is_expected.to contain_exactly(*array1, *array2) } +# +# # good +# it { is_expected.to match_array(array1 + array2) } +# +# # good +# it { is_expected.to contain_exactly(content, *array) } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#22 +class RuboCop::Cop::RSpec::ContainExactly < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#28 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#44 + def autocorrect_for_populated_array(node, corrector); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#36 + def check_populated_collection(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#25 +RuboCop::Cop::RSpec::ContainExactly::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#26 +RuboCop::Cop::RSpec::ContainExactly::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# `context` should not be used for specifying methods. +# +# @example +# # bad +# context '#foo_bar' do +# # ... +# end +# +# context '.foo_bar' do +# # ... +# end +# +# # good +# describe '#foo_bar' do +# # ... +# end +# +# describe '.foo_bar' do +# # ... +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#27 +class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#33 + def context_method(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#41 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#51 + def method_name?(description); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#30 +RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String) + +# Checks that `context` docstring starts with an allowed prefix. +# +# The default list of prefixes is minimal. Users are encouraged to tailor +# the configuration to meet project needs. Other acceptable prefixes may +# include `if`, `unless`, `for`, `before`, `after`, or `during`. +# They may consist of multiple words if desired. +# +# This cop can be customized allowed context description pattern +# with `AllowedPatterns`. By default, there are no checking by pattern. +# +# @example `Prefixes` configuration +# # .rubocop.yml +# # RSpec/ContextWording: +# # Prefixes: +# # - when +# # - with +# # - without +# # - if +# # - unless +# # - for +# @example +# # bad +# context 'the display name not present' do +# # ... +# end +# +# # good +# context 'when the display name is not present' do +# # ... +# end +# @example `AllowedPatterns` configuration +# +# # .rubocop.yml +# # RSpec/ContextWording: +# # AllowedPatterns: +# # - とき$ +# @example +# # bad +# context '条件を満たす' do +# # ... +# end +# +# # good +# context '条件を満たすとき' do +# # ... +# end +# @see http://www.betterspecs.org/#contexts +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#58 +class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#64 + def context_wording(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#68 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#79 + def allowed_patterns; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#87 + def bad_pattern?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#93 + def description(context); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#101 + def expect_patterns; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#83 + def prefix_regexes; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#111 + def prefixes; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#61 +RuboCop::Cop::RSpec::ContextWording::MSG = T.let(T.unsafe(nil), String) + +# Check that the first argument to the top-level describe is a constant. +# +# It can be configured to ignore strings when certain metadata is passed. +# +# Ignores Rails and Aruba `type` metadata by default. +# +# @example `IgnoredMetadata` configuration +# # .rubocop.yml +# # RSpec/DescribeClass: +# # IgnoredMetadata: +# # type: +# # - request +# # - controller +# @example +# # bad +# describe 'Do something' do +# end +# +# # good +# describe TestedClass do +# subject { described_class } +# end +# +# describe 'TestedClass::VERSION' do +# subject { Object.const_get(self.class.description) } +# end +# +# describe "A feature example", type: :feature do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#37 +class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#44 + def example_group_with_ignored_metadata?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#49 + def not_a_const_described(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#58 + def on_top_level_group(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#54 + def sym_pair(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#79 + def ignored_metadata; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#68 + def ignored_metadata?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#74 + def string_constant?(described); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#40 +RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String) + +# Checks that the second argument to `describe` specifies a method. +# +# @example +# # bad +# describe MyClass, 'do something' do +# end +# +# # good +# describe MyClass, '#my_instance_method' do +# end +# +# describe MyClass, '.my_class_method' do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#20 +class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#34 + def method_name?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#38 + def on_top_level_group(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#27 + def second_string_literal_argument(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#46 + def method_name_prefix?(description); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#23 +RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String) + +# Avoid describing symbols. +# +# @example +# # bad +# describe :my_method do +# # ... +# end +# +# # good +# describe '#my_method' do +# # ... +# end +# @see https://github.com/rspec/rspec-core/issues/1610 +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#20 +class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#25 + def describe_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#29 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#21 +RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#22 +RuboCop::Cop::RSpec::DescribeSymbol::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that tests use `described_class`. +# +# If the first argument of describe is a class, the class is exposed to +# each example via described_class. +# +# This cop can be configured using the `EnforcedStyle`, `SkipBlocks` +# and `OnlyStaticConstants` options. +# `OnlyStaticConstants` is only relevant when `EnforcedStyle` is +# `described_class`. +# +# There's a known caveat with rspec-rails's `controller` helper that +# runs its block in a different context, and `described_class` is not +# available to it. `SkipBlocks` option excludes detection in all +# non-RSpec related blocks. +# +# To narrow down this setting to only a specific directory, it is +# possible to use an overriding configuration file local to that +# directory. +# +# @example `EnforcedStyle: described_class` (default) +# # bad +# describe MyClass do +# subject { MyClass.do_something } +# end +# +# # good +# describe MyClass do +# subject { described_class.do_something } +# end +# @example `OnlyStaticConstants: true` (default) +# # good +# describe MyClass do +# subject { MyClass::CONSTANT } +# end +# @example `OnlyStaticConstants: false` +# # bad +# describe MyClass do +# subject { MyClass::CONSTANT } +# end +# @example `EnforcedStyle: explicit` +# # bad +# describe MyClass do +# subject { described_class.do_something } +# end +# +# # good +# describe MyClass do +# subject { MyClass.do_something } +# end +# @example `SkipBlocks: true` +# # spec/controllers/.rubocop.yml +# # RSpec/DescribedClass: +# # SkipBlocks: true +# +# # acceptable +# describe MyConcern do +# controller(ApplicationController) do +# include MyConcern +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#71 +class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::Namespace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#80 + def common_instance_exec_closure?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#97 + def contains_described_class?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#92 + def described_constant(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#100 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#85 + def rspec_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#89 + def scope_changing_syntax?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#136 + def allowed?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#117 + def autocorrect(corrector, match); end + + # @example + # # nil represents base constant + # collapse_namespace([], [:C]) # => [:C] + # collapse_namespace([:A, :B], [:C]) # => [:A, :B, :C] + # collapse_namespace([:A, :B], [:B, :C]) # => [:A, :B, :C] + # collapse_namespace([:A, :B], [nil, :C]) # => [nil, :C] + # collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C] + # @param namespace [Array] + # @param const [Array] + # @return [Array] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#200 + def collapse_namespace(namespace, const); end + + # @example + # const_name(s(:const, nil, :C)) # => [:C] + # const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C] + # const_name(s(:const, s(:cbase), :C)) # => [nil, :C] + # @param node [RuboCop::AST::Node] + # @return [Array] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#217 + def const_name(node); end + + # @yield [node] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#127 + def find_usage(node, &block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#185 + def full_const_name(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#140 + def message(offense); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#163 + def offensive?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#171 + def offensive_described_class?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#159 + def only_static_constants?; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#149 + def scope_change?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#155 + def skippable_block?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#76 +RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#77 +RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String) + +# Avoid opening modules and defining specs within them. +# +# @example +# # bad +# module MyModule +# RSpec.describe MyClass do +# # ... +# end +# end +# +# # good +# RSpec.describe MyModule::MyClass do +# # ... +# end +# @see https://github.com/rubocop/rubocop-rspec/issues/735 +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#22 +class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#26 + def include_rspec_blocks?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#30 + def on_module(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#23 +RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String) + +# Enforces custom RSpec dialects. +# +# A dialect can be based on the following RSpec methods: +# +# - describe, context, feature, example_group +# - xdescribe, xcontext, xfeature +# - fdescribe, fcontext, ffeature +# - shared_examples, shared_examples_for, shared_context +# - it, specify, example, scenario, its +# - fit, fspecify, fexample, fscenario, focus +# - xit, xspecify, xexample, xscenario, skip +# - pending +# - prepend_before, before, append_before, +# - around +# - prepend_after, after, append_after +# - let, let! +# - subject, subject! +# - expect, is_expected, expect_any_instance_of +# +# By default all of the RSpec methods and aliases are allowed. By setting +# a config like: +# +# RSpec/Dialect: +# PreferredMethods: +# context: describe +# +# You can expect the following behavior: +# +# @example +# # bad +# context 'display name presence' do +# # ... +# end +# +# # good +# describe 'display name presence' do +# # ... +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#45 +class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#54 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#52 + def rspec_method?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#49 +RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String) + +# Avoid duplicated metadata. +# +# @example +# # bad +# describe 'Something', :a, :a +# +# # good +# describe 'Something', :a +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#14 +class RuboCop::Cop::RSpec::DuplicatedMetadata < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::Metadata + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#22 + def on_metadata(symbols, _hash); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#38 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#50 + def duplicated?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#30 + def on_metadata_symbol(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#20 +RuboCop::Cop::RSpec::DuplicatedMetadata::MSG = T.let(T.unsafe(nil), String) + +# Checks if an example group does not include any tests. +# +# @example usage +# # bad +# describe Bacon do +# let(:bacon) { Bacon.new(chunkiness) } +# let(:chunkiness) { false } +# +# context 'extra chunky' do # flagged by rubocop +# let(:chunkiness) { true } +# end +# +# it 'is chunky' do +# expect(bacon.chunky?).to be_truthy +# end +# end +# +# # good +# describe Bacon do +# let(:bacon) { Bacon.new(chunkiness) } +# let(:chunkiness) { false } +# +# it 'is chunky' do +# expect(bacon.chunky?).to be_truthy +# end +# end +# +# # good +# describe Bacon do +# pending 'will add tests later' +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#38 +class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Match example group blocks and yield their body + # + # @example source that matches + # describe 'example group' do + # it { is_expected.to be } + # end + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] example group body + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#55 + def example_group_body(param0 = T.unsafe(nil)); end + + # Match examples, example groups and includes + # + # @example source that matches + # it { is_expected.to fly } + # describe('non-empty example groups too') { } + # it_behaves_like 'an animal' + # it_behaves_like('a cat') { let(:food) { 'milk' } } + # it_has_root_access + # skip + # it 'will be implemented later' + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#73 + def example_or_group_or_include?(param0 = T.unsafe(nil)); end + + # Matches examples defined in scopes where they could run + # + # @example source that matches + # it { expect(myself).to be_run } + # describe { it { i_run_as_well } } + # @example source that does not match + # before { it { whatever here won't run anyway } } + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#130 + def examples?(param0 = T.unsafe(nil)); end + + # Match examples or examples inside blocks + # + # @example source that matches + # it { expect(drink).to be_cold } + # context('when winter') { it { expect(drink).to be_hot } } + # (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } } + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#111 + def examples_directly_or_in_block?(param0 = T.unsafe(nil)); end + + # Match examples defined inside a block which is not a hook + # + # @example source that matches + # %w(r g b).each do |color| + # it { is_expected.to have_color(color) } + # end + # @example source that does not match + # before do + # it { is_expected.to fall_into_oblivion } + # end + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#97 + def examples_inside_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#138 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#164 + def conditionals_with_examples?(body); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#172 + def examples_in_branches?(condition_node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#153 + def offensive?(body); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#178 + def removed_range(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#43 +RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty before and after hooks. +# +# @example +# # bad +# before {} +# after do; end +# before(:all) do +# end +# after(:all) { } +# +# # good +# before { create_users } +# after do +# cleanup_users +# end +# before(:all) do +# create_feed +# end +# after(:all) { cleanup_feed } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#26 +class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#33 + def empty_hook?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#37 + def on_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#30 +RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after example blocks. +# +# @example +# # bad +# RSpec.describe Foo do +# it 'does this' do +# end +# it 'does that' do +# end +# end +# +# # good +# RSpec.describe Foo do +# it 'does this' do +# end +# +# it 'does that' do +# end +# end +# +# # fair - it's ok to have non-separated one-liners +# RSpec.describe Foo do +# it { one } +# it { two } +# end +# @example with AllowConsecutiveOneLiners configuration +# # rubocop.yml +# # RSpec/EmptyLineAfterExample: +# # AllowConsecutiveOneLiners: false +# +# # bad +# RSpec.describe Foo do +# it { one } +# it { two } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#43 +class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#49 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#64 + def allow_consecutive_one_liners?; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#60 + def allowed_one_liner?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#68 + def consecutive_one_liner?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#72 + def next_one_line_example?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#47 +RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after example group blocks. +# +# @example +# # bad +# RSpec.describe Foo do +# describe '#bar' do +# end +# describe '#baz' do +# end +# end +# +# # good +# RSpec.describe Foo do +# describe '#bar' do +# end +# +# describe '#baz' do +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#26 +class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#32 + def on_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#30 +RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after the last let block. +# +# @example +# # bad +# let(:foo) { bar } +# let(:something) { other } +# it { does_something } +# +# # good +# let(:foo) { bar } +# let(:something) { other } +# +# it { does_something } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#20 +class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#26 + def on_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#24 +RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after hook blocks. +# +# `AllowConsecutiveOneLiners` configures whether adjacent +# one-line definitions are considered an offense. +# +# @example +# # bad +# before { do_something } +# it { does_something } +# +# # bad +# after { do_something } +# it { does_something } +# +# # bad +# around { |test| test.run } +# it { does_something } +# +# # good +# after { do_something } +# +# it { does_something } +# +# # fair - it's ok to have non-separated one-liners hooks +# around { |test| test.run } +# after { do_something } +# +# it { does_something } +# @example with AllowConsecutiveOneLiners configuration +# # rubocop.yml +# # RSpec/EmptyLineAfterHook: +# # AllowConsecutiveOneLiners: false +# +# # bad +# around { |test| test.run } +# after { do_something } +# +# it { does_something } +# +# # good +# around { |test| test.run } +# +# after { do_something } +# +# it { does_something } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#53 +class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#60 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#60 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#74 + def chained_single_line_hooks?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#58 +RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after subject block. +# +# @example +# # bad +# subject(:obj) { described_class } +# let(:foo) { bar } +# +# # good +# subject(:obj) { described_class } +# +# let(:foo) { bar } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#18 +class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#25 + def on_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#23 +RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String) + +# Helps determine the offending location if there is not an empty line +# following the node. Allows comments to follow directly after +# in the following cases. +# - followed by empty line(s) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#11 +module RuboCop::Cop::RSpec::EmptyLineSeparation + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#51 + def last_child?(node); end + + # @yield [offending_loc(enable_directive_line || final_end_line)] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#26 + def missing_separating_line(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#15 + def missing_separating_line_offense(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#41 + def offending_loc(last_line); end +end + +# Avoid empty metadata hash. +# +# @example EnforcedStyle: symbol (default) +# # bad +# describe 'Something', {} +# +# # good +# describe 'Something' +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#14 +class RuboCop::Cop::RSpec::EmptyMetadata < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::Metadata + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#22 + def on_metadata(_symbols, hash); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#32 + def remove_empty_metadata(corrector, node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#20 +RuboCop::Cop::RSpec::EmptyMetadata::MSG = T.let(T.unsafe(nil), String) + +# Use `eq` instead of `be ==` to compare objects. +# +# @example +# # bad +# expect(foo).to be == 42 +# +# # good +# expect(foo).to eq 42 +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#15 +class RuboCop::Cop::RSpec::Eq < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#23 + def be_equals(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#27 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#38 + def offense_range(matcher); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#19 +RuboCop::Cop::RSpec::Eq::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#20 +RuboCop::Cop::RSpec::Eq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for long examples. +# +# A long example is usually more difficult to understand. Consider +# extracting out some behavior, e.g. with a `let` block, or a helper +# method. +# +# You can set constructs you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', 'heredoc', and 'method_call'. +# Each construct will be counted as one line regardless of +# its actual size. +# +# @example +# # bad +# it do +# service = described_class.new +# more_setup +# more_setup +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it do +# service = described_class.new +# result = service.call +# expect(result).to be(true) +# end +# @example CountAsOne: ['array', 'heredoc', 'method_call'] +# +# it do +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# msg = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# +# foo( # +1 +# 1, +# 2 +# ) +# end # 6 points +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#57 +class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#62 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#70 + def cop_label; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#60 +RuboCop::Cop::RSpec::ExampleLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks for examples without a description. +# +# RSpec allows for auto-generated example descriptions when there is no +# description provided or the description is an empty one. +# It is acceptable to use `specify` without a description +# +# This cop removes empty descriptions. +# It also defines whether auto-generated description is allowed, based +# on the configured style. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example +# # always good +# specify do +# result = service.call +# expect(result).to be(true) +# end +# @example `EnforcedStyle: always_allow` (default) +# # bad +# it('') { is_expected.to be_good } +# specify '' do +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it { is_expected.to be_good } +# specify do +# result = service.call +# expect(result).to be(true) +# end +# @example `EnforcedStyle: single_line_only` +# # bad +# it('') { is_expected.to be_good } +# it do +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it { is_expected.to be_good } +# @example `EnforcedStyle: disallow` +# # bad +# it { is_expected.to be_good } +# it do +# result = service.call +# expect(result).to be(true) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#59 +class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#67 + def example_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#69 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#83 + def check_example_without_description(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#91 + def disallow_empty_description?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#64 +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#62 +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String) + +# Checks for common mistakes in example descriptions. +# +# This cop will correct docstrings that begin with 'should' and 'it'. +# This cop will also look for insufficient examples and call them out. +# +# The autocorrect is experimental - use with care! It can be configured +# with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only). +# +# Use the DisallowedExamples setting to prevent unclear or insufficient +# descriptions. Please note that this config will not be treated as +# case sensitive. +# +# @example +# # bad +# it 'should find nothing' do +# end +# +# it 'will find nothing' do +# end +# +# # good +# it 'finds nothing' do +# end +# @example +# # bad +# it 'it does things' do +# end +# +# # good +# it 'does things' do +# end +# @example `DisallowedExamples: ['works']` (default) +# # bad +# it 'works' do +# end +# +# # good +# it 'marks the task as done' do +# end +# @see http://betterspecs.org/#should +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#49 +class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#63 + def it_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#71 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#89 + def add_wording_offense(node, message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#136 + def custom_transform; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#99 + def docstring(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#140 + def ignored_words; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#144 + def insufficient_docstring?(description_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#148 + def insufficient_examples; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#153 + def preprocess(message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#109 + def replacement_text(node); end + + # Recursive processing is required to process nested dstr nodes + # that is the case for \-separated multiline strings with interpolation. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#125 + def text(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#60 +RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#55 +RuboCop::Cop::RSpec::ExampleWording::MSG_INSUFFICIENT_DESCRIPTION = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#54 +RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#52 +RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#53 +RuboCop::Cop::RSpec::ExampleWording::MSG_WILL = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#58 +RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#59 +RuboCop::Cop::RSpec::ExampleWording::WILL_PREFIX = T.let(T.unsafe(nil), Regexp) + +# Checks for excessive whitespace in example descriptions. +# +# @example +# # bad +# it ' has excessive spacing ' do +# end +# +# # good +# it 'has excessive spacing' do +# end +# @example +# # bad +# context ' when a condition is met ' do +# end +# +# # good +# context 'when a condition is met' do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#26 +class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#32 + def example_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#39 + def on_send(node); end + + private + + # @param node [RuboCop::AST::Node] + # @param text [String] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#76 + def add_whitespace_offense(node, text); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#85 + def docstring(node); end + + # @param text [String] + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#54 + def excessive_whitespace?(text); end + + # @param text [String] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#68 + def strip_excessive_whitespace(text); end + + # Recursive processing is required to process nested dstr nodes + # that is the case for \-separated multiline strings with interpolation. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#97 + def text(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#29 +RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::MSG = T.let(T.unsafe(nil), String) + +# Checks for `expect(...)` calls containing literal values. +# +# Autocorrection is performed when the expected is not a literal. +# +# @example +# # bad +# expect(5).to eq(price) +# expect(/foo/).to eq(pattern) +# expect("John").to eq(name) +# +# # good +# expect(price).to eq(5) +# expect(pattern).to eq(/foo/) +# expect(name).to eq("John") +# +# # bad (not supported autocorrection) +# expect(false).to eq(true) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#24 +class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#57 + def expect_literal(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#68 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#93 + def complex_literal?(node); end + + # This is not implemented using a NodePattern because it seems + # to not be able to match against an explicit (nil) sexp + # + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#85 + def literal?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#89 + def simple_literal?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#98 + def swap(corrector, actual, expected); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#44 +RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#54 +RuboCop::Cop::RSpec::ExpectActual::CORRECTABLE_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#27 +RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#29 +RuboCop::Cop::RSpec::ExpectActual::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#31 +RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#53 +RuboCop::Cop::RSpec::ExpectActual::SKIPPED_MATCHERS = T.let(T.unsafe(nil), Array) + +# Checks for consistent style of change matcher. +# +# Enforces either passing object and attribute as arguments to the matcher +# or passing a block that reads the attribute value. +# +# This cop can be configured using the `EnforcedStyle` option. +# +# @example `EnforcedStyle: method_call` (default) +# # bad +# expect { run }.to change { Foo.bar } +# expect { run }.to change { foo.baz } +# +# # good +# expect { run }.to change(Foo, :bar) +# expect { run }.to change(foo, :baz) +# # also good when there are arguments or chained method calls +# expect { run }.to change { Foo.bar(:count) } +# expect { run }.to change { user.reload.name } +# @example `EnforcedStyle: block` +# # bad +# expect { run }.to change(Foo, :bar) +# +# # good +# expect { run }.to change { Foo.bar } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#32 +class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#41 + def expect_change_with_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#46 + def expect_change_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#72 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#60 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#36 +RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#37 +RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#38 +RuboCop::Cop::RSpec::ExpectChange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Do not use `expect` in hooks such as `before`. +# +# @example +# # bad +# before do +# expect(something).to eq 'foo' +# end +# +# # bad +# after do +# expect_any_instance_of(Something).to receive(:foo) +# end +# +# # good +# it do +# expect(something).to eq 'foo' +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#24 +class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#28 + def expectation(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#30 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#30 + def on_numblock(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#44 + def message(expect, hook); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#25 +RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String) + +# Checks for opportunities to use `expect { ... }.to output`. +# +# @example +# # bad +# $stdout = StringIO.new +# my_app.print_report +# $stdout = STDOUT +# expect($stdout.string).to eq('Hello World') +# +# # good +# expect { my_app.print_report }.to output('Hello World').to_stdout +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#18 +class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#22 + def on_gvasgn(node); end + + private + + # Detect if we are inside the scope of a single example + # + # We want to encourage using `expect { ... }.to output` so + # we only care about situations where you would replace with + # an expectation. Therefore, assignments to stderr or stdout + # within a `before(:all)` or otherwise outside of an example + # don't matter. + # + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#40 + def inside_example_scope?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#19 +RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String) + +# A helper for `explicit` style +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#121 +module RuboCop::Cop::RSpec::ExplicitHelper + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#182 + def predicate_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#191 + def predicate_matcher_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#135 + def allowed_explicit_matchers; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#139 + def check_explicit(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#215 + def corrector_explicit(corrector, to_node, actual, matcher, block_child); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#175 + def heredoc_argument?(matcher); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#209 + def message_explicit(matcher); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#222 + def move_predicate(corrector, actual, matcher, block_child); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#200 + def predicate_matcher_name?(name); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#162 + def replaceable_matcher?(matcher); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#251 + def replacement_matcher(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#233 + def to_predicate_method(matcher); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#171 + def uncorrectable_matcher?(node, matcher); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#127 +RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#125 +RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb#6 +module RuboCop::Cop::RSpec::FactoryBot; end + +# Always declare attribute values as blocks. +# +# @example +# # bad +# kind [:active, :rejected].sample +# +# # good +# kind { [:active, :rejected].sample } +# +# # bad +# closed_at 1.day.from_now +# +# # good +# closed_at { 1.day.from_now } +# +# # bad +# count 1 +# +# # good +# count { 1 } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb#30 +RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically = RuboCop::Cop::FactoryBot::AttributeDefinedStatically + +# Use a consistent style for parentheses in factory bot calls. +# +# @example +# +# # bad +# create :user +# build(:user) +# create(:login) +# create :login +# @example `EnforcedStyle: require_parentheses` (default) +# +# # good +# create(:user) +# create(:user) +# create(:login) +# build(:login) +# @example `EnforcedStyle: omit_parentheses` +# +# # good +# create :user +# build :user +# create :login +# create :login +# +# # also good +# # when method name and first argument are not on same line +# create( +# :user +# ) +# build( +# :user, +# name: 'foo' +# ) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/consistent_parentheses_style.rb#45 +RuboCop::Cop::RSpec::FactoryBot::ConsistentParenthesesStyle = RuboCop::Cop::FactoryBot::ConsistentParenthesesStyle + +# Checks for create_list usage. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: create_list` (default) +# # bad +# 3.times { create :user } +# +# # good +# create_list :user, 3 +# +# # bad +# 3.times { create :user, age: 18 } +# +# # good - index is used to alter the created models attributes +# 3.times { |n| create :user, age: n } +# +# # good - contains a method call, may return different values +# 3.times { create :user, age: rand } +# @example `EnforcedStyle: n_times` +# # bad +# create_list :user, 3 +# +# # good +# 3.times { create :user } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/create_list.rb#36 +RuboCop::Cop::RSpec::FactoryBot::CreateList = RuboCop::Cop::FactoryBot::CreateList + +# Use string value when setting the class attribute explicitly. +# +# This cop would promote faster tests by lazy-loading of +# application files. Also, this could help you suppress potential +# bugs in combination with external libraries by avoiding a preload +# of application files from the factory files. +# +# @example +# # bad +# factory :foo, class: Foo do +# end +# +# # good +# factory :foo, class: 'Foo' do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb#25 +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName = RuboCop::Cop::FactoryBot::FactoryClassName + +# Checks for name style for argument of FactoryBot::Syntax::Methods. +# +# @example EnforcedStyle: symbol (default) +# # bad +# create('user') +# build "user", username: "NAME" +# +# # good +# create(:user) +# build :user, username: "NAME" +# @example EnforcedStyle: string +# # bad +# create(:user) +# build :user, username: "NAME" +# +# # good +# create('user') +# build "user", username: "NAME" +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/factory_name_style.rb#29 +RuboCop::Cop::RSpec::FactoryBot::FactoryNameStyle = RuboCop::Cop::FactoryBot::FactoryNameStyle + +# Use shorthands from `FactoryBot::Syntax::Methods` in your specs. +# +# @example +# # bad +# FactoryBot.create(:bar) +# FactoryBot.build(:bar) +# FactoryBot.attributes_for(:bar) +# +# # good +# create(:bar) +# build(:bar) +# attributes_for(:bar) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb#51 +RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods = RuboCop::Cop::FactoryBot::SyntaxMethods + +# Help methods for file. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#7 +module RuboCop::Cop::RSpec::FileHelp + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#8 + def expanded_file_path; end +end + +# Checks that spec file paths are consistent and well-formed. +# +# This cop is deprecated. +# We plan to remove it in the next major version update to 3.0. +# The migration targets are `RSpec/SpecFilePathSuffix` +# and `RSpec/SpecFilePathFormat`. +# If you are using this cop, please plan for migration. +# +# By default, this checks that spec file paths are consistent with the +# test subject and enforces that it reflects the described +# class/module and its optionally called out method. +# +# With the configuration option `IgnoreMethods` the called out method will +# be ignored when determining the enforced path. +# +# With the configuration option `CustomTransform` modules or classes can +# be specified that should not as usual be transformed from CamelCase to +# snake_case (e.g. 'RuboCop' => 'rubocop' ). +# +# With the configuration option `SpecSuffixOnly` test files will only +# be checked to ensure they end in '_spec.rb'. This option disables +# checking for consistency in the test subject or test methods. +# +# @example +# # bad +# whatever_spec.rb # describe MyClass +# +# # bad +# my_class_spec.rb # describe MyClass, '#method' +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_method_spec.rb # describe MyClass, '#method' +# +# # good +# my_class/method_spec.rb # describe MyClass, '#method' +# @example when configuration is `IgnoreMethods: true` +# # bad +# whatever_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass, '#method' +# @example when configuration is `SpecSuffixOnly: true` +# # good +# whatever_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass, '#method' +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#65 +class RuboCop::Cop::RSpec::FilePath < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + include ::RuboCop::Cop::RSpec::Namespace + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#72 + def example_group(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#81 + def on_top_level_example_group(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#79 + def routing_metadata?(param0); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#142 + def camel_to_snake_case(string); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#149 + def custom_transform; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#91 + def ensure_correct_file_path(send_node, example_group, arguments); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#173 + def expanded_file_path; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#132 + def expected_path(constant); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#157 + def filename_ends_with?(pattern); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#153 + def ignore_methods?; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#125 + def name_pattern(method_name); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#107 + def pattern_for(example_group, arguments); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#121 + def pattern_for_spec_suffix_only; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#161 + def relevant_rubocop_rspec_file?(_file); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#103 + def routing_spec?(args); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#169 + def routing_spec_path?; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#165 + def spec_suffix_only?; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/file_path.rb#69 +RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String) + +# Helps find the true end location of nodes which might contain heredocs. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/final_end_location.rb#7 +module RuboCop::Cop::RSpec::FinalEndLocation + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/final_end_location.rb#8 + def final_end_location(start_node); end +end + +# Checks if examples are focused. +# +# This cop does not support autocorrection in some cases. +# +# @example +# # bad +# describe MyClass, focus: true do +# end +# +# describe MyClass, :focus do +# end +# +# fdescribe MyClass do +# end +# +# # good +# describe MyClass do +# end +# +# # bad +# fdescribe 'test' do; end +# +# # good +# describe 'test' do; end +# +# # bad +# fdescribe 'test' do; end +# +# # good +# describe 'test' do; end +# +# # bad +# shared_examples 'test', focus: true do; end +# +# # good +# shared_examples 'test' do; end +# +# # bad +# shared_context 'test', focus: true do; end +# +# # good +# shared_context 'test' do; end +# +# # bad (does not support autocorrection) +# focus 'test' do; end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#52 +class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#59 + def focusable_selector?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#77 + def focused_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#71 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#81 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#110 + def correct_send(corrector, focus); end + + # @yield [node] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#97 + def focus_metadata(node, &block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#103 + def with_surrounding(focus); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#56 +RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String) + +# Checks the arguments passed to `before`, `around`, and `after`. +# +# This cop checks for consistent style when specifying RSpec +# hooks which run for each example. There are three supported +# styles: "implicit", "each", and "example." All styles have +# the same behavior. +# +# @example `EnforcedStyle: implicit` (default) +# # bad +# before(:each) do +# # ... +# end +# +# # bad +# before(:example) do +# # ... +# end +# +# # good +# before do +# # ... +# end +# @example `EnforcedStyle: each` +# # bad +# before(:example) do +# # ... +# end +# +# # bad +# before do +# # ... +# end +# +# # good +# before(:each) do +# # ... +# end +# @example `EnforcedStyle: example` +# # bad +# before(:each) do +# # ... +# end +# +# # bad +# before do +# # ... +# end +# +# # good +# before(:example) do +# # ... +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#61 +class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#78 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#78 + def on_numblock(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#69 + def scoped_hook(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#74 + def unscoped_hook(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#95 + def autocorrect(corrector, _node, method_send); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#102 + def check_implicit(method_send); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#116 + def explicit_message(scope); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#128 + def hook(node, &block); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#124 + def implicit_style?; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#66 +RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#65 +RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String) + +# Checks for before/around/after hooks that come after an example. +# +# @example +# # bad +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# before { prepare } +# after { clean_up } +# +# # good +# before { prepare } +# after { clean_up } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#25 +class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#31 + def example_or_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#41 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#41 + def on_numblock(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#73 + def autocorrect(corrector, node, first_example); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#55 + def check_hooks(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#69 + def find_first_example(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#51 + def multiline_block?(block); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#28 +RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +# Checks for equality assertions with identical expressions on both sides. +# +# @example +# # bad +# expect(foo.bar).to eq(foo.bar) +# expect(foo.bar).to eql(foo.bar) +# +# # good +# expect(foo.bar).to eq(2) +# expect(foo.bar).to eql(2) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#17 +class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#23 + def equality_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#29 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#18 +RuboCop::Cop::RSpec::IdenticalEqualityAssertion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#20 +RuboCop::Cop::RSpec::IdenticalEqualityAssertion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that implicit block expectation syntax is not used. +# +# Prefer using explicit block expectations. +# +# @example +# # bad +# subject { -> { do_something } } +# it { is_expected.to change(something).to(new_value) } +# +# # good +# it 'changes something to a new value' do +# expect { do_something }.to change(something).to(new_value) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#20 +class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#36 + def implicit_expect(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#25 + def lambda?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#33 + def lambda_subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#40 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#62 + def find_subject(block_node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#58 + def multi_statement_example_group?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#49 + def nearest_subject(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#21 +RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#22 +RuboCop::Cop::RSpec::ImplicitBlockExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that a consistent implicit expectation style is used. +# +# This cop can be configured using the `EnforcedStyle` option +# and supports the `--auto-gen-config` flag. +# +# @example `EnforcedStyle: is_expected` (default) +# # bad +# it { should be_truthy } +# +# # good +# it { is_expected.to be_truthy } +# @example `EnforcedStyle: should` +# # bad +# it { is_expected.to be_truthy } +# +# # good +# it { should be_truthy } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#25 +class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#34 + def implicit_expect(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#49 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#78 + def is_expected_range(source_map); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#69 + def offending_expect(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#86 + def offense_message(offending_source); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#94 + def replacement_source(offending_source); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#47 +RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#29 +RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#31 +RuboCop::Cop::RSpec::ImplicitExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for usage of implicit subject (`is_expected` / `should`). +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: single_line_only` (default) +# # bad +# it do +# is_expected.to be_truthy +# end +# +# # good +# it { is_expected.to be_truthy } +# it do +# expect(subject).to be_truthy +# end +# @example `EnforcedStyle: single_statement_only` +# # bad +# it do +# foo = 1 +# is_expected.to be_truthy +# end +# +# # good +# it do +# foo = 1 +# expect(subject).to be_truthy +# end +# it do +# is_expected.to be_truthy +# end +# @example `EnforcedStyle: disallow` +# # bad +# it { is_expected.to be_truthy } +# +# # good +# it { expect(subject).to be_truthy } +# @example `EnforcedStyle: require_implicit` +# # bad +# it { expect(subject).to be_truthy } +# +# # good +# it { is_expected.to be_truthy } +# +# # bad +# it do +# expect(subject).to be_truthy +# end +# +# # good +# it do +# is_expected.to be_truthy +# end +# +# # good +# it { expect(named_subject).to be_truthy } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#65 +class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#81 + def explicit_unnamed_subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#86 + def implicit_subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#90 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#100 + def autocorrect(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#159 + def example_of(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#135 + def implicit_subject_in_non_its?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#139 + def implicit_subject_in_non_its_and_non_single_line?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#143 + def implicit_subject_in_non_its_and_non_single_statement?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#122 + def invalid?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#147 + def its?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#113 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#151 + def single_line?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#155 + def single_statement?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#69 +RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_EXPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#71 +RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_IMPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#73 +RuboCop::Cop::RSpec::ImplicitSubject::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Do not set up test data using indexes (e.g., `item_1`, `item_2`). +# +# It makes reading the test harder because it's not clear what exactly +# is tested by this particular example. +# +# The configurable options `AllowedIdentifiers` and `AllowedPatterns` +# will also read those set in `Naming/VariableNumber`. +# +# @example `Max: 1 (default)` +# # bad +# let(:item_1) { create(:item) } +# let(:item_2) { create(:item) } +# +# let(:item1) { create(:item) } +# let(:item2) { create(:item) } +# +# # good +# +# let(:visible_item) { create(:item, visible: true) } +# let(:invisible_item) { create(:item, visible: false) } +# @example `Max: 2` +# # bad +# let(:item_1) { create(:item) } +# let(:item_2) { create(:item) } +# let(:item_3) { create(:item) } +# +# # good +# let(:item_1) { create(:item) } +# let(:item_2) { create(:item) } +# @example `AllowedIdentifiers: ['item_1', 'item_2']` +# # good +# let(:item_1) { create(:item) } +# let(:item_2) { create(:item) } +# @example `AllowedPatterns: ['item']` +# # good +# let(:item_1) { create(:item) } +# let(:item_2) { create(:item) } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#47 +class RuboCop::Cop::RSpec::IndexedLet < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::AllowedIdentifiers + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#55 + def let_name(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#62 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#104 + def allowed_identifiers; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#98 + def cop_config_patterns_values; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#78 + def filter_indexed_lets(candidates); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#87 + def indexed_let?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#94 + def let_name_stripped_index(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#76 +RuboCop::Cop::RSpec::IndexedLet::INDEX_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#51 +RuboCop::Cop::RSpec::IndexedLet::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#75 +RuboCop::Cop::RSpec::IndexedLet::SUFFIX_INDEX_REGEX = T.let(T.unsafe(nil), Regexp) + +# A helper for `inflected` style +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#7 +module RuboCop::Cop::RSpec::InflectedHelper + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#39 + def be_bool?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#44 + def be_boolthy?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#29 + def predicate_in_actual?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#48 + def boolean_matcher?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#16 + def check_inflected(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#60 + def message_inflected(predicate); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#56 + def predicate?(sym); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#85 + def remove_predicate(corrector, predicate); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#96 + def rewrite_matcher(corrector, predicate, matcher); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#67 + def to_predicate_matcher(name); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#107 + def true?(to_symbol, matcher); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#11 +RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String) + +# Helps you identify whether a given node +# is within an example group or not. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#8 +module RuboCop::Cop::RSpec::InsideExampleGroup + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#19 + def example_group_root?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#23 + def example_group_root_with_siblings?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#11 + def inside_example_group?(node); end +end + +# Checks for `instance_double` used with `have_received`. +# +# @example +# # bad +# it do +# foo = instance_double(Foo).as_null_object +# expect(foo).to have_received(:bar) +# end +# +# # good +# it do +# foo = instance_spy(Foo) +# expect(foo).to have_received(:bar) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#21 +class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#36 + def have_received_usage(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#28 + def null_double(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#45 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#61 + def autocorrect(corrector, node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#24 +RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String) + +# Checks for instance variable usage in specs. +# +# This cop can be configured with the option `AssignmentOnly` which +# will configure the cop to only register offenses on instance +# variable usage if the instance variable is also assigned within +# the spec +# +# @example +# # bad +# describe MyClass do +# before { @foo = [] } +# it { expect(@foo).to be_empty } +# end +# +# # good +# describe MyClass do +# let(:foo) { [] } +# it { expect(foo).to be_empty } +# end +# @example with AssignmentOnly configuration +# # rubocop.yml +# # RSpec/InstanceVariable: +# # AssignmentOnly: false +# +# # bad +# describe MyClass do +# before { @foo = [] } +# it { expect(@foo).to be_empty } +# end +# +# # allowed +# describe MyClass do +# it { expect(@foo).to be_empty } +# end +# +# # good +# describe MyClass do +# let(:foo) { [] } +# it { expect(foo).to be_empty } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#48 +class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#60 + def custom_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#55 + def dynamic_class?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#71 + def ivar_assigned?(param0, param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#68 + def ivar_usage(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#73 + def on_top_level_group(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#90 + def assignment_only?; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#84 + def valid_usage?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#51 +RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String) + +# Check for `specify` with `is_expected` and one-liner expectations. +# +# @example +# # bad +# specify { is_expected.to be_truthy } +# +# # good +# it { is_expected.to be_truthy } +# +# # good +# specify do +# # ... +# end +# specify { expect(sqrt(4)).to eq(2) } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#21 +class RuboCop::Cop::RSpec::IsExpectedSpecify < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#29 + def offense?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#33 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#25 +RuboCop::Cop::RSpec::IsExpectedSpecify::IS_EXPECTED_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#26 +RuboCop::Cop::RSpec::IsExpectedSpecify::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#24 +RuboCop::Cop::RSpec::IsExpectedSpecify::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that only one `it_behaves_like` style is used. +# +# @example `EnforcedStyle: it_behaves_like` (default) +# # bad +# it_should_behave_like 'a foo' +# +# # good +# it_behaves_like 'a foo' +# @example `EnforcedStyle: it_should_behave_like` +# # bad +# it_behaves_like 'a foo' +# +# # good +# it_should_behave_like 'a foo' +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#22 +class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#31 + def example_inclusion_offense(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#33 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#43 + def message(_node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#26 +RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#28 +RuboCop::Cop::RSpec::ItBehavesLike::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that `all` matcher is used instead of iterating over an array. +# +# @example +# # bad +# it 'validates users' do +# [user1, user2, user3].each { |user| expect(user).to be_valid } +# end +# +# # good +# it 'validates users' do +# expect([user1, user2, user3]).to all(be_valid) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#19 +class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#24 + def each?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#33 + def each_numblock?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#40 + def expectation?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#44 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#52 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#66 + def only_expectations?(body, arg); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#62 + def single_expectation?(body, arg); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#20 +RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String) + +# Enforce that subject is the first definition in the test. +# +# @example +# # bad +# let(:params) { blah } +# subject { described_class.new(params) } +# +# before { do_something } +# subject { described_class.new(params) } +# +# it { expect_something } +# subject { described_class.new(params) } +# it { expect_something_else } +# +# # good +# subject { described_class.new(params) } +# let(:params) { blah } +# +# # good +# subject { described_class.new(params) } +# before { do_something } +# +# # good +# subject { described_class.new(params) } +# it { expect_something } +# it { expect_something_else } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#34 +class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#40 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#70 + def autocorrect(corrector, node, sibling); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#49 + def check_previous_nodes(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#76 + def offending?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#58 + def offending_node(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#66 + def parent(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#38 +RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String) + +# Checks that no class, module, or constant is declared. +# +# Constants, including classes and modules, when declared in a block +# scope, are defined in global namespace, and leak between examples. +# +# If several examples may define a `DummyClass`, instead of being a +# blank slate class as it will be in the first example, subsequent +# examples will be reopening it and modifying its behavior in +# unpredictable ways. +# Even worse when a class that exists in the codebase is reopened. +# +# Anonymous classes are fine, since they don't result in global +# namespace name clashes. +# +# @example Constants leak between examples +# # bad +# describe SomeClass do +# OtherClass = Struct.new +# CONSTANT_HERE = 'I leak into global namespace' +# end +# +# # good +# describe SomeClass do +# before do +# stub_const('OtherClass', Struct.new) +# stub_const('CONSTANT_HERE', 'I only exist during this example') +# end +# end +# @example +# # bad +# describe SomeClass do +# class FooClass < described_class +# def double_that +# some_base_method * 2 +# end +# end +# +# it { expect(FooClass.new.double_that).to eq(4) } +# end +# +# # good - anonymous class, no constant needs to be defined +# describe SomeClass do +# let(:foo_class) do +# Class.new(described_class) do +# def double_that +# some_base_method * 2 +# end +# end +# end +# +# it { expect(foo_class.new.double_that).to eq(4) } +# end +# +# # good - constant is stubbed +# describe SomeClass do +# before do +# foo_class = Class.new(described_class) do +# def do_something +# end +# end +# stub_const('FooClass', foo_class) +# end +# +# it { expect(FooClass.new.double_that).to eq(4) } +# end +# @example +# # bad +# describe SomeClass do +# module SomeModule +# class SomeClass +# def do_something +# end +# end +# end +# end +# +# # good +# describe SomeClass do +# before do +# foo_class = Class.new(described_class) do +# def do_something +# end +# end +# stub_const('SomeModule::SomeClass', foo_class) +# end +# end +# @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#96 +class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#101 + def on_casgn(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#107 + def on_class(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#113 + def on_module(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#121 + def inside_describe_block?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#98 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#97 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#99 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String) + +# Checks for `let` definitions that come after an example. +# +# @example +# # bad +# let(:foo) { bar } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# let(:some) { other } +# +# it 'checks what some does' do +# expect(some).to be +# end +# +# # good +# let(:foo) { bar } +# let(:some) { other } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# it 'checks what some does' do +# expect(some).to be +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#33 +class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#39 + def example_or_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#47 + def include_examples?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#58 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#93 + def autocorrect(corrector, node, first_example); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#74 + def check_let_declarations(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#66 + def example_group_with_include_examples?(body); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#89 + def find_first_example(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#70 + def multiline_block?(block); end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#54 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#36 +RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +# Checks unreferenced `let!` calls being used for test setup. +# +# @example +# # bad +# let!(:my_widget) { create(:widget) } +# +# it 'counts widgets' do +# expect(Widget.count).to eq(1) +# end +# +# # good +# it 'counts widgets' do +# create(:widget) +# expect(Widget.count).to eq(1) +# end +# +# # good +# before { create(:widget) } +# +# it 'counts widgets' do +# expect(Widget.count).to eq(1) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#28 +class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#32 + def example_or_shared_group_or_including?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#40 + def let_bang(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#48 + def method_called?(param0, param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#50 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#66 + def child_let_bang(node, &block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#60 + def unused_let_bang(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#29 +RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String) + +# Helper methods to location. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#7 +module RuboCop::Cop::RSpec::LocationHelp + private + + # @example + # foo 1, 2 + # ^^^^^ + # @param node [RuboCop::AST::SendNode] + # @return [Parser::Source::Range] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#15 + def arguments_with_whitespace(node); end + + # @example + # foo { bar } + # ^^^^^^^^ + # @param node [RuboCop::AST::SendNode] + # @return [Parser::Source::Range] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#26 + def block_with_whitespace(node); end + + class << self + # @example + # foo 1, 2 + # ^^^^^ + # @param node [RuboCop::AST::SendNode] + # @return [Parser::Source::Range] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#15 + def arguments_with_whitespace(node); end + + # @example + # foo { bar } + # ^^^^^^^^ + # @param node [RuboCop::AST::SendNode] + # @return [Parser::Source::Range] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#26 + def block_with_whitespace(node); end + end +end + +# Checks where `match_array` is used. +# +# This cop checks for the following: +# - Prefer `contain_exactly` when matching an array with values. +# - Prefer `eq` when using `match_array` with an empty array literal. +# +# @example +# # bad +# it { is_expected.to match_array([content1, content2]) } +# +# # good +# it { is_expected.to contain_exactly(content1, content2) } +# +# # good +# it { is_expected.to match_array([content] + array) } +# +# # good +# it { is_expected.to match_array(%w(tremble in fear foolish mortals)) } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#25 +class RuboCop::Cop::RSpec::MatchArray < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#32 + def match_array_with_empty_array?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#36 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#45 + def check_populated_array(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#28 +RuboCop::Cop::RSpec::MatchArray::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#29 +RuboCop::Cop::RSpec::MatchArray::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that chains of messages are not being stubbed. +# +# @example +# # bad +# allow(foo).to receive_message_chain(:bar, :baz).and_return(42) +# +# # good +# thing = Thing.new(baz: 42) +# allow(foo).to receive(:bar).and_return(thing) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#16 +class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#20 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#17 +RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#18 +RuboCop::Cop::RSpec::MessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for consistent message expectation style. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: allow` (default) +# +# # bad +# expect(foo).to receive(:bar) +# +# # good +# allow(foo).to receive(:bar) +# @example `EnforcedStyle: expect` +# +# # bad +# allow(foo).to receive(:bar) +# +# # good +# expect(foo).to receive(:bar) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#27 +class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#35 + def message_expectation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#42 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#40 + def receive_message?(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#55 + def preferred_style?(expectation); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#30 +RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#32 +RuboCop::Cop::RSpec::MessageExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that message expectations are set using spies. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: have_received` (default) +# +# # bad +# expect(foo).to receive(:bar) +# do_something +# +# # good +# allow(foo).to receive(:bar) # or use instance_spy +# do_something +# expect(foo).to have_received(:bar) +# @example `EnforcedStyle: receive` +# +# # bad +# allow(foo).to receive(:bar) +# do_something +# expect(foo).to have_received(:bar) +# +# # good +# expect(foo).to receive(:bar) +# do_something +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#33 +class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#45 + def message_expectation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#54 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#50 + def receive_message(param0); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#77 + def error_message(receiver); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#73 + def preferred_style?(expectation); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#67 + def receive_message_matcher(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#38 +RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#36 +RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#42 +RuboCop::Cop::RSpec::MessageSpies::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Helper methods to find RSpec metadata. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#7 +module RuboCop::Cop::RSpec::Metadata + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#26 + def metadata_in_block(param0, param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#30 + def on_block(node); end + + # @raise [::NotImplementedError] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#43 + def on_metadata(_symbols, _hash); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#30 + def on_numblock(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#21 + def rspec_configure(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#13 + def rspec_metadata(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#49 + def on_metadata_arguments(metadata_arguments); end +end + +# Use consistent metadata style. +# +# This cop does not support autocorrection in the case of +# `EnforcedStyle: hash` where the trailing metadata type is ambiguous. +# (e.g. `describe 'Something', :a, b`) +# +# @example EnforcedStyle: symbol (default) +# # bad +# describe 'Something', a: true +# +# # good +# describe 'Something', :a +# @example EnforcedStyle: hash +# # bad +# describe 'Something', :a +# +# # good +# describe 'Something', a: true +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#25 +class RuboCop::Cop::RSpec::MetadataStyle < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::Metadata + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#33 + def extract_metadata_hash(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#43 + def match_ambiguous_trailing_metadata?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#38 + def match_boolean_metadata_pair?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#47 + def on_metadata(symbols, hash); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#66 + def autocorrect_pair(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#71 + def autocorrect_symbol(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#78 + def bad_metadata_pair?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#82 + def bad_metadata_symbol?(_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#86 + def format_symbol_to_pair_source(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#90 + def insert_pair(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#101 + def insert_pair_as_last_argument(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#110 + def insert_pair_to_empty_hash_metadata(corrector, node, hash_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#117 + def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#124 + def insert_symbol(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#131 + def message_for_style; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#138 + def on_metadata_pair(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#146 + def on_metadata_symbol(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#154 + def remove_pair(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#164 + def remove_pair_following(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#176 + def remove_pair_preceding(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#188 + def remove_symbol(corrector, node); end +end + +# Checks that the first argument to an example group is not empty. +# +# @example +# # bad +# describe do +# end +# +# RSpec.describe do +# end +# +# # good +# describe TestedClass do +# end +# +# describe "A feature example" do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#23 +class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#26 + def on_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#24 +RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for multiple top-level example groups. +# +# Multiple descriptions for the same class or module should either +# be nested or separated into different test files. +# +# @example +# # bad +# describe MyClass, '.do_something' do +# end +# describe MyClass, '.do_something_else' do +# end +# +# # good +# describe MyClass do +# describe '.do_something' do +# end +# describe '.do_something_else' do +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#26 +class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#31 + def on_top_level_group(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#29 +RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String) + +# Checks if examples contain too many `expect` calls. +# +# This cop is configurable using the `Max` option +# and works with `--auto-gen-config`. +# +# @example +# # bad +# describe UserCreator do +# it 'builds a user' do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# +# # good +# describe UserCreator do +# it 'sets the users name' do +# expect(user.name).to eq("John") +# end +# +# it 'sets the users age' do +# expect(user.age).to eq(22) +# end +# end +# @example `aggregate_failures: true` (default) +# # good - the cop ignores when RSpec aggregates failures +# describe UserCreator do +# it 'builds a user', :aggregate_failures do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @example `aggregate_failures: false` +# # Detected as an offense +# describe UserCreator do +# it 'builds a user', aggregate_failures: false do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @example `Max: 1` (default) +# # bad +# describe UserCreator do +# it 'builds a user' do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @example `Max: 2` +# # good +# describe UserCreator do +# it 'builds a user' do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @see http://betterspecs.org/#single Single expectation test +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#69 +class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#78 + def aggregate_failures?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#89 + def aggregate_failures_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#86 + def expect?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#93 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#109 + def example_with_aggregate_failures?(example_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#116 + def find_aggregate_failures(example_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#121 + def find_expectation(node, &block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#132 + def flag_example(node, expectation_count:); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#143 + def max_expectations; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#74 +RuboCop::Cop::RSpec::MultipleExpectations::ANYTHING = T.let(T.unsafe(nil), Proc) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#72 +RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#75 +RuboCop::Cop::RSpec::MultipleExpectations::TRUE = T.let(T.unsafe(nil), Proc) + +# Checks if example groups contain too many `let` and `subject` calls. +# +# This cop is configurable using the `Max` option and the `AllowSubject` +# which will configure the cop to only register offenses on calls to +# `let` and not calls to `subject`. +# +# @example +# # bad +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# +# context 'when stuff' do +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# end +# +# # good +# describe MyClass do +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# +# describe MyClass do +# context 'when stuff' do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:booger) { [] } +# end +# +# context 'when other stuff' do +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# end +# @example when disabling AllowSubject configuration +# # rubocop.yml +# # RSpec/MultipleMemoizedHelpers: +# # AllowSubject: false +# +# # bad - `subject` counts towards memoized helpers +# describe MyClass do +# subject { {} } +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# end +# @example with Max configuration +# # rubocop.yml +# # RSpec/MultipleMemoizedHelpers: +# # Max: 1 +# +# # bad +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#84 +class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::RSpec::Variable + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#90 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#101 + def on_new_investigation; end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#110 + def all_helpers(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#142 + def allow_subject?; end + + # Returns the value of attribute example_group_memoized_helpers. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#108 + def example_group_memoized_helpers; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#117 + def helpers(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#138 + def max; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#128 + def variable_nodes(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#88 +RuboCop::Cop::RSpec::MultipleMemoizedHelpers::MSG = T.let(T.unsafe(nil), String) + +# Checks if an example group defines `subject` multiple times. +# +# This cop does not support autocorrection in some cases. +# The autocorrect behavior for this cop depends on the type of +# duplication: +# +# - If multiple named subjects are defined then this probably indicates +# that the overwritten subjects (all subjects except the last +# definition) are effectively being used to define helpers. In this +# case they are replaced with `let`. +# +# - If multiple unnamed subjects are defined though then this can *only* +# be dead code and we remove the overwritten subject definitions. +# +# - If subjects are defined with `subject!` then we don't autocorrect. +# This is enough of an edge case that people can just move this to +# a `before` hook on their own +# +# @example +# # bad +# describe Foo do +# subject(:user) { User.new } +# subject(:post) { Post.new } +# end +# +# # good +# describe Foo do +# let(:user) { User.new } +# subject(:post) { Post.new } +# end +# +# # bad (does not support autocorrection) +# describe Foo do +# subject!(:user) { User.new } +# subject!(:post) { Post.new } +# end +# +# # good +# describe Foo do +# before do +# User.new +# Post.new +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#51 +class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#57 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#71 + def autocorrect(corrector, subject); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#81 + def named_subject?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#89 + def remove_autocorrect(corrector, node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#85 + def rename_autocorrect(corrector, node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#55 +RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String) + +# Checks for explicitly referenced test subjects. +# +# RSpec lets you declare an "implicit subject" using `subject { ... }` +# which allows for tests like `it { is_expected.to be_valid }`. +# If you need to reference your test subject you should explicitly +# name it using `subject(:your_subject_name) { ... }`. Your test subjects +# should be the most important object in your tests so they deserve +# a descriptive name. +# +# This cop can be configured in your configuration using `EnforcedStyle`, +# and `IgnoreSharedExamples` which will not report offenses for implicit +# subjects in shared example groups. +# +# @example `EnforcedStyle: always` (default) +# # bad +# RSpec.describe User do +# subject { described_class.new } +# +# it 'is valid' do +# expect(subject.valid?).to be(true) +# end +# end +# +# # good +# RSpec.describe User do +# subject(:user) { described_class.new } +# +# it 'is valid' do +# expect(user.valid?).to be(true) +# end +# end +# +# # also good +# RSpec.describe User do +# subject(:user) { described_class.new } +# +# it { is_expected.to be_valid } +# end +# @example `EnforcedStyle: named_only` +# # bad +# RSpec.describe User do +# subject(:user) { described_class.new } +# +# it 'is valid' do +# expect(subject.valid?).to be(true) +# end +# end +# +# # good +# RSpec.describe User do +# subject(:user) { described_class.new } +# +# it 'is valid' do +# expect(user.valid?).to be(true) +# end +# end +# +# # also good +# RSpec.describe User do +# subject { described_class.new } +# +# it { is_expected.to be_valid } +# end +# +# # acceptable +# RSpec.describe User do +# subject { described_class.new } +# +# it 'is valid' do +# expect(subject.valid?).to be(true) +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#79 +class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#85 + def example_or_hook_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#97 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#90 + def shared_example?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#95 + def subject_usage(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#120 + def allow_explicit_subject?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#124 + def always?; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#114 + def check_explicit_subject(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#147 + def find_subject(block_node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#109 + def ignored_shared_example?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#128 + def named_only?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#139 + def nearest_subject(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#133 + def subject_definition_is_named?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#82 +RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String) + +# Helps to find namespace of the node. +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/namespace.rb#7 +module RuboCop::Cop::RSpec::Namespace + private + + # @example + # namespace(node) # => ['A', 'B', 'C'] + # @param node [RuboCop::AST::Node] + # @return [Array] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/namespace.rb#14 + def namespace(node); end +end + +# Checks for nested example groups. +# +# This cop is configurable using the `Max` option +# and supports `--auto-gen-config`. +# +# @example +# # bad +# context 'when using some feature' do +# let(:some) { :various } +# let(:feature) { :setup } +# +# context 'when user is signed in' do # flagged by rubocop +# let(:user) do +# UserCreate.call(user_attributes) +# end +# +# let(:user_attributes) do +# { +# name: 'John', +# age: 22, +# role: role +# } +# end +# +# context 'when user is an admin' do # flagged by rubocop +# let(:role) { 'admin' } +# +# it 'blah blah' +# it 'yada yada' +# end +# end +# end +# +# # good +# context 'using some feature as an admin' do +# let(:some) { :various } +# let(:feature) { :setup } +# +# let(:user) do +# UserCreate.call( +# name: 'John', +# age: 22, +# role: 'admin' +# ) +# end +# +# it 'blah blah' +# it 'yada yada' +# end +# @example `Max: 3` (default) +# # bad +# describe Foo do +# context 'foo' do +# context 'bar' do +# context 'baz' do # flagged by rubocop +# end +# end +# end +# end +# @example `Max: 2` +# # bad +# describe Foo do +# context 'foo' do +# context 'bar' do # flagged by rubocop +# context 'baz' do # flagged by rubocop +# end +# end +# end +# end +# @example `AllowedGroups: [] (default)` +# describe Foo do # <-- nested groups 1 +# context 'foo' do # <-- nested groups 2 +# context 'bar' do # <-- nested groups 3 +# end +# end +# end +# @example `AllowedGroups: [path]` +# describe Foo do # <-- nested groups 1 +# path '/foo' do # <-- nested groups 1 (not counted) +# context 'bar' do # <-- nested groups 2 +# end +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#94 +class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#106 + def on_top_level_group(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#156 + def allowed_groups; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#133 + def count_up_nesting?(node, example_group); end + + # @yield [node, nesting] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#118 + def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#143 + def max_nesting; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#147 + def max_nesting_config; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#139 + def message(nesting); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#100 +RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#102 +RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#98 +RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String) + +# Checks if an example contains any expectation. +# +# All RSpec's example and expectation methods are covered by default. +# If you are using your own custom methods, +# add the following configuration: +# +# RSpec: +# Language: +# Examples: +# Regular: +# - custom_it +# Expectations: +# - custom_expect +# +# This cop can be customized with an allowed expectation methods pattern +# with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed +# by default. +# +# @example +# # bad +# it do +# a? +# end +# +# # good +# it do +# expect(a?).to be(true) +# end +# @example `AllowedPatterns` configuration +# +# # .rubocop.yml +# # RSpec/NoExpectationExample: +# # AllowedPatterns: +# # - ^expect_ +# # - ^assert_ +# @example +# # bad +# it do +# not_expect_something +# end +# +# # good +# it do +# expect_something +# end +# +# it do +# assert_something +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#58 +class RuboCop::Cop::RSpec::NoExpectationExample < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RSpec::SkipOrPending + + # @param node [RuboCop::AST::Node] + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#74 + def includes_expectation?(param0); end + + # @param node [RuboCop::AST::Node] + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#84 + def includes_skip_example?(param0); end + + # @param node [RuboCop::AST::BlockNode] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#89 + def on_block(node); end + + # @param node [RuboCop::AST::BlockNode] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#89 + def on_numblock(node); end + + # @param node [RuboCop::AST::Node] + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#67 + def regular_or_focused_example?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#62 +RuboCop::Cop::RSpec::NoExpectationExample::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent method usage for negating expectations. +# +# @example `EnforcedStyle: not_to` (default) +# # bad +# it '...' do +# expect(false).to_not be_true +# end +# +# # good +# it '...' do +# expect(false).not_to be_true +# end +# @example `EnforcedStyle: to_not` +# # bad +# it '...' do +# expect(false).not_to be_true +# end +# +# # good +# it '...' do +# expect(false).to_not be_true +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#30 +class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#38 + def not_to_not_offense(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#40 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#50 + def message(_node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#34 +RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#35 +RuboCop::Cop::RSpec::NotToNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks if there is a let/subject that overwrites an existing one. +# +# @example +# # bad +# let(:foo) { bar } +# let(:foo) { baz } +# +# subject(:foo) { bar } +# let(:foo) { baz } +# +# let(:foo) { bar } +# let!(:foo) { baz } +# +# # good +# subject(:test) { something } +# let(:foo) { bar } +# let(:baz) { baz } +# let!(:other) { other } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#25 +class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#34 + def first_argument_name(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#36 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#29 + def setup?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#64 + def common_setup?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#49 + def find_duplicates(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#26 +RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String) + +# Checks for any pending or skipped examples. +# +# @example +# # bad +# describe MyClass do +# it "should be true" +# end +# +# describe MyClass do +# it "should be true", skip: true do +# expect(1).to eq(2) +# end +# end +# +# describe MyClass do +# it "should be true" do +# pending +# end +# end +# +# describe MyClass do +# xit "should be true" do +# end +# end +# +# # good +# describe MyClass do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#35 +class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::SkipOrPending + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#61 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#54 + def pending_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#41 + def skippable?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#49 + def skippable_example?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#69 + def skipped?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#74 + def skipped_regular_example_without_body?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#38 +RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String) + +# Checks for pending or skipped examples without reason. +# +# @example +# # bad +# pending 'does something' do +# end +# +# # bad +# it 'does something', :pending do +# end +# +# # bad +# it 'does something' do +# pending +# end +# +# # bad +# xdescribe 'something' do +# end +# +# # bad +# skip 'does something' do +# end +# +# # bad +# it 'does something', :skip do +# end +# +# # bad +# it 'does something' do +# skip +# end +# +# # bad +# it 'does something' +# +# # good +# it 'does something' do +# pending 'reason' +# end +# +# # good +# it 'does something' do +# skip 'reason' +# end +# +# # good +# it 'does something', pending: 'reason' do +# end +# +# # good +# it 'does something', skip: 'reason' do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#59 +class RuboCop::Cop::RSpec::PendingWithoutReason < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#82 + def metadata_without_reason?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#102 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#98 + def pending_step_without_reason?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#93 + def skipped_by_example_group_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#72 + def skipped_by_example_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#77 + def skipped_by_example_method_with_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#63 + def skipped_in_example?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#123 + def block_node_example_group?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#135 + def on_pending_by_metadata(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#151 + def on_skipped_by_example_group_method(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#141 + def on_skipped_by_example_method(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#129 + def on_skipped_by_in_example_method(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#116 + def parent_node(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#60 +RuboCop::Cop::RSpec::PendingWithoutReason::MSG = T.let(T.unsafe(nil), String) + +# Prefer using predicate matcher over using predicate method directly. +# +# RSpec defines magic matchers for predicate methods. +# This cop recommends to use the predicate matcher instead of using +# predicate method directly. +# +# @example Strict: true, EnforcedStyle: inflected (default) +# # bad +# expect(foo.something?).to be_truthy +# +# # good +# expect(foo).to be_something +# +# # also good - It checks "true" strictly. +# expect(foo.something?).to be(true) +# @example Strict: false, EnforcedStyle: inflected +# # bad +# expect(foo.something?).to be_truthy +# expect(foo.something?).to be(true) +# +# # good +# expect(foo).to be_something +# @example Strict: true, EnforcedStyle: explicit +# # bad +# expect(foo).to be_something +# +# # good - the above code is rewritten to it by this cop +# expect(foo.something?).to be(true) +# +# # bad - no autocorrect +# expect(foo) +# .to be_something(<<~TEXT) +# bar +# TEXT +# +# # good +# expect(foo.something?(<<~TEXT)).to be(true) +# bar +# TEXT +# @example Strict: false, EnforcedStyle: explicit +# # bad +# expect(foo).to be_something +# +# # good - the above code is rewritten to it by this cop +# expect(foo.something?).to be_truthy +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#314 +class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::InflectedHelper + include ::RuboCop::Cop::RSpec::ExplicitHelper + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#331 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#322 + def on_send(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#320 +RuboCop::Cop::RSpec::PredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb#6 +module RuboCop::Cop::RSpec::Rails; end + +# Checks that tests use RSpec `before` hook over Rails `setup` method. +# +# @example +# # bad +# setup do +# allow(foo).to receive(:bar) +# end +# +# # good +# before do +# allow(foo).to receive(:bar) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb#20 +class RuboCop::Cop::RSpec::Rails::AvoidSetupHook < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb#32 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb#26 + def setup_call(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb#23 +RuboCop::Cop::RSpec::Rails::AvoidSetupHook::MSG = T.let(T.unsafe(nil), String) + +# Checks that tests use `have_http_status` instead of equality matchers. +# +# @example ResponseMethods: ['response', 'last_response'] (default) +# # bad +# expect(response.status).to be(200) +# expect(last_response.code).to eq("200") +# +# # good +# expect(response).to have_http_status(200) +# expect(last_response).to have_http_status(200) +# @example ResponseMethods: ['foo_response'] +# # bad +# expect(foo_response.status).to be(200) +# +# # good +# expect(foo_response).to have_http_status(200) +# +# # also good +# expect(response).to have_http_status(200) +# expect(last_response).to have_http_status(200) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#29 +class RuboCop::Cop::RSpec::Rails::HaveHttpStatus < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#40 + def match_status(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#50 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#72 + def response_methods; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#68 + def response_methods?(name); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#32 +RuboCop::Cop::RSpec::Rails::HaveHttpStatus::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#37 +RuboCop::Cop::RSpec::Rails::HaveHttpStatus::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/have_http_status.rb#36 +RuboCop::Cop::RSpec::Rails::HaveHttpStatus::RUNNERS = T.let(T.unsafe(nil), Set) + +# Identifies redundant spec type. +# +# After setting up rspec-rails, you will have enabled +# `config.infer_spec_type_from_file_location!` by default in +# spec/rails_helper.rb. This cop works in conjunction with this config. +# If you disable this config, disable this cop as well. +# +# @example +# # bad +# # spec/models/user_spec.rb +# RSpec.describe User, type: :model do +# end +# +# # good +# # spec/models/user_spec.rb +# RSpec.describe User do +# end +# +# # good +# # spec/models/user_spec.rb +# RSpec.describe User, type: :common do +# end +# @example `Inferences` configuration +# # .rubocop.yml +# # RSpec/Rails/InferredSpecType: +# # Inferences: +# # services: service +# +# # bad +# # spec/services/user_spec.rb +# RSpec.describe User, type: :service do +# end +# +# # good +# # spec/services/user_spec.rb +# RSpec.describe User do +# end +# +# # good +# # spec/services/user_spec.rb +# RSpec.describe User, type: :common do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#54 +class RuboCop::Cop::RSpec::Rails::InferredSpecType < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # @param node [RuboCop::AST::BlockNode] + # @return [RuboCop::AST::PairNode, nil] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#79 + def describe_with_type(param0 = T.unsafe(nil)); end + + # @param node [RuboCop::AST::BlockNode] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#60 + def on_block(node); end + + # @param node [RuboCop::AST::BlockNode] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#60 + def on_numblock(node); end + + private + + # @param corrector [RuboCop::AST::Corrector] + # @param node [RuboCop::AST::Node] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#91 + def autocorrect(corrector, node); end + + # @param node [RuboCop::AST::PairNode] + # @return [RuboCop::AST::Node] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#111 + def detect_removable_node(node); end + + # @return [String] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#120 + def file_path; end + + # @return [Hash] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#138 + def inferences; end + + # @param node [RuboCop::AST::PairNode] + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#126 + def inferred_type?(node); end + + # @return [Symbol, nil] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#131 + def inferred_type_from_file_path; end + + # @param node [RuboCop::AST::Node] + # @return [Parser::Source::Range] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#97 + def remove_range(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/inferred_spec_type.rb#57 +RuboCop::Cop::RSpec::Rails::InferredSpecType::MSG = T.let(T.unsafe(nil), String) + +# Check if using Minitest-like matchers. +# +# Check the use of minitest-like matchers +# starting with `assert_` or `refute_`. +# +# @example +# # bad +# assert_equal(a, b) +# assert_equal a, b, "must be equal" +# assert_not_includes a, b +# refute_equal(a, b) +# assert_nil a +# refute_empty(b) +# assert_true(a) +# assert_false(a) +# +# # good +# expect(b).to eq(a) +# expect(b).to(eq(a), "must be equal") +# expect(a).not_to include(b) +# expect(b).not_to eq(a) +# expect(a).to eq(nil) +# expect(a).not_to be_empty +# expect(a).to be(true) +# expect(a).to be(false) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#33 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#345 + def message(preferred); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#338 + def on_assertion(node, assertion); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#326 + def on_send(node); end +end + +# TODO: replace with `BasicAssertion.subclasses` in Ruby 3.1+ +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#318 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::ASSERTION_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#37 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + extend ::RuboCop::AST::NodePattern::Macros + + # @return [BasicAssertion] a new instance of BasicAssertion + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#46 + def initialize(expected, actual, failure_message); end + + # Returns the value of attribute actual. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#40 + def actual; end + + # @raise [NotImplementedError] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#65 + def assertion; end + + # Returns the value of attribute expected. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#40 + def expected; end + + # Returns the value of attribute failure_message. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#40 + def failure_message; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#61 + def negated?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#52 + def replaced(node); end + + class << self + # @raise [NotImplementedError] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#42 + def minitest_assertion; end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#254 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::EmptyAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#270 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#266 + def match(actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#262 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#255 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::EmptyAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#71 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::EqualAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#87 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#83 + def match(expected, actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#79 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#72 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::EqualAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#296 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::FalseAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#310 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#306 + def match(actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#302 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#297 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::FalseAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#159 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::InDeltaAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # @return [InDeltaAssertion] a new instance of InDeltaAssertion + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#175 + def initialize(expected, actual, delta, fail_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#181 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#171 + def match(expected, actual, delta, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#167 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#160 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::InDeltaAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#137 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::IncludesAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#153 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#149 + def match(collection, expected, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#145 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#138 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::IncludesAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#115 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::InstanceOfAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#131 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#127 + def match(expected, actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#123 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#116 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::InstanceOfAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#93 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::KindOfAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#109 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#105 + def match(expected, actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#101 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#94 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::KindOfAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#315 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#211 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::MatchAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#226 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#222 + def match(matcher, actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#218 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#212 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::MatchAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#232 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::NilAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#248 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#244 + def match(actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#240 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#233 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::NilAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#187 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::PredicateAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#205 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#199 + def match(subject, predicate, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#195 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#188 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::PredicateAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#324 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#276 +class RuboCop::Cop::RSpec::Rails::MinitestAssertions::TrueAssertion < ::RuboCop::Cop::RSpec::Rails::MinitestAssertions::BasicAssertion + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#290 + def assertion; end + + class << self + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#286 + def match(actual, failure_message); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#282 + def minitest_assertion(param0 = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/minitest_assertions.rb#277 +RuboCop::Cop::RSpec::Rails::MinitestAssertions::TrueAssertion::MATCHERS = T.let(T.unsafe(nil), Array) + +# Enforces use of `be_invalid` or `not_to` for negated be_valid. +# +# @example EnforcedStyle: not_to (default) +# # bad +# expect(foo).to be_invalid +# +# # good +# expect(foo).not_to be_valid +# +# # good (with method chain) +# expect(foo).to be_invalid.and be_odd +# @example EnforcedStyle: be_invalid +# # bad +# expect(foo).not_to be_valid +# +# # good +# expect(foo).to be_invalid +# +# # good (with method chain) +# expect(foo).to be_invalid.or be_even +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#33 +class RuboCop::Cop::RSpec::Rails::NegationBeValid < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#46 + def be_invalid?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#41 + def not_to?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#50 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#75 + def message(_matcher); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#62 + def offense?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#71 + def offense_range(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#90 + def replaced_matcher; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#81 + def replaced_runner; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#37 +RuboCop::Cop::RSpec::Rails::NegationBeValid::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/negation_be_valid.rb#38 +RuboCop::Cop::RSpec::Rails::NegationBeValid::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Prefer to travel in `before` rather than `around`. +# +# @example +# # bad +# around do |example| +# freeze_time do +# example.run +# end +# end +# +# # good +# before { freeze_time } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#27 +class RuboCop::Cop::RSpec::Rails::TravelAround < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#39 + def extract_run_in_travel(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#48 + def match_around_each?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#55 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#55 + def on_numblock(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#70 + def autocorrect(corrector, node, run_node, around_node); end + + # @param node [RuboCop::AST::BlockNode] + # @return [RuboCop::AST::BlockNode, nil] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#83 + def extract_surrounding_around_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#30 +RuboCop::Cop::RSpec::Rails::TravelAround::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/rails/travel_around.rb#32 +RuboCop::Cop::RSpec::Rails::TravelAround::TRAVEL_METHOD_NAMES = T.let(T.unsafe(nil), Set) + +# Check for `once` and `twice` receive counts matchers usage. +# +# @example +# # bad +# expect(foo).to receive(:bar).exactly(1).times +# expect(foo).to receive(:bar).exactly(2).times +# expect(foo).to receive(:bar).at_least(1).times +# expect(foo).to receive(:bar).at_least(2).times +# expect(foo).to receive(:bar).at_most(1).times +# expect(foo).to receive(:bar).at_most(2).times +# +# # good +# expect(foo).to receive(:bar).once +# expect(foo).to receive(:bar).twice +# expect(foo).to receive(:bar).at_least(:once) +# expect(foo).to receive(:bar).at_least(:twice) +# expect(foo).to receive(:bar).at_most(:once) +# expect(foo).to receive(:bar).at_most(:twice).times +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#25 +class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#40 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#33 + def receive_counts(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#38 + def stub?(param0); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#55 + def autocorrect(corrector, node, range); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#72 + def matcher_for(method, count); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#64 + def message_for(node, source); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#81 + def range(node, offending_node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#28 +RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#30 +RuboCop::Cop::RSpec::ReceiveCounts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for multiple messages stubbed on the same object. +# +# @example +# # bad +# before do +# allow(Service).to receive(:foo).and_return(bar) +# allow(Service).to receive(:baz).and_return(qux) +# end +# +# # good +# before do +# allow(Service).to receive_messages(foo: bar, baz: qux) +# end +# +# # good - ignore same message +# before do +# allow(Service).to receive(:foo).and_return(bar) +# allow(Service).to receive(:foo).and_return(qux) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#31 +class RuboCop::Cop::RSpec::ReceiveMessages < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#44 + def allow_argument(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#39 + def allow_receive_message?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#63 + def on_begin(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#59 + def receive_and_return_argument(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#54 + def receive_arg(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#49 + def receive_node(param0); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#83 + def add_repeated_lines_and_arguments(items); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#100 + def arguments(items); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#150 + def heredoc_or_splat?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#146 + def item_range_by_whole_lines(item); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#135 + def message(repeated_lines); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#109 + def normalize_receive_arg(receive_arg); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#117 + def normalize_return_arg(return_arg); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#125 + def register_offense(item, repeated_lines, args); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#73 + def repeated_receive_message(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#139 + def replace_to_receive_messages(corrector, item, args); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#155 + def requires_quotes?(value); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#91 + def uniq_items(items); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#35 +RuboCop::Cop::RSpec::ReceiveMessages::MSG = T.let(T.unsafe(nil), String) + +# Prefer `not_to receive(...)` over `receive(...).never`. +# +# @example +# # bad +# expect(foo).to receive(:bar).never +# +# # good +# expect(foo).not_to receive(:bar) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#15 +class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#21 + def method_on_stub?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#23 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#33 + def autocorrect(corrector, node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#17 +RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#18 +RuboCop::Cop::RSpec::ReceiveNever::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Remove redundant `around` hook. +# +# @example +# # bad +# around do |example| +# example.run +# end +# +# # good +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#16 +class RuboCop::Cop::RSpec::RedundantAround < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#43 + def match_redundant_around_hook_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#48 + def match_redundant_around_hook_send?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#23 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#23 + def on_numblock(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#32 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#59 + def autocorrect(corrector, node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#19 +RuboCop::Cop::RSpec::RedundantAround::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#21 +RuboCop::Cop::RSpec::RedundantAround::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant predicate matcher. +# +# @example +# # bad +# expect(foo).to be_exist(bar) +# expect(foo).not_to be_include(bar) +# expect(foo).to be_all(bar) +# +# # good +# expect(foo).to exist(bar) +# expect(foo).not_to include(bar) +# expect(foo).to all be(bar) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#19 +class RuboCop::Cop::RSpec::RedundantPredicateMatcher < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#28 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#44 + def message(bad_method, good_method); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#48 + def replaceable_arguments?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#56 + def replaced_method_name(method_name); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#22 +RuboCop::Cop::RSpec::RedundantPredicateMatcher::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#23 +RuboCop::Cop::RSpec::RedundantPredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that `remove_const` is not used in specs. +# +# @example +# # bad +# it 'does something' do +# Object.send(:remove_const, :SomeConstant) +# end +# +# before do +# SomeClass.send(:remove_const, :SomeConstant) +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#18 +class RuboCop::Cop::RSpec::RemoveConst < ::RuboCop::Cop::RSpec::Base + # Check for offenses + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#32 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#27 + def remove_const(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#22 +RuboCop::Cop::RSpec::RemoveConst::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#24 +RuboCop::Cop::RSpec::RemoveConst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for repeated description strings in example groups. +# +# @example +# # bad +# RSpec.describe User do +# it 'is valid' do +# # ... +# end +# +# it 'is valid' do +# # ... +# end +# end +# +# # good +# RSpec.describe User do +# it 'is valid when first and last name are present' do +# # ... +# end +# +# it 'is valid when last name only is present' do +# # ... +# end +# end +# +# # good +# RSpec.describe User do +# it 'is valid' do +# # ... +# end +# +# it 'is valid', :flag do +# # ... +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#42 +class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#45 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#88 + def example_signature(example); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#92 + def its_signature(example); end + + # Select examples in the current scope with repeated description strings + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#60 + def repeated_descriptions(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#74 + def repeated_its(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#43 +RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated examples within example groups. +# +# @example +# +# it 'is valid' do +# expect(user).to be_valid +# end +# +# it 'validates the user' do +# expect(user).to be_valid +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#18 +class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#21 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#41 + def example_signature(example); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#31 + def repeated_examples(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#19 +RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated describe and context block body. +# +# @example +# # bad +# describe 'cool feature x' do +# it { cool_predicate } +# end +# +# describe 'cool feature y' do +# it { cool_predicate } +# end +# +# # good +# describe 'cool feature' do +# it { cool_predicate } +# end +# +# describe 'another cool feature' do +# it { another_predicate } +# end +# +# # good +# context 'when case x', :tag do +# it { cool_predicate } +# end +# +# context 'when case y' do +# it { cool_predicate } +# end +# +# # good +# context Array do +# it { is_expected.to respond_to :each } +# end +# +# context Hash do +# it { is_expected.to respond_to :each } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#45 +class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::SkipOrPending + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#59 + def body(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#62 + def const_arg(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#56 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#64 + def on_begin(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#51 + def several_example_groups?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#85 + def add_repeated_lines(groups); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#94 + def message(group, repeats); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#74 + def repeated_group_bodies(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#90 + def signature_keys(group); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#48 +RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated example group descriptions. +# +# @example +# # bad +# describe 'cool feature' do +# # example group +# end +# +# describe 'cool feature' do +# # example group +# end +# +# # bad +# context 'when case x' do +# # example group +# end +# +# describe 'when case x' do +# # example group +# end +# +# # good +# describe 'cool feature' do +# # example group +# end +# +# describe 'another cool feature' do +# # example group +# end +# +# # good +# context 'when case x' do +# # example group +# end +# +# context 'when another case' do +# # example group +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#45 +class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::SkipOrPending + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#56 + def doc_string_and_metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#61 + def empty_description?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#63 + def on_begin(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#51 + def several_example_groups?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#85 + def add_repeated_lines(groups); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#90 + def message(group, repeats); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#73 + def repeated_group_descriptions(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#48 +RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated include of shared examples. +# +# @example +# # bad +# describe 'foo' do +# include_examples 'cool stuff' +# include_examples 'cool stuff' +# end +# +# # bad +# describe 'foo' do +# it_behaves_like 'a cool', 'thing' +# it_behaves_like 'a cool', 'thing' +# end +# +# # bad +# context 'foo' do +# it_should_behave_like 'a duck' +# it_should_behave_like 'a duck' +# end +# +# # good +# describe 'foo' do +# include_examples 'cool stuff' +# end +# +# describe 'bar' do +# include_examples 'cool stuff' +# end +# +# # good +# describe 'foo' do +# it_behaves_like 'a cool', 'thing' +# it_behaves_like 'a cool', 'person' +# end +# +# # good +# context 'foo' do +# it_should_behave_like 'a duck' +# it_should_behave_like 'a goose' +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#48 +class RuboCop::Cop::RSpec::RepeatedIncludeExample < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#58 + def include_examples?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#65 + def on_begin(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#53 + def several_include_examples?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#62 + def shared_examples_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#90 + def add_repeated_lines(items); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#85 + def literal_include_examples?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#99 + def message(item, repeats); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#75 + def repeated_include_examples(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#95 + def signature_keys(item); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#49 +RuboCop::Cop::RSpec::RepeatedIncludeExample::MSG = T.let(T.unsafe(nil), String) + +# Checks for repeated calls to subject missing that it is memoized. +# +# @example +# # bad +# it do +# subject +# expect { subject }.to not_change { A.count } +# end +# +# it do +# expect { subject }.to change { A.count } +# expect { subject }.to not_change { A.count } +# end +# +# # good +# it do +# expect { my_method }.to change { A.count } +# expect { my_method }.to not_change { A.count } +# end +# +# # also good +# it do +# expect { subject.a }.to change { A.count } +# expect { subject.b }.to not_change { A.count } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#32 +class RuboCop::Cop::RSpec::RepeatedSubjectCall < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#65 + def on_top_level_group(node); end + + # Find a named or unnamed subject definition + # + # @example anonymous subject + # subject?(parse('subject { foo }').ast) do |name| + # name # => :subject + # end + # @example named subject + # subject?(parse('subject(:thing) { foo }').ast) do |name| + # name # => :thing + # end + # @param node [RuboCop::AST::Node] + # @yield [Symbol] subject name + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#53 + def subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#61 + def subject_calls(param0, param1); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#73 + def detect_offense(subject_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#84 + def detect_offenses_in_block(node, subject_names = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#96 + def detect_offenses_in_example(node, subject_names); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#110 + def detect_subjects_in_scope(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#80 + def expect_block(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#35 +RuboCop::Cop::RSpec::RepeatedSubjectCall::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent style of stub's return setting. +# +# Enforces either `and_return` or block-style return in the cases +# where the returned value is constant. Ignores dynamic returned values +# are the result would be different +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: and_return` (default) +# # bad +# allow(Foo).to receive(:bar) { "baz" } +# expect(Foo).to receive(:bar) { "baz" } +# +# # good +# allow(Foo).to receive(:bar).and_return("baz") +# expect(Foo).to receive(:bar).and_return("baz") +# # also good as the returned value is dynamic +# allow(Foo).to receive(:bar) { bar.baz } +# @example `EnforcedStyle: block` +# # bad +# allow(Foo).to receive(:bar).and_return("baz") +# expect(Foo).to receive(:bar).and_return("baz") +# +# # good +# allow(Foo).to receive(:bar) { "baz" } +# expect(Foo).to receive(:bar) { "baz" } +# # also good as the returned value is dynamic +# allow(Foo).to receive(:bar).and_return(bar.baz) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#36 +class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#51 + def and_return_value(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#45 + def contains_stub?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#62 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#55 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#48 + def stub_with_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#71 + def check_and_return_call(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#81 + def check_block_body(block); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#90 + def dynamic?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#95 +class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector + # @return [AndReturnCallCorrector] a new instance of AndReturnCallCorrector + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#96 + def initialize(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#102 + def call(corrector); end + + private + + # Returns the value of attribute arg. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111 + def arg; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#133 + def hash_without_braces?; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#113 + def heredoc?; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111 + def node; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#117 + def range; end + + # Returns the value of attribute receiver. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111 + def receiver; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#125 + def replacement; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#139 +class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector + # @return [BlockBodyCorrector] a new instance of BlockBodyCorrector + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#140 + def initialize(block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#146 + def call(corrector); end + + private + + # Returns the value of attribute block. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158 + def block; end + + # Returns the value of attribute body. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158 + def body; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#160 + def heredoc?; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158 + def node; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#164 +RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#40 +RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#41 +RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#42 +RuboCop::Cop::RSpec::ReturnFromStub::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for let scattered across the example group. +# +# Group lets together +# +# @example +# # bad +# describe Foo do +# let(:foo) { 1 } +# subject { Foo } +# let(:bar) { 2 } +# before { prepare } +# let!(:baz) { 3 } +# end +# +# # good +# describe Foo do +# subject { Foo } +# before { prepare } +# let(:foo) { 1 } +# let(:bar) { 2 } +# let!(:baz) { 3 } +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#29 +class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#34 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#42 + def check_let_declarations(body); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#32 +RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String) + +# Checks for setup scattered across multiple hooks in an example group. +# +# Unify `before`, `after`, and `around` hooks when possible. +# +# @example +# # bad +# describe Foo do +# before { setup1 } +# before { setup2 } +# end +# +# # good +# describe Foo do +# before do +# setup1 +# setup2 +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#25 +class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#32 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#75 + def autocorrect(corrector, first_occurrence, occurrence); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#60 + def lines_msg(numbers); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#68 + def message(occurrences, occurrence); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#47 + def repeated_hooks(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#29 +RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String) + +# Checks for proper shared_context and shared_examples usage. +# +# If there are no examples defined, use shared_context. +# If there is no setup defined, use shared_examples. +# +# @example +# # bad +# RSpec.shared_context 'only examples here' do +# it 'does x' do +# end +# +# it 'does y' do +# end +# end +# +# # good +# RSpec.shared_examples 'only examples here' do +# it 'does x' do +# end +# +# it 'does y' do +# end +# end +# @example +# # bad +# RSpec.shared_examples 'only setup here' do +# subject(:foo) { :bar } +# +# let(:baz) { :bazz } +# +# before do +# something +# end +# end +# +# # good +# RSpec.shared_context 'only setup here' do +# subject(:foo) { :bar } +# +# let(:baz) { :bazz } +# +# before do +# something +# end +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#53 +class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#65 + def context?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#60 + def examples?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#81 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#72 + def shared_context(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#77 + def shared_example(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#97 + def context_with_only_examples(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#101 + def examples_with_only_context(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#57 +RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#56 +RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String) + +# Checks for consistent style for shared example names. +# +# Enforces either `string` or `symbol` for shared example names. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: string` (default) +# # bad +# it_behaves_like :foo_bar_baz +# it_should_behave_like :foo_bar_baz +# shared_examples :foo_bar_baz +# shared_examples_for :foo_bar_baz +# include_examples :foo_bar_baz +# +# # good +# it_behaves_like 'foo bar baz' +# it_should_behave_like 'foo bar baz' +# shared_examples 'foo bar baz' +# shared_examples_for 'foo bar baz' +# include_examples 'foo bar baz' +# @example `EnforcedStyle: symbol` +# # bad +# it_behaves_like 'foo bar baz' +# it_should_behave_like 'foo bar baz' +# shared_examples 'foo bar baz' +# shared_examples_for 'foo bar baz' +# include_examples 'foo bar baz' +# +# # good +# it_behaves_like :foo_bar_baz +# it_should_behave_like :foo_bar_baz +# shared_examples :foo_bar_baz +# shared_examples_for :foo_bar_baz +# include_examples :foo_bar_baz +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#42 +class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#54 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#47 + def shared_examples(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#75 + def new_checker(ast_node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#67 + def offense?(ast_node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#104 +class RuboCop::Cop::RSpec::SharedExamples::StringChecker + # @return [StringChecker] a new instance of StringChecker + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#110 + def initialize(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#114 + def message; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#108 + def node; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#118 + def preferred_style; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#105 +RuboCop::Cop::RSpec::SharedExamples::StringChecker::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#84 +class RuboCop::Cop::RSpec::SharedExamples::SymbolChecker + # @return [SymbolChecker] a new instance of SymbolChecker + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#90 + def initialize(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#94 + def message; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#88 + def node; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#98 + def preferred_style; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#85 +RuboCop::Cop::RSpec::SharedExamples::SymbolChecker::MSG = T.let(T.unsafe(nil), String) + +# Checks that chains of messages contain more than one element. +# +# @example +# # bad +# allow(foo).to receive_message_chain(:bar).and_return(42) +# +# # good +# allow(foo).to receive(:bar).and_return(42) +# +# # also good +# allow(foo).to receive(:bar, :baz) +# allow(foo).to receive("bar.baz") +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#19 +class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#27 + def message_chain(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#34 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#32 + def single_key_hash?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#49 + def autocorrect(corrector, node, method, arg); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#77 + def autocorrect_array_arg(corrector, arg); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#69 + def autocorrect_hash_arg(corrector, arg); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#83 + def key_to_arg(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#87 + def replacement(method); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#65 + def single_element_array?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#55 + def valid_usage?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#22 +RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#24 +RuboCop::Cop::RSpec::SingleArgumentMessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for passing a block to `skip` within examples. +# +# @example +# # bad +# it 'does something' do +# skip 'not yet implemented' do +# do_something +# end +# end +# +# # good +# it 'does something' do +# skip 'not yet implemented' +# do_something +# end +# +# # good - when outside example +# skip 'not yet implemented' do +# end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#26 +class RuboCop::Cop::RSpec::SkipBlockInsideExample < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#29 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#29 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#40 + def inside_example?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#27 +RuboCop::Cop::RSpec::SkipBlockInsideExample::MSG = T.let(T.unsafe(nil), String) + +# Helps check offenses with variable definitions +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#7 +module RuboCop::Cop::RSpec::SkipOrPending + extend ::RuboCop::AST::NodePattern::Macros + + # Match skip/pending statements inside a block (e.g. `context`) + # + # @example source that matches + # context 'when color is blue' do + # skip 'not implemented yet' + # pending 'not implemented yet' + # end + # @example source that does not match + # skip 'not implemented yet' + # pending 'not implemented yet' + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#33 + def skip_or_pending_inside_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#11 + def skipped_in_metadata?(param0 = T.unsafe(nil)); end +end + +# Sort RSpec metadata alphabetically. +# +# @example +# # bad +# describe 'Something', :b, :a +# context 'Something', foo: 'bar', baz: true +# it 'works', :b, :a, foo: 'bar', baz: true +# +# # good +# describe 'Something', :a, :b +# context 'Something', baz: true, foo: 'bar' +# it 'works', :a, :b, baz: true, foo: 'bar' +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#19 +class RuboCop::Cop::RSpec::SortMetadata < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::Metadata + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#26 + def on_metadata(symbols, hash); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#38 + def crime_scene(symbols, pairs); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#47 + def replacement(symbols, pairs); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#55 + def sort_pairs(pairs); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#59 + def sort_symbols(symbols); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#51 + def sorted?(symbols, pairs); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#24 +RuboCop::Cop::RSpec::SortMetadata::MSG = T.let(T.unsafe(nil), String) + +# Checks that spec file paths are consistent and well-formed. +# +# @example +# # bad +# whatever_spec.rb # describe MyClass +# my_class_spec.rb # describe MyClass, '#method' +# +# # good +# my_class_spec.rb # describe MyClass +# my_class_method_spec.rb # describe MyClass, '#method' +# my_class/method_spec.rb # describe MyClass, '#method' +# @example `CustomTransform: {RuboCop=>rubocop, RSpec=>rspec}` (default) +# # good +# rubocop_spec.rb # describe RuboCop +# rspec_spec.rb # describe RSpec +# @example `IgnoreMethods: false` (default) +# # bad +# my_class_spec.rb # describe MyClass, '#method' +# @example `IgnoreMethods: true` +# # good +# my_class_spec.rb # describe MyClass, '#method' +# @example `IgnoreMetadata: {type=>routing}` (default) +# # good +# whatever_spec.rb # describe MyClass, type: :routing do; end +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#35 +class RuboCop::Cop::RSpec::SpecFilePathFormat < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + include ::RuboCop::Cop::RSpec::Namespace + include ::RuboCop::Cop::RSpec::FileHelp + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#43 + def example_group_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#48 + def metadata_key_value(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#50 + def on_top_level_example_group(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#108 + def camel_to_snake_case(string); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#81 + def correct_path_pattern(class_name, arguments); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#115 + def custom_transform; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#62 + def ensure_correct_file_path(send_node, class_name, arguments); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#98 + def expected_path(constant); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#127 + def filename_ends_with?(pattern); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#94 + def ignore?(method_name); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#123 + def ignore_metadata; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#73 + def ignore_metadata?(arguments); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#119 + def ignore_methods?; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#88 + def name_pattern(method_name); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#40 +RuboCop::Cop::RSpec::SpecFilePathFormat::MSG = T.let(T.unsafe(nil), String) + +# Checks that spec file paths suffix are consistent and well-formed. +# +# @example +# # bad +# my_class/foo_specorb.rb # describe MyClass +# spec/models/user.rb # describe User +# spec/models/user_specxrb # describe User +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good - shared examples are allowed +# spec/models/user.rb # shared_examples_for 'foo' +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#20 +class RuboCop::Cop::RSpec::SpecFilePathSuffix < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + include ::RuboCop::Cop::RSpec::FileHelp + + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#26 + def on_top_level_example_group(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#34 + def correct_path?; end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#24 +RuboCop::Cop::RSpec::SpecFilePathSuffix::MSG = T.let(T.unsafe(nil), String) + +# Checks that message expectations do not have a configured response. +# +# @example +# # bad +# expect(foo).to receive(:bar).with(42).and_return("hello world") +# +# # good (without spies) +# allow(foo).to receive(:bar).with(42).and_return("hello world") +# expect(foo).to receive(:bar).with(42) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#16 +class RuboCop::Cop::RSpec::StubbedMock < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#42 + def configured_response?(param0 = T.unsafe(nil)); end + + # Match expectation + # + # @example source that matches + # is_expected.to be_in_the_bar + # @example source that matches + # expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari) + # @example source that matches + # expect_any_instance_of(Officer).to be_alert + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] expectation, method name, matcher + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#61 + def expectation(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response in block-pass + # + # @example source that matches + # receive(:foo, &canned) + # @example source that matches + # receive_message_chain(:foo, :bar, &canned) + # @example source that matches + # receive(:foo).with('bar', &canned) + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#129 + def matcher_with_blockpass(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response + # + # @example source that matches + # receive(:foo).and_return('bar') + # @example source that matches + # receive(:lower).and_raise(SomeError) + # @example source that matches + # receive(:redirect).and_call_original + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#81 + def matcher_with_configured_response(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response defined as a hash + # + # @example source that matches + # receive_messages(foo: 'bar', baz: 'qux') + # @example source that matches + # receive_message_chain(:foo, bar: 'baz') + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#108 + def matcher_with_hash(param0 = T.unsafe(nil)); end + + # Match matcher with a return block + # + # @example source that matches + # receive(:foo) { 'bar' } + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#93 + def matcher_with_return_block(param0 = T.unsafe(nil)); end + + # Match message expectation matcher + # + # @example source that matches + # receive(:foo) + # @example source that matches + # receive_message_chain(:foo, :bar) + # @example source that matches + # receive(:foo).with('bar') + # @param node [RuboCop::AST::Node] + # @return [Array] matching nodes + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#34 + def message_expectation?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#138 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#155 + def msg(method_name); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#144 + def on_expectation(expectation, method_name, matcher); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#161 + def replacement(method_name); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#17 +RuboCop::Cop::RSpec::StubbedMock::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#136 +RuboCop::Cop::RSpec::StubbedMock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Ensure that subject is defined using subject helper. +# +# @example +# # bad +# let(:subject) { foo } +# let!(:subject) { foo } +# subject(:subject) { foo } +# subject!(:subject) { foo } +# +# # bad +# block = -> {} +# let(:subject, &block) +# +# # good +# subject(:test_subject) { foo } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#22 +class RuboCop::Cop::RSpec::SubjectDeclaration < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#27 + def offensive_subject_declaration?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#31 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#40 + def message_for(offense); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#23 +RuboCop::Cop::RSpec::SubjectDeclaration::MSG_LET = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#24 +RuboCop::Cop::RSpec::SubjectDeclaration::MSG_REDUNDANT = T.let(T.unsafe(nil), String) + +# Checks for stubbed test subjects. +# +# Checks nested subject stubs for innermost subject definition +# when subject is also defined in parent example groups. +# +# @example +# # bad +# describe Article do +# subject(:article) { Article.new } +# +# it 'indicates that the author is unknown' do +# allow(article).to receive(:author).and_return(nil) +# expect(article.description).to include('by an unknown author') +# end +# end +# +# # bad +# describe Article do +# subject(:foo) { Article.new } +# +# context 'nested subject' do +# subject(:article) { Article.new } +# +# it 'indicates that the author is unknown' do +# allow(article).to receive(:author).and_return(nil) +# expect(article.description).to include('by an unknown author') +# end +# end +# end +# +# # good +# describe Article do +# subject(:article) { Article.new(author: nil) } +# +# it 'indicates that the author is unknown' do +# expect(article.description).to include('by an unknown author') +# end +# end +# @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test +# @see https://penelope.zone/2015/12/27/introducing-rspec-smells-and-where-to-find-them.html#smell-1-stubjec +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#50 +class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # Find a memoized helper + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#80 + def let?(param0 = T.unsafe(nil)); end + + # Match `allow` and `expect(...).to receive` + # + # @example source that matches + # allow(foo).to receive(:bar) + # allow(foo).to receive(:bar).with(1) + # allow(foo).to receive(:bar).with(1).and_return(2) + # expect(foo).to receive(:bar) + # expect(foo).to receive(:bar).with(1) + # expect(foo).to receive(:bar).with(1).and_return(2) + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#97 + def message_expectation?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#109 + def message_expectation_matcher?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#115 + def on_top_level_group(node); end + + # Find a named or unnamed subject definition + # + # @example anonymous subject + # subject?(parse('subject { foo }').ast) do |name| + # name # => :subject + # end + # @example named subject + # subject?(parse('subject(:thing) { foo }').ast) do |name| + # name # => :thing + # end + # @param node [RuboCop::AST::Node] + # @yield [Symbol] subject name + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#71 + def subject?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#126 + def find_all_explicit(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#140 + def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#53 +RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String) + +# Helper methods for top level example group cops +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#7 +module RuboCop::Cop::RSpec::TopLevelGroup + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#10 + def on_new_investigation; end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#19 + def top_level_groups; end + + private + + # Dummy methods to be overridden in the consumer + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#27 + def on_top_level_example_group(_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#29 + def on_top_level_group(_node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#48 + def root_node; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#31 + def top_level_group?(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#35 + def top_level_nodes(node); end +end + +# Checks for a specified error in checking raised errors. +# +# Enforces one of an Exception type, a string, or a regular +# expression to match against the exception message as a parameter +# to `raise_error` +# +# @example +# # bad +# expect { +# raise StandardError.new('error') +# }.to raise_error +# +# # good +# expect { +# raise StandardError.new('error') +# }.to raise_error(StandardError) +# +# expect { +# raise StandardError.new('error') +# }.to raise_error('error') +# +# expect { +# raise StandardError.new('error') +# }.to raise_error(/err/) +# +# expect { do_something }.not_to raise_error +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#33 +class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#38 + def empty_raise_error_or_exception(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#47 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#59 + def block_with_args?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#55 + def empty_exception_matcher?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#34 +RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#35 +RuboCop::Cop::RSpec::UnspecifiedException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Helps check offenses with variable definitions +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#7 +module RuboCop::Cop::RSpec::Variable + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#14 + def variable_definition?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#11 +RuboCop::Cop::RSpec::Variable::Helpers = RuboCop::RSpec::Language::Helpers + +# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#10 +RuboCop::Cop::RSpec::Variable::Subjects = RuboCop::RSpec::Language::Subjects + +# Checks that memoized helpers names are symbols or strings. +# +# @example EnforcedStyle: symbols (default) +# # bad +# subject('user') { create_user } +# let('user_name') { 'Adam' } +# +# # good +# subject(:user) { create_user } +# let(:user_name) { 'Adam' } +# @example EnforcedStyle: strings +# # bad +# subject(:user) { create_user } +# let(:user_name) { 'Adam' } +# +# # good +# subject('user') { create_user } +# let('user_name') { 'Adam' } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#26 +class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::Variable + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#34 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#51 + def correct_variable(variable); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#67 + def string?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#62 + def style_offense?(variable); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#71 + def symbol?(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#32 +RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks that memoized helper names use the configured style. +# +# Variables can be excluded from checking using the `AllowedPatterns` +# option. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# subject(:userName1) { 'Adam' } +# let(:userName2) { 'Adam' } +# +# # good +# subject(:user_name_1) { 'Adam' } +# let(:user_name_2) { 'Adam' } +# @example EnforcedStyle: camelCase +# # bad +# subject(:user_name_1) { 'Adam' } +# let(:user_name_2) { 'Adam' } +# +# # good +# subject(:userName1) { 'Adam' } +# let(:userName2) { 'Adam' } +# @example AllowedPatterns configuration +# # rubocop.yml +# # RSpec/VariableName: +# # EnforcedStyle: snake_case +# # AllowedPatterns: +# # - ^userFood +# @example +# # okay because it matches the `^userFood` regex in `AllowedPatterns` +# subject(:userFood_1) { 'spaghetti' } +# let(:userFood_2) { 'fettuccine' } +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#41 +class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RSpec::Variable + include ::RuboCop::Cop::RSpec::InsideExampleGroup + + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#49 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#62 + def message(style); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#47 +RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent verified double reference style. +# +# Only investigates references that are one of the supported styles. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: constant` (default) +# # bad +# let(:foo) do +# instance_double('ClassName', method_name: 'returned_value') +# end +# +# # good +# let(:foo) do +# instance_double(ClassName, method_name: 'returned_value') +# end +# @example `EnforcedStyle: string` +# # bad +# let(:foo) do +# instance_double(ClassName, method_name: 'returned_value') +# end +# +# # good +# let(:foo) do +# instance_double('ClassName', method_name: 'returned_value') +# end +# @example Reference is not in the supported style list. No enforcement +# +# # good +# let(:foo) do +# instance_double(@klass, method_name: 'returned_value') +# end +# @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#43 +class RuboCop::Cop::RSpec::VerifiedDoubleReference < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#74 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#66 + def verified_double(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#101 + def correct_style(offense); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#92 + def opposing_style?(class_reference); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#47 +RuboCop::Cop::RSpec::VerifiedDoubleReference::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#60 +RuboCop::Cop::RSpec::VerifiedDoubleReference::REFERENCE_TYPE_STYLES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#49 +RuboCop::Cop::RSpec::VerifiedDoubleReference::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Prefer using verifying doubles over normal doubles. +# +# @example +# # bad +# let(:foo) do +# double(method_name: 'returned value') +# end +# +# # bad +# let(:foo) do +# double("ClassName", method_name: 'returned value') +# end +# +# # good +# let(:foo) do +# instance_double("ClassName", method_name: 'returned value') +# end +# @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#26 +class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#35 + def on_send(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#31 + def unverified_double(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#46 + def symbol?(name); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#27 +RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#28 +RuboCop::Cop::RSpec::VerifiedDoubles::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks void `expect()`. +# +# @example +# # bad +# expect(something) +# +# # good +# expect(something).to be(1) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#15 +class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#21 + def expect?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#26 + def expect_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#36 + def on_block(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#30 + def on_send(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#44 + def check_expect(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#50 + def void?(expect); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#16 +RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#18 +RuboCop::Cop::RSpec::VoidExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for calling a block within a stub. +# +# @example +# # bad +# allow(foo).to receive(:bar) { |&block| block.call(1) } +# +# # good +# expect(foo).to receive(:bar).and_yield(1) +# +# source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#15 +class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#25 + def block_arg(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#28 + def block_call?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#22 + def method_on_stub?(param0); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#30 + def on_block(node); end + + private + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#46 + def autocorrect(corrector, node, range); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#61 + def block_range(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#53 + def calling_block?(node, block); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#73 + def convert_block_to_yield(node); end + + # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#65 + def generate_replacement(node); end +end + +# source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#19 +RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Style; end + +class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop/1.58.0/lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95 + def on_csend(node); end + + # source://rubocop/1.58.0/lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95 + def on_send(node); end + + class << self + # source://rubocop-rspec//lib/rubocop-rspec.rb#60 + def autocorrect_incompatible_with; end + end +end + +# RuboCop RSpec project namespace +# +# source://rubocop-rspec//lib/rubocop/rspec.rb#5 +module RuboCop::RSpec; end + +# Shared behavior for aligning braces for single line lets +# +# source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#6 +class RuboCop::RSpec::AlignLetBrace + include ::RuboCop::RSpec::Language + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + + # @return [AlignLetBrace] a new instance of AlignLetBrace + # + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#10 + def initialize(root, token); end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#21 + def indent_for(node); end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#15 + def offending_tokens; end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#43 + def adjacent_let_chunks; end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#35 + def let_group_for(let); end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#27 + def let_token(node); end + + # Returns the value of attribute root. + # + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#60 + def root; end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#53 + def single_line_lets; end + + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#31 + def target_column_for(let); end + + # Returns the value of attribute token. + # + # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#60 + def token; end +end + +# source://rubocop-rspec//lib/rubocop/rspec.rb#7 +RuboCop::RSpec::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname) + +# Wrapper for RSpec DSL methods +# +# source://rubocop-rspec//lib/rubocop/rspec/concept.rb#6 +class RuboCop::RSpec::Concept + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::RSpec::Language::NodePattern + + # @return [Concept] a new instance of Concept + # + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#11 + def initialize(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#15 + def ==(other); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#15 + def eql?(other); end + + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#21 + def hash; end + + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#25 + def to_node; end + + protected + + # Returns the value of attribute node. + # + # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#31 + def node; end +end + +# source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#5 +module RuboCop::RSpec::Corrector; end + +# Helper methods to move a node +# +# source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#7 +class RuboCop::RSpec::Corrector::MoveNode + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RSpec::CommentsHelp + + # @return [MoveNode] a new instance of MoveNode + # + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#14 + def initialize(node, corrector, processed_source); end + + # Returns the value of attribute corrector. + # + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12 + def corrector; end + + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#27 + def move_after(other); end + + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#20 + def move_before(other); end + + # Returns the value of attribute original. + # + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12 + def original; end + + # Returns the value of attribute processed_source. + # + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12 + def processed_source; end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#40 + def node_range(node); end + + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#44 + def node_range_with_surrounding_space(node); end + + # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#36 + def source(node); end +end + +# Wrapper for RSpec examples +# +# source://rubocop-rspec//lib/rubocop/rspec/example.rb#7 +class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#28 + def definition; end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#16 + def doc_string; end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#8 + def extract_doc_string(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#14 + def extract_implementation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#11 + def extract_metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#24 + def implementation; end + + # source://rubocop-rspec//lib/rubocop/rspec/example.rb#20 + def metadata; end +end + +# Wrapper for RSpec example groups +# +# source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#12 +class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#28 + def examples; end + + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#34 + def hooks; end + + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#20 + def lets; end + + # Detect if the node is an example group or shared example + # + # Selectors which indicate that we should stop searching + # + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#13 + def scope_change?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#24 + def subjects; end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#56 + def find_all(node, predicate); end + + # Recursively search for predicate within the current scope + # + # Searches node and halts when a scope change is detected + # + # @param node [RuboCop::AST::Node] node to recursively search + # @param predicate [Symbol] method to call with node as argument + # @return [Array] discovered nodes + # + # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#50 + def find_all_in_scope(node, predicate); end +end + +# Wrapper for RSpec hook +# +# source://rubocop-rspec//lib/rubocop/rspec/hook.rb#7 +class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#24 + def example?; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#8 + def extract_metadata(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#18 + def knowable_scope?; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#38 + def metadata; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#14 + def name; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#28 + def scope; end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#74 + def scope_argument; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#70 + def scope_name; end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#51 + def transform_metadata(meta); end + + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#66 + def transform_true(node); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#47 + def valid_scope?(node); end +end + +# Because RuboCop doesn't yet support plugins, we have to monkey patch in a +# bit of our configuration. +# +# source://rubocop-rspec//lib/rubocop/rspec/inject.rb#7 +module RuboCop::RSpec::Inject + class << self + # source://rubocop-rspec//lib/rubocop/rspec/inject.rb#8 + def defaults!; end + end +end + +# Contains node matchers for common RSpec DSL. +# +# RSpec allows for configuring aliases for commonly used DSL elements, e.g. +# example groups and hooks. It is possible to configure RuboCop RSpec to +# be able to properly detect these elements in the `RSpec/Language` section +# of the RuboCop YAML configuration file. +# +# In addition to providing useful matchers, this class is responsible for +# using the configured aliases. +# +# source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#5 +module RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::RSpec::Language::NodePattern + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#50 + def example?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#29 + def example_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#45 + def example_group_with_body?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#26 + def explicit_rspec?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#53 + def hook?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#69 + def include?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#61 + def let?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#23 + def rspec?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#34 + def shared_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#38 + def spec_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#77 + def subject?(param0 = T.unsafe(nil)); end + + class << self + # Returns the value of attribute config. + # + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#19 + def config; end + + # Sets the attribute config + # + # @param value the value to set the attribute config to. + # + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#19 + def config=(_arg0); end + end +end + +# This is used in Dialect and DescribeClass cops to detect RSpec blocks. +# +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#205 +module RuboCop::RSpec::Language::ALL + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#206 + def all(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#79 +module RuboCop::RSpec::Language::ExampleGroups + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#81 + def all(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#91 + def focused(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#87 + def regular(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#95 + def skipped(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#101 +module RuboCop::RSpec::Language::Examples + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#103 + def all(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#114 + def focused(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#122 + def pending(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#110 + def regular(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#118 + def skipped(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#128 +module RuboCop::RSpec::Language::Expectations + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#129 + def all(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#134 +module RuboCop::RSpec::Language::Helpers + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#135 + def all(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#146 +module RuboCop::RSpec::Language::HookScopes + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#148 + def all(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#147 +RuboCop::RSpec::Language::HookScopes::ALL = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#140 +module RuboCop::RSpec::Language::Hooks + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#141 + def all(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#153 +module RuboCop::RSpec::Language::Includes + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#155 + def all(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#164 + def context(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#160 + def examples(element); end + end +end + +# Helper methods to detect RSpec DSL used with send and block +# +# @deprecated Prefer using Node Pattern directly +# Use `'(block (send nil? #Example.all ...) ...)'` instead of +# `block_pattern('#Example.all')` +# +# source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#10 +module RuboCop::RSpec::Language::NodePattern + # @deprecated Prefer using Node Pattern directly + # + # source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#30 + def block_or_numblock_pattern(string); end + + # @deprecated Prefer using Node Pattern directly + # + # source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#18 + def block_pattern(string); end + + # @deprecated Prefer using Node Pattern directly + # + # source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#24 + def numblock_pattern(string); end + + # @deprecated Prefer using Node Pattern directly + # + # source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#12 + def send_pattern(string); end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/language/node_pattern.rb#37 + def deprecation_warning(method); end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#170 +module RuboCop::RSpec::Language::Runners + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#173 + def all(element = T.unsafe(nil)); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#171 +RuboCop::RSpec::Language::Runners::ALL = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#181 +module RuboCop::RSpec::Language::SharedGroups + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#183 + def all(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#192 + def context(element); end + + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#188 + def examples(element); end + end +end + +# source://rubocop-rspec//lib/rubocop/rspec/language.rb#198 +module RuboCop::RSpec::Language::Subjects + class << self + # source://rubocop-rspec//lib/rubocop/rspec/language.rb#199 + def all(element); end + end +end + +# RuboCop RSpec specific extensions of RuboCop::AST::Node +# +# source://rubocop-rspec//lib/rubocop/rspec/node.rb#6 +module RuboCop::RSpec::Node + # In various cops we want to regard const as literal although it's not + # strictly literal. + # + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/node.rb#9 + def recursive_literal_or_const?; end +end + +# source://rubocop-rspec//lib/rubocop/rspec.rb#6 +RuboCop::RSpec::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname) + +# Version information for the RSpec RuboCop plugin. +# +# source://rubocop-rspec//lib/rubocop/rspec/version.rb#6 +module RuboCop::RSpec::Version; end + +# source://rubocop-rspec//lib/rubocop/rspec/version.rb#7 +RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String) + +# RSpec example wording rewriter +# +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#6 +class RuboCop::RSpec::Wording + # @return [Wording] a new instance of Wording + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#14 + def initialize(text, ignore:, replace:); end + + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#21 + def rewrite; end + + private + + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#80 + def append_suffix(word, suffix); end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#65 + def ignored_word?(word); end + + # Returns the value of attribute ignores. + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39 + def ignores; end + + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#51 + def remove_should_and_pluralize; end + + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#41 + def replace_prefix(pattern, replacement); end + + # Returns the value of attribute replacements. + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39 + def replacements; end + + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#69 + def substitute(word); end + + # Returns the value of attribute text. + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39 + def text; end + + # @return [Boolean] + # + # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#47 + def uppercase?(word); end +end + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#11 +RuboCop::RSpec::Wording::ES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#12 +RuboCop::RSpec::Wording::IES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#8 +RuboCop::RSpec::Wording::SHOULDNT_BE_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#7 +RuboCop::RSpec::Wording::SHOULDNT_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#9 +RuboCop::RSpec::Wording::WILL_NOT_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#10 +RuboCop::RSpec::Wording::WONT_PREFIX = T.let(T.unsafe(nil), Regexp) diff --git a/sorbet/rbi/gems/rubocop@1.58.0.rbi b/sorbet/rbi/gems/rubocop@1.58.0.rbi index a52345a4bb0..2274866f50c 100644 --- a/sorbet/rbi/gems/rubocop@1.58.0.rbi +++ b/sorbet/rbi/gems/rubocop@1.58.0.rbi @@ -4,5 +4,57116 @@ # This is an autogenerated file for types exported from the `rubocop` gem. # Please instead update this file by running `bin/tapioca gem rubocop`. -# THIS IS AN EMPTY RBI FILE. -# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem +class Parser::Source::Comment + include ::RuboCop::Ext::Comment +end + +class Parser::Source::Range + include ::RuboCop::Ext::Range +end + +class Regexp::Expression::Base + include ::RuboCop::Ext::RegexpParser::Expression::Base +end + +class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression + include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet +end + +class Regexp::Expression::Quantifier + include ::RuboCop::Ext::RegexpParser::Expression::Base +end + +# source://rubocop//lib/rubocop/version.rb#3 +module RuboCop; end + +class RuboCop::AST::ProcessedSource + include ::RuboCop::Ext::ProcessedSource +end + +class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node + include ::RuboCop::Ext::RegexpNode +end + +# This is a class that reads optional command line arguments to rubocop from environment variable. +# +# @api private +# +# source://rubocop//lib/rubocop/arguments_env.rb#6 +class RuboCop::ArgumentsEnv + class << self + # @api private + # + # source://rubocop//lib/rubocop/arguments_env.rb#7 + def read_as_arguments; end + end +end + +# This is a class that reads optional command line arguments to rubocop from .rubocop file. +# +# @api private +# +# source://rubocop//lib/rubocop/arguments_file.rb#6 +class RuboCop::ArgumentsFile + class << self + # @api private + # + # source://rubocop//lib/rubocop/arguments_file.rb#7 + def read_as_arguments; end + end +end + +# The CLI is a class responsible of handling all the command line interface +# logic. +# +# source://rubocop//lib/rubocop/cli.rb#8 +class RuboCop::CLI + # @return [CLI] a new instance of CLI + # + # source://rubocop//lib/rubocop/cli.rb#24 + def initialize; end + + # Returns the value of attribute config_store. + # + # source://rubocop//lib/rubocop/cli.rb#22 + def config_store; end + + # Returns the value of attribute options. + # + # source://rubocop//lib/rubocop/cli.rb#22 + def options; end + + # Entry point for the application logic. Here we + # do the command line arguments processing and inspect + # the target files. + # + # + # @api public + # @param args [Array] command line arguments + # @return [Integer] UNIX exit code + # + # source://rubocop//lib/rubocop/cli.rb#39 + def run(args = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cli.rb#152 + def act_on_options; end + + # source://rubocop//lib/rubocop/cli.rb#189 + def apply_default_formatter; end + + # source://rubocop//lib/rubocop/cli.rb#121 + def execute_runners; end + + # @raise [Finished] + # + # source://rubocop//lib/rubocop/cli.rb#178 + def handle_exiting_options; end + + # source://rubocop//lib/rubocop/cli.rb#140 + def parallel_by_default!; end + + # source://rubocop//lib/rubocop/cli.rb#76 + def profile_if_needed; end + + # source://rubocop//lib/rubocop/cli.rb#109 + def require_gem(name); end + + # source://rubocop//lib/rubocop/cli.rb#117 + def run_command(name); end + + # source://rubocop//lib/rubocop/cli.rb#169 + def set_options_to_config_loader; end + + # source://rubocop//lib/rubocop/cli.rb#129 + def suggest_extensions; end + + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/cli.rb#133 + def validate_options_vs_config; end +end + +# Home of subcommands in the CLI. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command.rb#7 +module RuboCop::CLI::Command + class << self + # Find the command with a given name and run it in an environment. + # + # @api private + # + # source://rubocop//lib/rubocop/cli/command.rb#10 + def run(env, name); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command.rb#16 + def class_for(name); end + end +end + +# Generate a configuration file acting as a TODO list. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#8 +class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#22 + def run; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#98 + def add_formatter; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#106 + def add_inheritance_from_auto_generated_file(config_file); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#102 + def execute_runner; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#127 + def existing_configuration(config_file); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#60 + def line_length_cop(config); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#48 + def line_length_enabled?(config); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#56 + def max_line_length(config); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#31 + def maybe_run_line_length_cop; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#153 + def options_config_in_root?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#64 + def options_has_only_flag?; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#144 + def relative_path_to_todo_from_options_config; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#91 + def reset_config_and_auto_gen_file; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#82 + def run_all_cops(line_length_contents); end + + # Do an initial run with only Layout/LineLength so that cops that + # depend on Layout/LineLength:Max get the correct value for that + # parameter. + # + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#71 + def run_line_length_cop; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#52 + def same_max_line_length?(config1, config2); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#43 + def skip_line_length_cop(reason); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#133 + def write_config_file(file_name, file_string, rubocop_yml_contents); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#11 +RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#15 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1 = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#19 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_DISABLED = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#18 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_OVERRIDDEN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#20 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_SKIPPED = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#16 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_2 = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#13 +RuboCop::CLI::Command::AutoGenerateConfig::PLACEHOLDER = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#12 +RuboCop::CLI::Command::AutoGenerateConfig::YAML_OPTIONAL_DOC_START = T.let(T.unsafe(nil), Regexp) + +# A subcommand in the CLI. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/base.rb#8 +class RuboCop::CLI::Command::Base + # @api private + # @return [Base] a new instance of Base + # + # source://rubocop//lib/rubocop/cli/command/base.rb#26 + def initialize(env); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/base.rb#9 + def env; end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/cli/command/base.rb#21 + def by_command_name(name); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/base.rb#14 + def command_name; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/base.rb#14 + def command_name=(_arg0); end + + # @api private + # @private + # + # source://rubocop//lib/rubocop/cli/command/base.rb#16 + def inherited(subclass); end + end +end + +# Run all the selected cops and report the result. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/execute_runner.rb#8 +class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base + include ::RuboCop::Formatter::TextUtil + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#16 + def run; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#85 + def bug_tracker_uri; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#69 + def display_error_summary(errors); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#56 + def display_summary(runner); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#61 + def display_warning_summary(warnings); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#22 + def execute_runner(paths); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#91 + def maybe_print_corrected_source; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#42 + def with_redirect; end +end + +# Combination of short and long formatter names. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/execute_runner.rb#12 +RuboCop::CLI::Command::ExecuteRunner::INTEGRATION_FORMATTERS = T.let(T.unsafe(nil), Array) + +# Generate a .rubocop.yml file in the current directory. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#8 +class RuboCop::CLI::Command::InitDotfile < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#13 + def run; end +end + +# @api private +# +# source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#9 +RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String) + +# Start Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/lsp.rb#10 +class RuboCop::CLI::Command::Lsp < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/lsp.rb#13 + def run; end +end + +# Shows the given cops, or all cops by default, and their configurations +# for the current directory. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/show_cops.rb#9 +class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base + # @api private + # @return [ShowCops] a new instance of ShowCops + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#12 + def initialize(env); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#19 + def run; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#67 + def config_lines(cop); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#63 + def cops_of_department(cops, department); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#25 + def print_available_cops; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#48 + def print_cop_details(cops); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#36 + def print_cops_of_department(registry, department, show_all); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_cops.rb#57 + def selected_cops_of_department(cops, department); end +end + +# Prints out url to documentation of provided cops +# or documentation base url by default. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#9 +class RuboCop::CLI::Command::ShowDocsUrl < ::RuboCop::CLI::Command::Base + # @api private + # @return [ShowDocsUrl] a new instance of ShowDocsUrl + # + # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#12 + def initialize(env); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#18 + def run; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#38 + def cops_array; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#24 + def print_documentation_url; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#42 + def registry_hash; end +end + +# Suggest RuboCop extensions to install based on Gemfile dependencies. +# Only primary dependencies are evaluated, so if a dependency depends on a +# gem with an extension, it is not suggested. However, if an extension is +# a transitive dependency, it will not be suggested. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#12 +class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#17 + def run; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#73 + def all_extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#69 + def current_formatter; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#111 + def dependent_gems; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#87 + def extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#103 + def installed_and_not_loaded_extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#91 + def installed_extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#115 + def installed_gems; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#99 + def loaded_extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#107 + def lockfile; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#95 + def not_installed_extensions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#41 + def print_install_suggestions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#51 + def print_load_suggestions; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#60 + def print_opt_out_instruction; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#119 + def puts(*args); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#30 + def skip?; end +end + +# Combination of short and long formatter names. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#13 +RuboCop::CLI::Command::SuggestExtensions::INCLUDED_FORMATTERS = T.let(T.unsafe(nil), Array) + +# Display version. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/command/version.rb#8 +class RuboCop::CLI::Command::Version < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop//lib/rubocop/cli/command/version.rb#11 + def run; end +end + +# source://rubocop//lib/rubocop/cli.rb#13 +RuboCop::CLI::DEFAULT_PARALLEL_OPTIONS = T.let(T.unsafe(nil), Array) + +# Execution environment for a CLI command. +# +# @api private +# +# source://rubocop//lib/rubocop/cli/environment.rb#7 +class RuboCop::CLI::Environment + # @api private + # @return [Environment] a new instance of Environment + # + # source://rubocop//lib/rubocop/cli/environment.rb#10 + def initialize(options, config_store, paths); end + + # @api private + # + # source://rubocop//lib/rubocop/cli/environment.rb#8 + def config_store; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/environment.rb#8 + def options; end + + # @api private + # + # source://rubocop//lib/rubocop/cli/environment.rb#8 + def paths; end + + # Run a command in this environment. + # + # @api private + # + # source://rubocop//lib/rubocop/cli/environment.rb#17 + def run(name); end +end + +# source://rubocop//lib/rubocop/cli.rb#20 +class RuboCop::CLI::Finished < ::StandardError; end + +# source://rubocop//lib/rubocop/cli.rb#11 +RuboCop::CLI::STATUS_ERROR = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cli.rb#12 +RuboCop::CLI::STATUS_INTERRUPTED = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cli.rb#10 +RuboCop::CLI::STATUS_OFFENSES = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cli.rb#9 +RuboCop::CLI::STATUS_SUCCESS = T.let(T.unsafe(nil), Integer) + +# This class represents the cache config of the caching RuboCop runs. +# +# @api private +# +# source://rubocop//lib/rubocop/cache_config.rb#6 +class RuboCop::CacheConfig + class << self + # @api private + # + # source://rubocop//lib/rubocop/cache_config.rb#7 + def root_dir; end + end +end + +# Converts RuboCop objects to and from the serialization format JSON. +# +# @api private +# +# source://rubocop//lib/rubocop/cached_data.rb#8 +class RuboCop::CachedData + # @api private + # @return [CachedData] a new instance of CachedData + # + # source://rubocop//lib/rubocop/cached_data.rb#9 + def initialize(filename); end + + # @api private + # + # source://rubocop//lib/rubocop/cached_data.rb#13 + def from_json(text); end + + # @api private + # + # source://rubocop//lib/rubocop/cached_data.rb#17 + def to_json(offenses); end + + private + + # Restore an offense object loaded from a JSON file. + # + # @api private + # + # source://rubocop//lib/rubocop/cached_data.rb#47 + def deserialize_offenses(offenses); end + + # @api private + # + # source://rubocop//lib/rubocop/cached_data.rb#40 + def message(offense); end + + # @api private + # + # source://rubocop//lib/rubocop/cached_data.rb#23 + def serialize_offense(offense); end +end + +# and provides a way to check if each cop is enabled at arbitrary line. +# +# source://rubocop//lib/rubocop/comment_config.rb#6 +class RuboCop::CommentConfig + extend ::Forwardable + + # @return [CommentConfig] a new instance of CommentConfig + # + # source://rubocop//lib/rubocop/comment_config.rb#34 + def initialize(processed_source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/comment_config.rb#63 + def comment_only_line?(line_number); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def config(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/comment_config.rb#51 + def cop_disabled_line_ranges; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/comment_config.rb#39 + def cop_enabled_at_line?(cop, line_number); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/comment_config.rb#47 + def cop_opted_in?(cop); end + + # source://rubocop//lib/rubocop/comment_config.rb#55 + def extra_enabled_comments; end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/comment_config.rb#30 + def processed_source; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def registry(*args, **_arg1, &block); end + + private + + # source://rubocop//lib/rubocop/comment_config.rb#96 + def analyze; end + + # source://rubocop//lib/rubocop/comment_config.rb#124 + def analyze_cop(analysis, directive); end + + # source://rubocop//lib/rubocop/comment_config.rb#144 + def analyze_disabled(analysis, directive); end + + # source://rubocop//lib/rubocop/comment_config.rb#155 + def analyze_rest(analysis, directive); end + + # source://rubocop//lib/rubocop/comment_config.rb#135 + def analyze_single_line(analysis, directive); end + + # source://rubocop//lib/rubocop/comment_config.rb#164 + def cop_line_ranges(analysis); end + + # source://rubocop//lib/rubocop/comment_config.rb#170 + def each_directive; end + + # source://rubocop//lib/rubocop/comment_config.rb#69 + def extra_enabled_comments_with_names(extras:, names:); end + + # source://rubocop//lib/rubocop/comment_config.rb#190 + def handle_enable_all(directive, names, extras); end + + # Collect cops that have been disabled or enabled by name in a directive comment + # so that `Lint/RedundantCopEnableDirective` can register offenses correctly. + # + # source://rubocop//lib/rubocop/comment_config.rb#204 + def handle_switch(directive, names, extras); end + + # source://rubocop//lib/rubocop/comment_config.rb#115 + def inject_disabled_cops_directives(analyses); end + + # source://rubocop//lib/rubocop/comment_config.rb#183 + def non_comment_token_line_numbers; end + + # source://rubocop//lib/rubocop/comment_config.rb#83 + def opt_in_cops; end + + # source://rubocop//lib/rubocop/comment_config.rb#179 + def qualified_cop_name(cop_name); end +end + +# source://rubocop//lib/rubocop/comment_config.rb#9 +RuboCop::CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN = T.let(T.unsafe(nil), Float) + +# This class provides an API compatible with RuboCop::DirectiveComment +# to be used for cops that are disabled in the config file +# +# source://rubocop//lib/rubocop/comment_config.rb#13 +class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment + include ::RuboCop::Ext::Comment + + # @return [ConfigDisabledCopDirectiveComment] a new instance of ConfigDisabledCopDirectiveComment + # + # source://rubocop//lib/rubocop/comment_config.rb#21 + def initialize(cop_name); end + + # Returns the value of attribute line_number. + # + # source://rubocop//lib/rubocop/comment_config.rb#16 + def line_number; end + + # Returns the value of attribute loc. + # + # source://rubocop//lib/rubocop/comment_config.rb#16 + def loc; end + + # Returns the value of attribute text. + # + # source://rubocop//lib/rubocop/comment_config.rb#16 + def text; end +end + +# source://rubocop//lib/rubocop/comment_config.rb#19 +class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Expression < ::Struct + # Returns the value of attribute line + # + # @return [Object] the current value of line + def line; end + + # Sets the attribute line + # + # @param value [Object] the value to set the attribute line to. + # @return [Object] the newly set value + def line=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/comment_config.rb#18 +class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Loc < ::Struct + # Returns the value of attribute expression + # + # @return [Object] the current value of expression + def expression; end + + # Sets the attribute expression + # + # @param value [Object] the value to set the attribute expression to. + # @return [Object] the newly set value + def expression=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/comment_config.rb#28 +class RuboCop::CommentConfig::CopAnalysis < ::Struct + # Returns the value of attribute line_ranges + # + # @return [Object] the current value of line_ranges + def line_ranges; end + + # Sets the attribute line_ranges + # + # @param value [Object] the value to set the attribute line_ranges to. + # @return [Object] the newly set value + def line_ranges=(_); end + + # Returns the value of attribute start_line_number + # + # @return [Object] the current value of start_line_number + def start_line_number; end + + # Sets the attribute start_line_number + # + # @param value [Object] the value to set the attribute start_line_number to. + # @return [Object] the newly set value + def start_line_number=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# This class represents the configuration of the RuboCop application +# and all its cops. A Config is associated with a YAML configuration +# file from which it was read. Several different Configs can be used +# during a run of the rubocop program, if files in several +# directories are inspected. +# +# source://rubocop//lib/rubocop/config.rb#14 +class RuboCop::Config + include ::RuboCop::PathUtil + include ::RuboCop::FileFinder + extend ::Forwardable + + # @return [Config] a new instance of Config + # + # source://rubocop//lib/rubocop/config.rb#32 + def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def [](*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def []=(*args, **_arg1, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#172 + def active_support_extensions_enabled?; end + + # source://rubocop//lib/rubocop/config.rb#98 + def add_excludes_from_higher_level(highest_config); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#195 + def allowed_camel_case_file?(file); end + + # Paths specified in configuration files starting with .rubocop are + # relative to the directory where that file is. Paths in other config files + # are relative to the current directory. This is so that paths in + # config/default.yml, for example, are not relative to RuboCop's config + # directory since that wouldn't work. + # + # source://rubocop//lib/rubocop/config.rb#239 + def base_dir_for_path_parameters; end + + # source://rubocop//lib/rubocop/config.rb#264 + def bundler_lock_file_path; end + + # source://rubocop//lib/rubocop/config.rb#53 + def check; end + + # @api private + # @return [Boolean] whether config for this badge has 'Include' or 'Exclude' keys + # + # source://rubocop//lib/rubocop/config.rb#144 + def clusivity_config_for_badge?(badge); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def delete(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#110 + def deprecation_check; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def dig(*args, **_arg1, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#164 + def disabled_new_cops?; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def each_key(*args, **_arg1, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#168 + def enabled_new_cops?; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def fetch(*args, **_arg1, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#217 + def file_to_exclude?(file); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#176 + def file_to_include?(file); end + + # source://rubocop//lib/rubocop/config.rb#160 + def for_all_cops; end + + # Note: the 'Enabled' attribute is same as that returned by `for_cop` + # + # @return [Config] for the given cop merged with that of its department (if any) + # + # source://rubocop//lib/rubocop/config.rb#130 + def for_badge(badge); end + + # Note: the 'Enabled' attribute is calculated according to the department's + # and 'AllCops' configuration; other attributes are not inherited. + # + # @return [Config] for the given cop / cop name. + # + # source://rubocop//lib/rubocop/config.rb#124 + def for_cop(cop); end + + # Note: the 'Enabled' attribute will be present only if specified + # at the department's level + # + # @return [Config] for the given department name. + # + # source://rubocop//lib/rubocop/config.rb#155 + def for_department(department_name); end + + # source://rubocop//lib/rubocop/config.rb#287 + def inspect; end + + # True if this is a config file that is shipped with RuboCop + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#78 + def internal?; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def key?(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def keys(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#49 + def loaded_features; end + + # Returns the value of attribute loaded_path. + # + # source://rubocop//lib/rubocop/config.rb#22 + def loaded_path; end + + # source://rubocop//lib/rubocop/config.rb#83 + def make_excludes_absolute; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def map(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def merge(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#230 + def path_relative_to_config(path); end + + # source://rubocop//lib/rubocop/config.rb#226 + def patterns_to_exclude; end + + # source://rubocop//lib/rubocop/config.rb#222 + def patterns_to_include; end + + # source://rubocop//lib/rubocop/config.rb#275 + def pending_cops; end + + # Returns true if there's a chance that an Include pattern matches hidden + # files, false if that's definitely not possible. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#209 + def possibly_include_hidden?; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def replace(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#73 + def signature; end + + # source://rubocop//lib/rubocop/config.rb#260 + def smart_loaded_path; end + + # source://rubocop//lib/rubocop/config.rb#249 + def target_rails_version; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def target_ruby_version(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_h(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def to_hash(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#69 + def to_s; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def transform_values(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def validate(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config.rb#60 + def validate_after_resolution; end + + private + + # source://rubocop//lib/rubocop/config.rb#322 + def department_of(qualified_cop_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config.rb#310 + def enable_cop?(qualified_cop_name, cop_options); end + + # source://rubocop//lib/rubocop/config.rb#297 + def read_rails_version_from_bundler_lock_file; end + + # source://rubocop//lib/rubocop/config.rb#293 + def target_rails_version_from_bundler_lock_file; end + + class << self + # source://rubocop//lib/rubocop/config.rb#24 + def create(hash, path, check: T.unsafe(nil)); end + end +end + +# source://rubocop//lib/rubocop/config.rb#19 +class RuboCop::Config::CopConfig < ::Struct + # Returns the value of attribute metadata + # + # @return [Object] the current value of metadata + def metadata; end + + # Sets the attribute metadata + # + # @param value [Object] the value to set the attribute metadata to. + # @return [Object] the newly set value + def metadata=(_); end + + # Returns the value of attribute name + # + # @return [Object] the current value of name + def name; end + + # Sets the attribute name + # + # @param value [Object] the value to set the attribute name to. + # @return [Object] the newly set value + def name=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/config.rb#21 +RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float) + +# This class has methods related to finding configuration path. +# +# @api private +# +# source://rubocop//lib/rubocop/config_finder.rb#8 +class RuboCop::ConfigFinder + extend ::RuboCop::FileFinder + + class << self + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#19 + def find_config_path(target_dir); end + + # Returns the path RuboCop inferred as the root of the project. No file + # searches will go past this directory. + # + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#26 + def project_root; end + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#17 + def project_root=(_arg0); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#59 + def expand_path(path); end + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#40 + def find_project_dotfile(target_dir); end + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#32 + def find_project_root; end + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#44 + def find_user_dotfile; end + + # @api private + # + # source://rubocop//lib/rubocop/config_finder.rb#52 + def find_user_xdg_config; end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_finder.rb#12 +RuboCop::ConfigFinder::DEFAULT_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/config_finder.rb#9 +RuboCop::ConfigFinder::DOTFILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/config_finder.rb#11 +RuboCop::ConfigFinder::RUBOCOP_HOME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/config_finder.rb#10 +RuboCop::ConfigFinder::XDG_CONFIG = T.let(T.unsafe(nil), String) + +# This class represents the configuration of the RuboCop application +# and all its cops. A Config is associated with a YAML configuration +# file from which it was read. Several different Configs can be used +# during a run of the rubocop program, if files in several +# directories are inspected. +# +# source://rubocop//lib/rubocop/config_loader.rb#18 +class RuboCop::ConfigLoader + extend ::RuboCop::FileFinder + + class << self + # source://rubocop//lib/rubocop/config_loader.rb#138 + def add_excludes_from_files(config, config_file); end + + # Used to add features that were required inside a config or from + # the CLI using `--require`. + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader.rb#199 + def add_loaded_features(loaded_features); end + + # source://rubocop//lib/rubocop/config_loader.rb#81 + def add_missing_namespaces(path, hash); end + + # source://rubocop//lib/rubocop/config_loader.rb#42 + def clear_options; end + + # Returns the path of .rubocop.yml searching upwards in the + # directory structure starting at the given directory where the + # inspected file is. If no .rubocop.yml is found there, the + # user's home directory is checked. If there's no .rubocop.yml + # there either, the path to the default file is returned. + # + # source://rubocop//lib/rubocop/config_loader.rb#105 + def configuration_file_for(target_dir); end + + # source://rubocop//lib/rubocop/config_loader.rb#109 + def configuration_from_file(config_file, check: T.unsafe(nil)); end + + # Returns the value of attribute debug. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def debug; end + + # Sets the attribute debug + # + # @param value the value to set the attribute debug to. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def debug=(_arg0); end + + # Returns the value of attribute debug. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def debug?; end + + # source://rubocop//lib/rubocop/config_loader.rb#148 + def default_configuration; end + + # Sets the attribute default_configuration + # + # @param value the value to set the attribute default_configuration to. + # + # source://rubocop//lib/rubocop/config_loader.rb#36 + def default_configuration=(_arg0); end + + # Returns the value of attribute disable_pending_cops. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def disable_pending_cops; end + + # Sets the attribute disable_pending_cops + # + # @param value the value to set the attribute disable_pending_cops to. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def disable_pending_cops=(_arg0); end + + # Returns the value of attribute enable_pending_cops. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def enable_pending_cops; end + + # Sets the attribute enable_pending_cops + # + # @param value the value to set the attribute enable_pending_cops to. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def enable_pending_cops=(_arg0); end + + # Returns the value of attribute ignore_parent_exclusion. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def ignore_parent_exclusion; end + + # Sets the attribute ignore_parent_exclusion + # + # @param value the value to set the attribute ignore_parent_exclusion to. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def ignore_parent_exclusion=(_arg0); end + + # Returns the value of attribute ignore_parent_exclusion. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def ignore_parent_exclusion?; end + + # Returns the value of attribute ignore_unrecognized_cops. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def ignore_unrecognized_cops; end + + # Sets the attribute ignore_unrecognized_cops + # + # @param value the value to set the attribute ignore_unrecognized_cops to. + # + # source://rubocop//lib/rubocop/config_loader.rb#34 + def ignore_unrecognized_cops=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader.rb#156 + def inject_defaults!(project_root); end + + # source://rubocop//lib/rubocop/config_loader.rb#48 + def load_file(file, check: T.unsafe(nil)); end + + # @raise [TypeError] + # + # source://rubocop//lib/rubocop/config_loader.rb#68 + def load_yaml_configuration(absolute_path); end + + # Returns the value of attribute loaded_features. + # + # source://rubocop//lib/rubocop/config_loader.rb#37 + def loaded_features; end + + # Return a recursive merge of two hashes. That is, a normal hash merge, + # with the addition that any value that is a hash, and occurs in both + # arguments, will also be merged. And so on. + # + # source://rubocop//lib/rubocop/config_loader.rb#96 + def merge(base_hash, derived_hash); end + + # Merges the given configuration with the default one. + # + # source://rubocop//lib/rubocop/config_loader.rb#192 + def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/config_loader.rb#129 + def pending_cops_only_qualified(pending_cops); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader.rb#133 + def possible_new_cops?(config); end + + # Returns the path RuboCop inferred as the root of the project. No file + # searches will go past this directory. + # + # @deprecated Use `RuboCop::ConfigFinder.project_root` instead. + # + # source://rubocop//lib/rubocop/config_loader.rb#167 + def project_root; end + + # source://rubocop//lib/rubocop/config_loader.rb#176 + def warn_on_pending_cops(pending_cops); end + + # source://rubocop//lib/rubocop/config_loader.rb#184 + def warn_pending_cop(cop); end + + private + + # source://rubocop//lib/rubocop/config_loader.rb#213 + def check_duplication(yaml_code, absolute_path); end + + # source://rubocop//lib/rubocop/config_loader.rb#205 + def file_path(file); end + + # Read the specified file, or exit with a friendly, concise message on + # stderr. Care is taken to use the standard OS exit code for a "file not + # found" error. + # + # source://rubocop//lib/rubocop/config_loader.rb#233 + def read_file(absolute_path); end + + # source://rubocop//lib/rubocop/config_loader.rb#209 + def resolver; end + + # source://rubocop//lib/rubocop/config_loader.rb#239 + def yaml_safe_load(yaml_code, filename); end + + # source://rubocop//lib/rubocop/config_loader.rb#249 + def yaml_safe_load!(yaml_code, filename); end + end +end + +# source://rubocop//lib/rubocop/config_loader.rb#21 +RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/config_loader.rb#19 +RuboCop::ConfigLoader::DOTFILE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/config_loader.rb#20 +RuboCop::ConfigLoader::RUBOCOP_HOME = T.let(T.unsafe(nil), String) + +# A help class for ConfigLoader that handles configuration resolution. +# +# @api private +# +# source://rubocop//lib/rubocop/config_loader_resolver.rb#9 +class RuboCop::ConfigLoaderResolver + # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the + # base configuration are relative to the directory where the base configuration file is. For the + # derived configuration, we need to make those paths relative to where the derived configuration + # file is. + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#45 + def fix_include_paths(base_config_path, hash, path, key, value); end + + # Return a recursive merge of two hashes. That is, a normal hash merge, + # with the addition that any value that is a hash, and occurs in both + # arguments, will also be merged. And so on. + # + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#99 + def merge(base_hash, derived_hash, **opts); end + + # Merges the given configuration with the default one. If + # AllCops:DisabledByDefault is true, it changes the Enabled params so that + # only cops from user configuration are enabled. If + # AllCops:EnabledByDefault is true, it changes the Enabled params so that + # only cops explicitly disabled in user configuration are disabled. + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#75 + def merge_with_default(config, config_file, unset_nil:); end + + # An `Enabled: true` setting in user configuration for a cop overrides an + # `Enabled: false` setting for its department. + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#119 + def override_department_setting_for_cops(base_hash, derived_hash); end + + # If a cop was previously explicitly enabled, but then superseded by the + # department being disabled, disable it. + # + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#136 + def override_enabled_for_disabled_departments(base_hash, derived_hash); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#19 + def resolve_inheritance(path, hash, file, debug); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#55 + def resolve_inheritance_from_gems(hash); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#10 + def resolve_requires(path, hash); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#208 + def base_configs(path, inherit_from, file); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#176 + def determine_inherit_mode(hash, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#152 + def disabled?(hash, department); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#156 + def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#268 + def gem_config_path(gem_name, relative_config_path); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#246 + def handle_disabled_by_default(config, new_default_configuration); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#220 + def inherited_file(path, inherit_from, file); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#204 + def merge_hashes?(base_hash, derived_hash, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#241 + def remote_file?(uri); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#196 + def should_merge?(mode, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#200 + def should_override?(mode, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#182 + def should_union?(derived_hash, base_hash, root_mode, key); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#264 + def transform(config, &block); end + + # @api private + # + # source://rubocop//lib/rubocop/config_loader_resolver.rb#165 + def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end +end + +# Raised when a RuboCop configuration file is not found. +# +# source://rubocop//lib/rubocop/config_loader.rb#10 +class RuboCop::ConfigNotFoundError < ::RuboCop::Error; end + +# This class handles obsolete configuration. +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/rule.rb#4 +class RuboCop::ConfigObsoletion + # @api private + # @return [ConfigObsoletion] a new instance of ConfigObsoletion + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#35 + def initialize(config); end + + # @api private + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#41 + def reject_obsolete!; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#21 + def rules; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#21 + def warnings; end + + private + + # Cop rules are keyed by the name of the original cop + # + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#72 + def load_cop_rules(rules); end + + # Parameter rules may apply to multiple cops and multiple parameters + # and are given as an array. Each combination is turned into a separate + # rule object. + # + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#85 + def load_parameter_rules(rules); end + + # Default rules for obsoletions are in config/obsoletion.yml + # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename` + # + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#52 + def load_rules; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#98 + def obsoletions; end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#24 + def files; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#24 + def files=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion.rb#26 + def legacy_cop_names; end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion.rb#8 +RuboCop::ConfigObsoletion::COP_RULE_CLASSES = T.let(T.unsafe(nil), Hash) + +# Encapsulation of a ConfigObsoletion rule for changing a parameter +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#7 +class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < ::RuboCop::ConfigObsoletion::ParameterRule + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#14 + def message; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#10 + def violated?; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#28 + def value; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#8 +RuboCop::ConfigObsoletion::ChangedEnforcedStyles::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for changing a parameter +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#7 +class RuboCop::ConfigObsoletion::ChangedParameter < ::RuboCop::ConfigObsoletion::ParameterRule + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#10 + def message; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#8 +RuboCop::ConfigObsoletion::ChangedParameter::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Base class for ConfigObsoletion rules relating to cops +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#7 +class RuboCop::ConfigObsoletion::CopRule < ::RuboCop::ConfigObsoletion::Rule + # @api private + # @return [CopRule] a new instance of CopRule + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#10 + def initialize(config, old_name); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#15 + def cop_rule?; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#19 + def message; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#8 + def old_name; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#28 + def violated?; end + + # Cop rules currently can only be failures, not warnings + # + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#24 + def warning?; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion.rb#7 +RuboCop::ConfigObsoletion::DEFAULT_RULES_FILE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for splitting a cop's +# functionality into multiple new cops. +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#8 +class RuboCop::ConfigObsoletion::ExtractedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [ExtractedCop] a new instance of ExtractedCop + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#11 + def initialize(config, old_name, gem); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#9 + def department; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#9 + def gem; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#23 + def rule_message; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#17 + def violated?; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#32 + def affected_cops; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#41 + def feature_loaded?; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion.rb#18 +RuboCop::ConfigObsoletion::LOAD_RULES_CACHE = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion.rb#14 +RuboCop::ConfigObsoletion::PARAMETER_RULE_CLASSES = T.let(T.unsafe(nil), Hash) + +# Base class for ConfigObsoletion rules relating to parameters +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#7 +class RuboCop::ConfigObsoletion::ParameterRule < ::RuboCop::ConfigObsoletion::Rule + # @api private + # @return [ParameterRule] a new instance of ParameterRule + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#10 + def initialize(config, cop, parameter, metadata); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8 + def cop; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8 + def metadata; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8 + def parameter; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#17 + def parameter_rule?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#21 + def violated?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#25 + def warning?; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#39 + def alternative; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#43 + def alternatives; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#31 + def applies_to_current_ruby_version?; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#47 + def reason; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#51 + def severity; end +end + +# Encapsulation of a ConfigObsoletion rule for removing +# a previously defined cop. +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#8 +class RuboCop::ConfigObsoletion::RemovedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [RemovedCop] a new instance of RemovedCop + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#13 + def initialize(config, old_name, metadata); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#9 + def metadata; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#9 + def old_name; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#18 + def rule_message; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#36 + def alternatives; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#32 + def reason; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#11 +RuboCop::ConfigObsoletion::RemovedCop::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for renaming +# a cop or moving it to a new department. +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#8 +class RuboCop::ConfigObsoletion::RenamedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [RenamedCop] a new instance of RenamedCop + # + # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#11 + def initialize(config, old_name, new_name); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#9 + def new_name; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#16 + def rule_message; end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#22 + def moved?; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#29 + def verb; end +end + +# Abstract base class for ConfigObsoletion rules +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/rule.rb#7 +class RuboCop::ConfigObsoletion::Rule + # @api private + # @return [Rule] a new instance of Rule + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#8 + def initialize(config); end + + # Does this rule relate to cops? + # + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#13 + def cop_rule?; end + + # Does this rule relate to parameters? + # + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#18 + def parameter_rule?; end + + # @api private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#22 + def violated?; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#28 + def config; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#36 + def smart_loaded_path; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#30 + def to_sentence(collection, connector: T.unsafe(nil)); end +end + +# Encapsulation of a ConfigObsoletion rule for splitting a cop's +# functionality into multiple new cops. +# +# @api private +# +# source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#8 +class RuboCop::ConfigObsoletion::SplitCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [SplitCop] a new instance of SplitCop + # + # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#11 + def initialize(config, old_name, metadata); end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#9 + def metadata; end + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#16 + def rule_message; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#22 + def alternatives; end +end + +# This class handles collecting the options for regenerating a TODO file. +# +# @api private +# +# source://rubocop//lib/rubocop/config_regeneration.rb#6 +class RuboCop::ConfigRegeneration + # Get options from the comment in the TODO file, and parse them as options + # + # @api private + # + # source://rubocop//lib/rubocop/config_regeneration.rb#12 + def options; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/config_regeneration.rb#29 + def generation_command; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/config_regeneration.rb#25 + def todo_exists?; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_regeneration.rb#7 +RuboCop::ConfigRegeneration::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/config_regeneration.rb#8 +RuboCop::ConfigRegeneration::COMMAND_REGEX = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop//lib/rubocop/config_regeneration.rb#9 +RuboCop::ConfigRegeneration::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# Handles caching of configurations and association of inspected +# ruby files to configurations. +# +# source://rubocop//lib/rubocop/config_store.rb#6 +class RuboCop::ConfigStore + # @return [ConfigStore] a new instance of ConfigStore + # + # source://rubocop//lib/rubocop/config_store.rb#10 + def initialize; end + + # If type (file/dir) is known beforehand, + # prefer using #for_file or #for_dir for improved performance + # + # source://rubocop//lib/rubocop/config_store.rb#52 + def for(file_or_dir); end + + # source://rubocop//lib/rubocop/config_store.rb#61 + def for_dir(dir); end + + # source://rubocop//lib/rubocop/config_store.rb#42 + def for_file(file); end + + # source://rubocop//lib/rubocop/config_store.rb#46 + def for_pwd; end + + # source://rubocop//lib/rubocop/config_store.rb#33 + def force_default_config!; end + + # source://rubocop//lib/rubocop/config_store.rb#28 + def options_config=(options_config); end + + # source://rubocop//lib/rubocop/config_store.rb#37 + def unvalidated; end + + # Returns the value of attribute validated. + # + # source://rubocop//lib/rubocop/config_store.rb#7 + def validated; end + + # Returns the value of attribute validated. + # + # source://rubocop//lib/rubocop/config_store.rb#7 + def validated?; end +end + +# Handles validation of configuration, for example cop names, parameter +# names, and Ruby versions. +# +# source://rubocop//lib/rubocop/config_validator.rb#8 +class RuboCop::ConfigValidator + extend ::Forwardable + + # @return [ConfigValidator] a new instance of ConfigValidator + # + # source://rubocop//lib/rubocop/config_validator.rb#27 + def initialize(config); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def for_all_cops(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def smart_loaded_path(*args, **_arg1, &block); end + + # source://rubocop//lib/rubocop/config_validator.rb#63 + def target_ruby_version; end + + # source://rubocop//lib/rubocop/config_validator.rb#33 + def validate; end + + # Validations that should only be run after all config resolving has + # taken place: + # * The target ruby version is only checked once the entire inheritance + # chain has been loaded so that only the final value is validated, and + # any obsolete but overridden values are ignored. + # + # source://rubocop//lib/rubocop/config_validator.rb#59 + def validate_after_resolution; end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#67 + def validate_section_presence(name); end + + private + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#104 + def alert_about_unrecognized_cops(invalid_cop_names); end + + # source://rubocop//lib/rubocop/config_validator.rb#253 + def check_cop_config_value(hash, parent = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/config_validator.rb#77 + def check_obsoletions; end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#84 + def check_target_ruby; end + + # source://rubocop//lib/rubocop/config_validator.rb#195 + def each_invalid_parameter(cop_name); end + + # source://rubocop//lib/rubocop/config_validator.rb#120 + def list_unknown_cops(invalid_cop_names); end + + # FIXME: Handling colors in exception messages like this is ugly. + # + # source://rubocop//lib/rubocop/config_validator.rb#266 + def msg_not_boolean(parent, key, value); end + + # source://rubocop//lib/rubocop/config_validator.rb#242 + def reject_conflicting_safe_settings; end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#233 + def reject_mutually_exclusive_defaults; end + + # source://rubocop//lib/rubocop/config_validator.rb#142 + def suggestion(name); end + + # Returns the value of attribute target_ruby. + # + # source://rubocop//lib/rubocop/config_validator.rb#75 + def target_ruby; end + + # source://rubocop//lib/rubocop/config_validator.rb#207 + def validate_enforced_styles(valid_cop_names); end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#169 + def validate_new_cops_parameter; end + + # source://rubocop//lib/rubocop/config_validator.rb#180 + def validate_parameter_names(valid_cop_names); end + + # source://rubocop//lib/rubocop/config_validator.rb#227 + def validate_support_and_has_list(name, formats, valid); end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/config_validator.rb#158 + def validate_syntax_cop; end +end + +# @api private +# +# source://rubocop//lib/rubocop/config_validator.rb#12 +RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/config_validator.rb#22 +RuboCop::ConfigValidator::CONFIG_CHECK_DEPARTMENTS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/config_validator.rb#21 +RuboCop::ConfigValidator::CONFIG_CHECK_KEYS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop//lib/rubocop/config_validator.rb#14 +RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/config_validator.rb#18 +RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/util.rb#4 +module RuboCop::Cop; end + +# This module checks for nodes that should be aligned to the left or right. +# This amount is determined by the instance variable @column_delta. +# +# source://rubocop//lib/rubocop/cop/mixin/alignment.rb#7 +module RuboCop::Cop::Alignment + private + + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#26 + def check_alignment(items, base_column = T.unsafe(nil)); end + + # Returns the value of attribute column_delta. + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#12 + def column_delta; end + + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#14 + def configured_indentation_width; end + + # @api public + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#58 + def display_column(range); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#45 + def each_bad_alignment(items, base_column); end + + # @deprecated Use processed_source.comment_at_line(line) + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#69 + def end_of_line_comment(line); end + + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#18 + def indentation(node); end + + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#22 + def offset(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#74 + def register_offense(offense_node, message_node); end + + # @api public + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#64 + def within?(inner, outer); end +end + +# source://rubocop//lib/rubocop/cop/mixin/alignment.rb#10 +RuboCop::Cop::Alignment::SPACE = T.let(T.unsafe(nil), String) + +# This class does autocorrection of nodes that should just be moved to +# the left or to the right, amount being determined by the instance +# variable column_delta. +# +# source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#8 +class RuboCop::Cop::AlignmentCorrector + extend ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::Alignment + + class << self + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#29 + def align_end(corrector, processed_source, node, align_to); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#15 + def correct(corrector, processed_source, node, column_delta); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#13 + def processed_source; end + + private + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#124 + def alignment_column(align_to); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#40 + def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#81 + def block_comment_within?(expr); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#87 + def calculate_range(expr, line_begin_pos, column_delta); end + + # Some special kinds of string literals are not composed of literal + # characters between two delimiters: + # - The source map of `?a` responds to :begin and :end but its end is + # nil. + # - The source map of `__FILE__` responds to neither :begin nor :end. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#75 + def delimited_string_literal?(node); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#110 + def each_line(expr); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#60 + def inside_string_range(node); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#54 + def inside_string_ranges(node); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#99 + def remove(range, corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#118 + def whitespace_range(node); end + end +end + +# This module encapsulates the ability to allow certain identifiers in a cop. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#6 +module RuboCop::Cop::AllowedIdentifiers + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#9 + def allowed_identifier?(name); end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#13 + def allowed_identifiers; end +end + +# if a variable starts with a sigil it will be removed +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#7 +RuboCop::Cop::AllowedIdentifiers::SIGILS = T.let(T.unsafe(nil), String) + +# This module encapsulates the ability to allow certain methods when +# parsing. Even if the code is in offense, if it contains methods +# that are allowed. This module is equivalent to the IgnoredMethods module, +# which will be deprecated in RuboCop 2.0. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#9 +module RuboCop::Cop::AllowedMethods + private + + # @api public + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#13 + def allowed_method?(name); end + + # @api public + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#21 + def allowed_methods; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#29 + def cop_config_allowed_methods; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#33 + def cop_config_deprecated_values; end + + # @api public + # @deprecated Use allowed_method? instead + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#13 + def ignored_method?(name); end +end + +# This module encapsulates the ability to ignore certain lines when +# parsing. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#7 +module RuboCop::Cop::AllowedPattern + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#10 + def allowed_line?(line); end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#30 + def allowed_patterns; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#46 + def cop_config_deprecated_methods_values; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#40 + def cop_config_patterns_values; end + + # @deprecated Use allowed_line? instead + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#10 + def ignored_line?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#23 + def matches_allowed_pattern?(line); end + + # @deprecated Use matches_allowed_pattern?? instead + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#23 + def matches_ignored_pattern?(line); end +end + +# This module encapsulates the ability to allow certain receivers in a cop. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#6 +module RuboCop::Cop::AllowedReceivers + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#7 + def allowed_receiver?(receiver); end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#29 + def allowed_receivers; end + + # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#13 + def receiver_name(receiver); end +end + +# Error raised when an unqualified cop name is used that could +# refer to two or more cops under different departments +# +# source://rubocop//lib/rubocop/cop/registry.rb#7 +class RuboCop::Cop::AmbiguousCopName < ::RuboCop::Error + # @return [AmbiguousCopName] a new instance of AmbiguousCopName + # + # source://rubocop//lib/rubocop/cop/registry.rb#11 + def initialize(name, origin, badges); end +end + +# source://rubocop//lib/rubocop/cop/registry.rb#8 +RuboCop::Cop::AmbiguousCopName::MSG = T.let(T.unsafe(nil), String) + +# Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`). +# +# source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#6 +class RuboCop::Cop::AnnotationComment + extend ::Forwardable + + # @param comment [Parser::Source::Comment] + # @param keywords [Array] + # @return [AnnotationComment] a new instance of AnnotationComment + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#13 + def initialize(comment, keywords); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#19 + def annotation?; end + + # Returns the range bounds for just the annotation + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#31 + def bounds; end + + # Returns the value of attribute colon. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def colon; end + + # Returns the value of attribute comment. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def comment; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#23 + def correct?(colon:); end + + # Returns the value of attribute keyword. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def keyword; end + + # Returns the value of attribute margin. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def margin; end + + # Returns the value of attribute note. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def note; end + + # Returns the value of attribute space. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#9 + def space; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#67 + def just_keyword_of_sentence?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#63 + def keyword_appearance?; end + + # Returns the value of attribute keywords. + # + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#39 + def keywords; end + + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#53 + def regex; end + + # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#41 + def split_comment(comment); end +end + +# source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#50 +RuboCop::Cop::AnnotationComment::KEYWORDS_REGEX_CACHE = T.let(T.unsafe(nil), Hash) + +# Handles the `MinSize` configuration option for array-based cops +# `Style/SymbolArray` and `Style/WordArray`, which check for use of the +# relevant percent literal syntax such as `%i[...]` and `%w[...]` +# +# source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#8 +module RuboCop::Cop::ArrayMinSize + private + + # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#19 + def array_style_detected(style, ary_size); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#11 + def below_array_length?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#38 + def largest_brackets_size(style, ary_size); end + + # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#15 + def min_size_config; end + + # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#48 + def smallest_percent_size(style, ary_size); end +end + +# Common code for ordinary arrays with [] that can be written with % +# syntax. +# +# source://rubocop//lib/rubocop/cop/mixin/array_syntax.rb#7 +module RuboCop::Cop::ArraySyntax + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/array_syntax.rb#10 + def bracketed_array_of?(element_type, node); end +end + +# extend this module to signal autocorrection support +# +# source://rubocop//lib/rubocop/cop/mixin/auto_corrector.rb#6 +module RuboCop::Cop::AutoCorrector + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/auto_corrector.rb#7 + def support_autocorrect?; end +end + +# This module encapsulates the logic for autocorrect behavior for a cop. +# +# source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#6 +module RuboCop::Cop::AutocorrectLogic + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#7 + def autocorrect?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#31 + def autocorrect_enabled?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#15 + def autocorrect_requested?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#11 + def autocorrect_with_disable_uncorrectable?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#19 + def correctable?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#23 + def disable_uncorrectable?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#27 + def safe_autocorrect?; end + + private + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#46 + def disable_offense(offense_range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#113 + def disable_offense_at_end_of_line(range, eol_comment); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#117 + def disable_offense_before_and_after(range_by_lines); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#56 + def disable_offense_with_eol_or_surround_comment(range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#109 + def max_line_length; end + + # Expand the given range to include all of any lines it covers. Does not + # include newline at end of the last line. + # + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#99 + def range_by_lines(range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#90 + def range_of_first_line(range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#67 + def surrounding_heredoc(offense_range); end + + # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#78 + def surrounding_percent_array(offense_range); end +end + +# Identifier of all cops containing a department and cop name. +# +# All cops are identified by their badge. For example, the badge for +# `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`. +# Badges can be parsed as either `Department/CopName` or just `CopName` to +# allow for badge references in source files that omit the department for +# RuboCop to infer. +# +# source://rubocop//lib/rubocop/cop/badge.rb#12 +class RuboCop::Cop::Badge + # @return [Badge] a new instance of Badge + # + # source://rubocop//lib/rubocop/cop/badge.rb#34 + def initialize(class_name_parts); end + + # source://rubocop//lib/rubocop/cop/badge.rb#41 + def ==(other); end + + # Returns the value of attribute cop_name. + # + # source://rubocop//lib/rubocop/cop/badge.rb#13 + def cop_name; end + + # Returns the value of attribute department. + # + # source://rubocop//lib/rubocop/cop/badge.rb#13 + def department; end + + # Returns the value of attribute department_name. + # + # source://rubocop//lib/rubocop/cop/badge.rb#13 + def department_name; end + + # source://rubocop//lib/rubocop/cop/badge.rb#41 + def eql?(other); end + + # source://rubocop//lib/rubocop/cop/badge.rb#46 + def hash; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/badge.rb#51 + def match?(other); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/badge.rb#59 + def qualified?; end + + # source://rubocop//lib/rubocop/cop/badge.rb#55 + def to_s; end + + # source://rubocop//lib/rubocop/cop/badge.rb#63 + def with_department(department); end + + class << self + # source://rubocop//lib/rubocop/cop/badge.rb#27 + def camel_case(name_part); end + + # source://rubocop//lib/rubocop/cop/badge.rb#15 + def for(class_name); end + + # source://rubocop//lib/rubocop/cop/badge.rb#23 + def parse(identifier); end + end +end + +# A scaffold for concrete cops. +# +# The Cop::Base class is meant to be extended. +# +# Cops track offenses and can autocorrect them on the fly. +# +# A commissioner object is responsible for traversing the AST and invoking +# the specific callbacks on each cop. +# +# First the callback `on_new_investigation` is called; +# if a cop needs to do its own processing of the AST or depends on +# something else. +# +# Then callbacks like `on_def`, `on_send` (see AST::Traversal) are called +# with their respective nodes. +# +# Finally the callback `on_investigation_end` is called. +# +# Within these callbacks, cops are meant to call `add_offense` or +# `add_global_offense`. Use the `processed_source` method to +# get the currently processed source being investigated. +# +# In case of invalid syntax / unparsable content, +# the callback `on_other_file` is called instead of all the other +# `on_...` callbacks. +# +# Private methods are not meant for custom cops consumption, +# nor are any instance variables. +# +# source://rubocop//lib/rubocop/cop/base.rb#34 +class RuboCop::Cop::Base + include ::RuboCop::AST::Sexp + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + include ::RuboCop::Cop::IgnoredNode + include ::RuboCop::Cop::AutocorrectLogic + extend ::RuboCop::AST::Sexp + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::ExcludeLimit + + # @return [Base] a new instance of Base + # + # source://rubocop//lib/rubocop/cop/base.rb#129 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#239 + def active_support_extensions_enabled?; end + + # Adds an offense that has no particular location. + # No correction can be applied to global offenses + # + # source://rubocop//lib/rubocop/cop/base.rb#162 + def add_global_offense(message = T.unsafe(nil), severity: T.unsafe(nil)); end + + # Adds an offense on the specified range (or node with an expression) + # Unless that offense is disabled for this range, a corrector will be yielded + # to provide the cop the opportunity to autocorrect the offense. + # If message is not specified, the method `message` will be called. + # + # source://rubocop//lib/rubocop/cop/base.rb#172 + def add_offense(node_or_range, message: T.unsafe(nil), severity: T.unsafe(nil), &block); end + + # Called before any investigation + # + # @api private + # + # source://rubocop//lib/rubocop/cop/base.rb#295 + def begin_investigation(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/base.rb#280 + def callbacks_needed; end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/cop/base.rb#43 + def config; end + + # source://rubocop//lib/rubocop/cop/base.rb#223 + def config_to_allow_offenses; end + + # source://rubocop//lib/rubocop/cop/base.rb#227 + def config_to_allow_offenses=(hash); end + + # Configuration Helpers + # + # source://rubocop//lib/rubocop/cop/base.rb#217 + def cop_config; end + + # source://rubocop//lib/rubocop/cop/base.rb#209 + def cop_name; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#251 + def excluded_file?(file); end + + # This method should be overridden when a cop's behavior depends + # on state that lives outside of these locations: + # + # (1) the file under inspection + # (2) the cop's source code + # (3) the config (eg a .rubocop.yml file) + # + # For example, some cops may want to look at other parts of + # the codebase being inspected to find violations. A cop may + # use the presence or absence of file `foo.rb` to determine + # whether a certain violation exists in `bar.rb`. + # + # Overriding this method allows the cop to indicate to RuboCop's + # ResultCache system when those external dependencies change, + # ie when the ResultCache should be invalidated. + # + # source://rubocop//lib/rubocop/cop/base.rb#205 + def external_dependency_checksum; end + + # source://rubocop//lib/rubocop/cop/base.rb#308 + def inspect; end + + # Gets called if no message is specified when calling `add_offense` or + # `add_global_offense` + # Cops are discouraged to override this; instead pass your message directly + # + # source://rubocop//lib/rubocop/cop/base.rb#156 + def message(_range = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/base.rb#209 + def name; end + + # @deprecated Make potential errors with previous API more obvious + # + # source://rubocop//lib/rubocop/cop/base.rb#271 + def offenses; end + + # Called after all on_... have been called + # When refining this method, always call `super` + # + # source://rubocop//lib/rubocop/cop/base.rb#143 + def on_investigation_end; end + + # Called before all on_... have been called + # When refining this method, always call `super` + # + # source://rubocop//lib/rubocop/cop/base.rb#137 + def on_new_investigation; end + + # Called instead of all on_... callbacks for unrecognized files / syntax errors + # When refining this method, always call `super` + # + # source://rubocop//lib/rubocop/cop/base.rb#149 + def on_other_file; end + + # There should be very limited reasons for a Cop to do it's own parsing + # + # source://rubocop//lib/rubocop/cop/base.rb#256 + def parse(source, path = T.unsafe(nil)); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/base.rb#43 + def processed_source; end + + # Called between investigations + # + # @api private + # + # source://rubocop//lib/rubocop/cop/base.rb#262 + def ready; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#243 + def relevant_file?(file); end + + # source://rubocop//lib/rubocop/cop/base.rb#235 + def target_rails_version; end + + # source://rubocop//lib/rubocop/cop/base.rb#231 + def target_ruby_version; end + + private + + # source://rubocop//lib/rubocop/cop/base.rb#436 + def annotate(message); end + + # source://rubocop//lib/rubocop/cop/base.rb#320 + def apply_correction(corrector); end + + # @return [Symbol] offense status + # + # source://rubocop//lib/rubocop/cop/base.rb#400 + def attempt_correction(range, corrector); end + + # Reserved for Cop::Cop + # + # source://rubocop//lib/rubocop/cop/base.rb#316 + def callback_argument(range); end + + # Called to complete an investigation + # + # source://rubocop//lib/rubocop/cop/base.rb#349 + def complete_investigation; end + + # @return [Symbol, Corrector] offense status + # + # source://rubocop//lib/rubocop/cop/base.rb#374 + def correct(range); end + + # source://rubocop//lib/rubocop/cop/base.rb#334 + def current_corrector; end + + # Reserved for Commissioner: + # + # source://rubocop//lib/rubocop/cop/base.rb#326 + def current_offense_locations; end + + # source://rubocop//lib/rubocop/cop/base.rb#338 + def current_offenses; end + + # source://rubocop//lib/rubocop/cop/base.rb#330 + def currently_disabled_lines; end + + # source://rubocop//lib/rubocop/cop/base.rb#464 + def custom_severity; end + + # source://rubocop//lib/rubocop/cop/base.rb#460 + def default_severity; end + + # source://rubocop//lib/rubocop/cop/base.rb#414 + def disable_uncorrectable(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#450 + def enabled_line?(line_number); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#442 + def file_name_matches_any?(file, parameter, default_result); end + + # source://rubocop//lib/rubocop/cop/base.rb#432 + def find_message(range, message); end + + # source://rubocop//lib/rubocop/cop/base.rb#456 + def find_severity(_range, severity); end + + # source://rubocop//lib/rubocop/cop/base.rb#477 + def range_for_original(range); end + + # source://rubocop//lib/rubocop/cop/base.rb#421 + def range_from_node_or_range(node_or_range); end + + # source://rubocop//lib/rubocop/cop/base.rb#369 + def reset_investigation; end + + # @return [Symbol] offense status + # + # source://rubocop//lib/rubocop/cop/base.rb#389 + def use_corrector(range, corrector); end + + class << self + # List of cops that should not try to autocorrect at the same + # time as this cop + # + # @api public + # @return [Array] + # + # source://rubocop//lib/rubocop/cop/base.rb#59 + def autocorrect_incompatible_with; end + + # Naming + # + # source://rubocop//lib/rubocop/cop/base.rb#89 + def badge; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/base.rb#285 + def callbacks_needed; end + + # source://rubocop//lib/rubocop/cop/base.rb#93 + def cop_name; end + + # source://rubocop//lib/rubocop/cop/base.rb#97 + def department; end + + # Cops (other than builtin) are encouraged to implement this + # + # @api public + # @return [String, nil] + # + # source://rubocop//lib/rubocop/cop/base.rb#67 + def documentation_url; end + + # Call for abstract Cop classes + # + # source://rubocop//lib/rubocop/cop/base.rb#77 + def exclude_from_registry; end + + # @private + # + # source://rubocop//lib/rubocop/cop/base.rb#71 + def inherited(subclass); end + + # Override and return the Force class(es) you need to join + # + # source://rubocop//lib/rubocop/cop/base.rb#114 + def joining_forces; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#101 + def lint?; end + + # Returns true if the cop name or the cop namespace matches any of the + # given names. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#107 + def match?(given_names); end + + # Returns if class supports autocorrect. + # It is recommended to extend AutoCorrector instead of overriding + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#83 + def support_autocorrect?; end + + # Override if your cop should be called repeatedly for multiple investigations + # Between calls to `on_new_investigation` and `on_investigation_end`, + # the result of `processed_source` will remain constant. + # You should invalidate any caches that depend on the current `processed_source` + # in the `on_new_investigation` callback. + # If your cop does autocorrections, be aware that your instance may be called + # multiple times with the same `processed_source.path` but different content. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#125 + def support_multiple_source?; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/base.rb#360 + def builtin?; end + + # source://rubocop//lib/rubocop/cop/base.rb#342 + def restrict_on_send; end + end +end + +# source://rubocop//lib/rubocop/cop/base.rb#346 +RuboCop::Cop::Base::EMPTY_OFFENSES = T.let(T.unsafe(nil), Array) + +# Reports of an investigation. +# Immutable +# Consider creation API private +# +# source://rubocop//lib/rubocop/cop/base.rb#48 +class RuboCop::Cop::Base::InvestigationReport < ::Struct + # Returns the value of attribute cop + # + # @return [Object] the current value of cop + def cop; end + + # Sets the attribute cop + # + # @param value [Object] the value to set the attribute cop to. + # @return [Object] the newly set value + def cop=(_); end + + # Returns the value of attribute corrector + # + # @return [Object] the current value of corrector + def corrector; end + + # Sets the attribute corrector + # + # @param value [Object] the value to set the attribute corrector to. + # @return [Object] the newly set value + def corrector=(_); end + + # Returns the value of attribute offenses + # + # @return [Object] the current value of offenses + def offenses; end + + # Sets the attribute offenses + # + # @param value [Object] the value to set the attribute offenses to. + # @return [Object] the newly set value + def offenses=(_); end + + # Returns the value of attribute processed_source + # + # @return [Object] the current value of processed_source + def processed_source; end + + # Sets the attribute processed_source + # + # @param value [Object] the value to set the attribute processed_source to. + # @return [Object] the newly set value + def processed_source=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# List of methods names to restrict calls for `on_send` / `on_csend` +# +# source://rubocop//lib/rubocop/cop/base.rb#51 +RuboCop::Cop::Base::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#5 +module RuboCop::Cop::Bundler; end + +# A Gem's requirements should be listed only once in a Gemfile. +# +# @example +# # bad +# gem 'rubocop' +# gem 'rubocop' +# +# # bad +# group :development do +# gem 'rubocop' +# end +# +# group :test do +# gem 'rubocop' +# end +# +# # good +# group :development, :test do +# gem 'rubocop' +# end +# +# # good +# gem 'rubocop', groups: [:development, :test] +# +# # good - conditional declaration +# if Dir.exist?(local) +# gem 'rubocop', path: local +# elsif ENV['RUBOCOP_VERSION'] == 'master' +# gem 'rubocop', git: 'https://github.com/rubocop/rubocop.git' +# else +# gem 'rubocop', '~> 0.90.0' +# end +# +# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#39 +class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#58 + def gem_declarations(param0); end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#45 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#67 + def conditional_declaration?(nodes); end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#60 + def duplicated_gem_nodes; end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#81 + def register_offense(node, gem_name, line_of_first_occurrence); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#75 + def within_conditional?(node, conditional_node); end +end + +# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#42 +RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String) + +# A Gem group, or a set of groups, should be listed only once in a Gemfile. +# +# For example, if the values of `source`, `git`, `platforms`, or `path` +# surrounding `group` are different, no offense will be registered: +# +# [source,ruby] +# ----- +# platforms :ruby do +# group :default do +# gem 'openssl' +# end +# end +# +# platforms :jruby do +# group :default do +# gem 'jruby-openssl' +# end +# end +# ----- +# +# @example +# # bad +# group :development do +# gem 'rubocop' +# end +# +# group :development do +# gem 'rubocop-rails' +# end +# +# # bad (same set of groups declared twice) +# group :development, :test do +# gem 'rubocop' +# end +# +# group :test, :development do +# gem 'rspec' +# end +# +# # good +# group :development do +# gem 'rubocop' +# end +# +# group :development, :test do +# gem 'rspec' +# end +# +# # good +# gem 'rubocop', groups: [:development, :test] +# gem 'rspec', groups: [:development, :test] +# +# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#58 +class RuboCop::Cop::Bundler::DuplicatedGroup < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#66 + def group_declarations(param0); end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#68 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#82 + def duplicated_group_nodes; end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#105 + def find_source_key(node); end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#115 + def group_attributes(node); end + + # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#94 + def register_offense(node, group_name, line_of_first_occurrence); end +end + +# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#61 +RuboCop::Cop::Bundler::DuplicatedGroup::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#63 +RuboCop::Cop::Bundler::DuplicatedGroup::SOURCE_BLOCK_NAMES = T.let(T.unsafe(nil), Array) + +# Each gem in the Gemfile should have a comment explaining +# its purpose in the project, or the reason for its version +# or source. +# +# The optional "OnlyFor" configuration array +# can be used to only register offenses when the gems +# use certain options or have version specifiers. +# +# When "version_specifiers" is included, a comment +# will be enforced if the gem has any version specifier. +# +# When "restrictive_version_specifiers" is included, a comment +# will be enforced if the gem has a version specifier that +# holds back the version of the gem. +# +# For any other value in the array, a comment will be enforced for +# a gem if an option by the same name is present. +# A useful use case is to enforce a comment when using +# options that change the source of a gem: +# +# - `bitbucket` +# - `gist` +# - `git` +# - `github` +# - `source` +# +# For a full list of options supported by bundler, +# see https://bundler.io/man/gemfile.5.html +# . +# +# @example OnlyFor: [] (default) +# # bad +# +# gem 'foo' +# +# # good +# +# # Helpers for the foo things. +# gem 'foo' +# @example OnlyFor: ['version_specifiers'] +# # bad +# +# gem 'foo', '< 2.1' +# +# # good +# +# # Version 2.1 introduces breaking change baz +# gem 'foo', '< 2.1' +# @example OnlyFor: ['restrictive_version_specifiers'] +# # bad +# +# gem 'foo', '< 2.1' +# +# # good +# +# gem 'foo', '>= 1.0' +# +# # Version 2.1 introduces breaking change baz +# gem 'foo', '< 2.1' +# @example OnlyFor: ['version_specifiers', 'github'] +# # bad +# +# gem 'foo', github: 'some_account/some_fork_of_foo' +# +# gem 'bar', '< 2.1' +# +# # good +# +# # Using this fork because baz +# gem 'foo', github: 'some_account/some_fork_of_foo' +# +# # Version 2.1 introduces breaking change baz +# gem 'bar', '< 2.1' +# +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#83 +class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::DefNode + include ::RuboCop::Cop::GemDeclaration + + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#94 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#135 + def checked_options_present?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#109 + def commented?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#105 + def commented_any_descendant?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#159 + def contains_checked_options?(node); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#163 + def gem_options(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#130 + def ignored_gem?(node); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#116 + def precede?(node1, node2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#126 + def preceding_comment?(node1, node2); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#120 + def preceding_lines(node); end + + # Version specifications that restrict all updates going forward. This excludes versions + # like ">= 1.0" or "!= 2.0.3". + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#152 + def restrictive_version_specified_gem?(node); end + + # Besides the gem name, all other *positional* arguments to `gem` are version specifiers, + # as long as it has one we know there's at least one version specifier. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#145 + def version_specified_gem?(node); end +end + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#88 +RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#87 +RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#91 +RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#90 +RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#92 +RuboCop::Cop::Bundler::GemComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#89 +RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) + +# Verifies that a project contains Gemfile or gems.rb file and correct +# associated lock file based on the configuration. +# +# @example EnforcedStyle: Gemfile (default) +# # bad +# Project contains gems.rb and gems.locked files +# +# # bad +# Project contains Gemfile and gems.locked file +# +# # good +# Project contains Gemfile and Gemfile.lock +# @example EnforcedStyle: gems.rb +# # bad +# Project contains Gemfile and Gemfile.lock files +# +# # bad +# Project contains gems.rb and Gemfile.lock file +# +# # good +# Project contains gems.rb and gems.locked files +# +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#28 +class RuboCop::Cop::Bundler::GemFilename < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#43 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#88 + def expected_gemfile?(basename); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#80 + def gemfile_offense?(basename); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#93 + def gemfile_required?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#84 + def gems_rb_offense?(basename); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#97 + def gems_rb_required?; end + + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#58 + def register_gemfile_offense(file_path, basename); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#69 + def register_gems_rb_offense(file_path, basename); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#53 + def register_offense(file_path, basename); end +end + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#40 +RuboCop::Cop::Bundler::GemFilename::GEMFILE_FILES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#41 +RuboCop::Cop::Bundler::GemFilename::GEMS_RB_FILES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#36 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_MISMATCHED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#32 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_REQUIRED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#38 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_MISMATCHED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#34 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_REQUIRED = T.let(T.unsafe(nil), String) + +# Enforce that Gem version specifications or a commit reference (branch, +# ref, or tag) are either required or forbidden. +# +# @example EnforcedStyle: required (default) +# # bad +# gem 'rubocop' +# +# # good +# gem 'rubocop', '~> 1.12' +# +# # good +# gem 'rubocop', '>= 1.10.0' +# +# # good +# gem 'rubocop', '>= 1.5.0', '< 1.10.0' +# +# # good +# gem 'rubocop', branch: 'feature-branch' +# +# # good +# gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b' +# +# # good +# gem 'rubocop', tag: 'v1.17.0' +# @example EnforcedStyle: forbidden +# # good +# gem 'rubocop' +# +# # bad +# gem 'rubocop', '~> 1.12' +# +# # bad +# gem 'rubocop', '>= 1.10.0' +# +# # bad +# gem 'rubocop', '>= 1.5.0', '< 1.10.0' +# +# # bad +# gem 'rubocop', branch: 'feature-branch' +# +# # bad +# gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b' +# +# # bad +# gem 'rubocop', tag: 'v1.17.0' +# +# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#53 +class RuboCop::Cop::Bundler::GemVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::GemDeclaration + + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#67 + def includes_commit_reference?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#62 + def includes_version_specification?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#85 + def allowed_gem?(node); end + + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#89 + def allowed_gems; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#113 + def forbidden_offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#119 + def forbidden_style?; end + + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#93 + def message(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#103 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#107 + def required_offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#123 + def required_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#127 + def version_specification?(expression); end +end + +# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#58 +RuboCop::Cop::Bundler::GemVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#57 +RuboCop::Cop::Bundler::GemVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#59 +RuboCop::Cop::Bundler::GemVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp) + +# Passing symbol arguments to `source` (e.g. `source :rubygems`) is +# deprecated because they default to using HTTP requests. Instead, specify +# `'https://rubygems.org'` if possible, or `'http://rubygems.org'` if not. +# +# When autocorrecting, this cop will replace symbol arguments with +# `'https://rubygems.org'`. +# +# This cop will not replace existing sources that use `http://`. This may +# be necessary where HTTPS is not available. For example, where using an +# internal gem server via an intranet, or where HTTPS is prohibited. +# However, you should strongly prefer `https://` where possible, as it is +# more secure. +# +# If you don't allow `http://`, please set `false` to `AllowHttpProtocol`. +# This option is `true` by default for safe autocorrection. +# +# @example +# # bad +# source :gemcutter +# source :rubygems +# source :rubyforge +# +# # good +# source 'https://rubygems.org' # strongly recommended +# @example AllowHttpProtocol: true (default) +# +# # good +# source 'http://rubygems.org' # use only if HTTPS is unavailable +# @example AllowHttpProtocol: false +# +# # bad +# source 'http://rubygems.org' +# +# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#41 +class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#54 + def insecure_protocol_source?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#59 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#80 + def allow_http_protocol?; end +end + +# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#45 +RuboCop::Cop::Bundler::InsecureProtocolSource::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#49 +RuboCop::Cop::Bundler::InsecureProtocolSource::MSG_HTTP_PROTOCOL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#51 +RuboCop::Cop::Bundler::InsecureProtocolSource::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Gems should be alphabetically sorted within groups. +# +# @example +# # bad +# gem 'rubocop' +# gem 'rspec' +# +# # good +# gem 'rspec' +# gem 'rubocop' +# +# # good +# gem 'rubocop' +# +# gem 'rspec' +# @example TreatCommentsAsGroupSeparators: true (default) +# # good +# # For code quality +# gem 'rubocop' +# # For tests +# gem 'rspec' +# @example TreatCommentsAsGroupSeparators: false +# # bad +# # For code quality +# gem 'rubocop' +# # For tests +# gem 'rspec' +# +# source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#35 +class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#64 + def gem_declarations(param0); end + + # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#43 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#57 + def previous_declaration(node); end +end + +# source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#39 +RuboCop::Cop::Bundler::OrderedGems::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking assignment nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#6 +module RuboCop::Cop::CheckAssignment + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#19 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#29 + def extract_rhs(node); end + + class << self + # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#29 + def extract_rhs(node); end + end +end + +# This mixin detects collections that are safe to "break" +# by inserting new lines. This is useful for breaking +# up long lines. +# +# Let's look at hashes as an example: +# +# We know hash keys are safe to break across lines. We can add +# linebreaks into hashes on lines longer than the specified maximum. +# Then in further passes cops can clean up the multi-line hash. +# For example, say the maximum line length is as indicated below: +# +# | +# v +# {foo: "0000000000", bar: "0000000000", baz: "0000000000"} +# +# In a LineLength autocorrection pass, a line is added before +# the first key that exceeds the column limit: +# +# {foo: "0000000000", bar: "0000000000", +# baz: "0000000000"} +# +# In a MultilineHashKeyLineBreaks pass, lines are inserted +# before all keys: +# +# {foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000"} +# +# Then in future passes FirstHashElementLineBreak, +# MultilineHashBraceLayout, and TrailingCommaInHashLiteral will +# manipulate as well until we get: +# +# { +# foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000", +# } +# +# (Note: Passes may not happen exactly in this sequence.) +# +# source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#44 +module RuboCop::Cop::CheckLineBreakable + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#45 + def extract_breakable_node(node, max); end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#200 + def all_on_same_line?(nodes); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#220 + def already_on_multiple_lines?(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#133 + def breakable_collection?(node, elements); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#187 + def children_could_be_broken_up?(children); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#150 + def contained_by_breakable_collection_on_same_line?(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#170 + def contained_by_multiline_collection_that_could_be_broken_up?(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#60 + def extract_breakable_node_from_elements(node, elements, max); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#72 + def extract_first_element_over_column_limit(node, elements, max); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#92 + def first_argument_is_heredoc?(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#207 + def process_args(args); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#117 + def safe_to_ignore?(node); end + + # If a send node contains a heredoc argument, splitting cannot happen + # after the heredoc or else it will cause a syntax error. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#101 + def shift_elements_for_heredoc_arg(node, elements, index); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#112 + def within_column_limit?(element, max, line); end +end + +# Common functionality for checking length of code segments. +# +# source://rubocop//lib/rubocop/cop/mixin/code_length.rb#6 +module RuboCop::Cop::CodeLength + extend ::RuboCop::ExcludeLimit + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#49 + def build_code_length_calculator(node); end + + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#31 + def check_code_length(node); end + + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#27 + def count_as_one; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#23 + def count_comments?; end + + # Returns true for lines that shall not be included in the count. + # + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#45 + def irrelevant_line(source_line); end + + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#19 + def max_length; end + + # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#15 + def message(length, max_length); end +end + +# source://rubocop//lib/rubocop/cop/mixin/code_length.rb#9 +RuboCop::Cop::CodeLength::MSG = T.let(T.unsafe(nil), String) + +# Help methods for working with nodes containing comments. +# +# source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#6 +module RuboCop::Cop::CommentsHelp + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#25 + def comments_contain_disables?(node, cop_name); end + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#18 + def comments_in_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#14 + def contains_comments?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#7 + def source_range_with_comment(node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#44 + def begin_pos_with_comment(node); end + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#58 + def buffer; end + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#39 + def end_position_for(node); end + + # Returns the end line of a node, which might be a comment and not part of the AST + # End line is considered either the line at which another node starts, or + # the line at which the parent node ends. + # + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#66 + def find_end_line(node); end + + # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#54 + def start_line_position(node); end +end + +# Commissioner class is responsible for processing the AST and delegating +# work to the specified cops. +# +# source://rubocop//lib/rubocop/cop/commissioner.rb#7 +class RuboCop::Cop::Commissioner + include ::RuboCop::AST::Traversal + + # @return [Commissioner] a new instance of Commissioner + # + # source://rubocop//lib/rubocop/cop/commissioner.rb#44 + def initialize(cops, forces = T.unsafe(nil), options = T.unsafe(nil)); end + + # Returns the value of attribute errors. + # + # source://rubocop//lib/rubocop/cop/commissioner.rb#42 + def errors; end + + # @return [InvestigationReport] + # + # source://rubocop//lib/rubocop/cop/commissioner.rb#79 + def investigate(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on___ENCODING__(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on___FILE__(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on___LINE__(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_alias(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_arg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_arg_expr(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_args(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_array_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_array_pattern_with_tail(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_back_ref(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_block_pass(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_blockarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_break(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_cbase(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_complex(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_const(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_const_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_cvar(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_defined?(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_dstr(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_dsym(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_eflipflop(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_empty_else(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_ensure(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_false(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_find_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_float(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_forward_arg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_forward_args(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_forwarded_args(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_forwarded_kwrestarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_forwarded_restarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_gvar(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_hash_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_if_guard(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_iflipflop(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_in_match(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_in_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_index(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_indexasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_int(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_irange(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_ivar(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwargs(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwbegin(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwnilarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwoptarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwrestarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_kwsplat(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_lambda(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_lvar(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_alt(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_as(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_current_line(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_nil_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_pattern(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_pattern_p(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_rest(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_var(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_with_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_match_with_trailing_comma(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_mlhs(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_next(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_nil(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_not(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_nth_ref(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_optarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_pair(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_pin(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_postexe(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_preexe(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_procarg0(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_rational(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_redo(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_regexp(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_regopt(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_rescue(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_restarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_retry(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_return(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_self(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_shadowarg(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_splat(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_str(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_super(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_sym(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_true(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_undef(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_unless_guard(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_when(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_while_post(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_xstr(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_yield(node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#68 + def on_zsuper(node); end + + private + + # source://rubocop//lib/rubocop/cop/commissioner.rb#98 + def begin_investigation(processed_source, offset:, original:); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#121 + def build_callbacks(cops); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#116 + def initialize_callbacks; end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#159 + def invoke(callback, cops); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#163 + def invoke_with_argument(callback, cops, arg); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#112 + def reset; end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#131 + def restrict_callbacks(callbacks); end + + # NOTE: mutates `callbacks` in place + # + # source://rubocop//lib/rubocop/cop/commissioner.rb#149 + def restricted_map(callbacks); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#104 + def trigger_responding_cops(callback, node); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#139 + def trigger_restricted_cops(event, node); end + + # Allow blind rescues here, since we're absorbing and packaging or + # re-raising exceptions that can be raised from within the individual + # cops' `#investigate` methods. + # + # source://rubocop//lib/rubocop/cop/commissioner.rb#170 + def with_cop_error_handling(cop, node = T.unsafe(nil)); end +end + +# How a Commissioner returns the results of the investigation +# as a list of Cop::InvestigationReport and any errors caught +# during the investigation. +# Immutable +# Consider creation API private +# +# source://rubocop//lib/rubocop/cop/commissioner.rb#18 +class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct + # Returns the value of attribute cop_reports + # + # @return [Object] the current value of cop_reports + def cop_reports; end + + # Sets the attribute cop_reports + # + # @param value [Object] the value to set the attribute cop_reports to. + # @return [Object] the newly set value + def cop_reports=(_); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#19 + def cops; end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#27 + def correctors; end + + # Returns the value of attribute errors + # + # @return [Object] the current value of errors + def errors; end + + # Sets the attribute errors + # + # @param value [Object] the value to set the attribute errors to. + # @return [Object] the newly set value + def errors=(_); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#35 + def merge(investigation); end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#31 + def offenses; end + + # source://rubocop//lib/rubocop/cop/commissioner.rb#23 + def offenses_per_cop; end + + # Returns the value of attribute processed_source + # + # @return [Object] the current value of processed_source + def processed_source; end + + # Sets the attribute processed_source + # + # @param value [Object] the value to set the attribute processed_source to. + # @return [Object] the newly set value + def processed_source=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/cop/commissioner.rb#10 +RuboCop::Cop::Commissioner::RESTRICTED_CALLBACKS = T.let(T.unsafe(nil), Array) + +# This class does condition autocorrection +# +# source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#6 +class RuboCop::Cop::ConditionCorrector + class << self + # source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#8 + def correct_negative_condition(corrector, node); end + + private + + # source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#17 + def negated_condition(node); end + end +end + +# Handles `EnforcedStyle` configuration parameters. +# +# source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#6 +module RuboCop::Cop::ConfigurableEnforcedStyle + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#88 + def alternative_style; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#96 + def alternative_styles; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#19 + def ambiguous_style_detected(*possibilities); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60 + def conflicting_styles_detected; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#11 + def correct_style_detected; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#64 + def detected_style; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#68 + def detected_style=(style); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60 + def no_acceptable_style!; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#56 + def no_acceptable_style?; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#7 + def opposite_style_detected; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#79 + def style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#75 + def style_configured?; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#29 + def style_detected(detected); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#107 + def style_parameter_name; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#100 + def supported_styles; end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#15 + def unexpected_style_detected(unexpected); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60 + def unrecognized_style_detected; end +end + +# source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#23 +RuboCop::Cop::ConfigurableEnforcedStyle::SYMBOL_TO_STRING_CACHE = T.let(T.unsafe(nil), Hash) + +# Shared functionality between mixins that enforce naming conventions +# +# source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#6 +module RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#9 + def check_name(node, name, name_range); end + + # A class emitter method is a singleton method in a class/module, where + # the method has the same name as a class defined in the class/module. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#29 + def class_emitter_method?(node, name); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#17 + def report_opposing_styles(node, name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#23 + def valid_name?(node, name, given_style = T.unsafe(nil)); end +end + +# Handles `Max` configuration parameters, especially setting them to an +# appropriate value with --auto-gen-config. +# +# @deprecated Use `exclude_limit ParameterName` instead. +# +# source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#8 +module RuboCop::Cop::ConfigurableMax + private + + # source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#11 + def max=(value); end + + # source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#19 + def max_parameter_name; end +end + +# This module provides functionality for checking if names match the +# configured EnforcedStyle. +# +# source://rubocop//lib/rubocop/cop/mixin/configurable_naming.rb#7 +module RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting +end + +# source://rubocop//lib/rubocop/cop/mixin/configurable_naming.rb#10 +RuboCop::Cop::ConfigurableNaming::FORMATS = T.let(T.unsafe(nil), Hash) + +# This module provides functionality for checking if numbering match the +# configured EnforcedStyle. +# +# source://rubocop//lib/rubocop/cop/mixin/configurable_numbering.rb#7 +module RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting +end + +# source://rubocop//lib/rubocop/cop/mixin/configurable_numbering.rb#11 +RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash) + +# Monkey-patch Cop for tests to provide easy access to messages and +# highlights. +# +# source://rubocop//lib/rubocop/cop/cop.rb#11 +class RuboCop::Cop::Cop < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/cop.rb#53 + def add_offense(node_or_range, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil), &block); end + + # Called before any investigation + # + # @api private + # + # source://rubocop//lib/rubocop/cop/cop.rb#103 + def begin_investigation(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end + + # @deprecated + # + # source://rubocop//lib/rubocop/cop/cop.rb#82 + def corrections; end + + # source://rubocop//lib/rubocop/cop/cop.rb#70 + def find_location(node, loc); end + + # Returns the value of attribute offenses. + # + # source://rubocop//lib/rubocop/cop/cop.rb#12 + def offenses; end + + # Called after all on_... have been called + # + # source://rubocop//lib/rubocop/cop/cop.rb#96 + def on_investigation_end; end + + # Called before all on_... have been called + # + # source://rubocop//lib/rubocop/cop/cop.rb#90 + def on_new_investigation; end + + # @deprecated Use class method + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/cop.rb#76 + def support_autocorrect?; end + + private + + # source://rubocop//lib/rubocop/cop/cop.rb#121 + def apply_correction(corrector); end + + # Override Base + # + # source://rubocop//lib/rubocop/cop/cop.rb#117 + def callback_argument(_range); end + + # source://rubocop//lib/rubocop/cop/cop.rb#138 + def correction_lambda; end + + # source://rubocop//lib/rubocop/cop/cop.rb#144 + def dedupe_on_node(node); end + + # Just for legacy + # + # @yield [corrector] + # + # source://rubocop//lib/rubocop/cop/cop.rb#126 + def emulate_v0_callsequence(corrector); end + + # source://rubocop//lib/rubocop/cop/cop.rb#157 + def range_for_original(range); end + + # source://rubocop//lib/rubocop/cop/cop.rb#151 + def suppress_clobbering; end + + class << self + # @deprecated Use Registry.all + # + # source://rubocop//lib/rubocop/cop/cop.rb#44 + def all; end + + # source://rubocop//lib/rubocop/cop/cop.rb#29 + def joining_forces; end + + # @deprecated Use Registry.qualified_cop_name + # + # source://rubocop//lib/rubocop/cop/cop.rb#49 + def qualified_cop_name(name, origin); end + + # @deprecated Use Registry.global + # + # source://rubocop//lib/rubocop/cop/cop.rb#39 + def registry; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/cop.rb#25 + def support_autocorrect?; end + end +end + +# @deprecated +# +# source://rubocop//lib/rubocop/cop/cop.rb#17 +class RuboCop::Cop::Cop::Correction < ::Struct + # source://rubocop//lib/rubocop/cop/cop.rb#18 + def call(corrector); end + + # Returns the value of attribute cop + # + # @return [Object] the current value of cop + def cop; end + + # Sets the attribute cop + # + # @param value [Object] the value to set the attribute cop to. + # @return [Object] the newly set value + def cop=(_); end + + # Returns the value of attribute lambda + # + # @return [Object] the current value of lambda + def lambda; end + + # Sets the attribute lambda + # + # @param value [Object] the value to set the attribute lambda to. + # @return [Object] the newly set value + def lambda=(_); end + + # Returns the value of attribute node + # + # @return [Object] the current value of node + def node; end + + # Sets the attribute node + # + # @param value [Object] the value to set the attribute node to. + # @return [Object] the newly set value + def node=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# This class takes a source buffer and rewrite its source +# based on the different correction rules supplied. +# +# Important! +# The nodes modified by the corrections should be part of the +# AST of the source_buffer. +# +# source://rubocop//lib/rubocop/cop/corrector.rb#11 +class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter + # corrector = Corrector.new(cop) + # + # @param source [Parser::Source::Buffer, or anything + # leading to one via `(processed_source.)buffer`] + # @return [Corrector] a new instance of Corrector + # + # source://rubocop//lib/rubocop/cop/corrector.rb#32 + def initialize(source); end + + # Removes `size` characters from the beginning of the given range. + # If `size` is greater than the size of `range`, the removed region can + # overrun the end of `range`. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop//lib/rubocop/cop/corrector.rb#63 + def remove_leading(node_or_range, size); end + + # Removes `size` characters prior to the source range. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop//lib/rubocop/cop/corrector.rb#51 + def remove_preceding(node_or_range, size); end + + # Removes `size` characters from the end of the given range. + # If `size` is greater than the size of `range`, the removed region can + # overrun the beginning of `range`. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop//lib/rubocop/cop/corrector.rb#75 + def remove_trailing(node_or_range, size); end + + # Legacy + # + # source://parser/3.3.0.1/lib/parser/source/tree_rewriter.rb#252 + def rewrite; end + + # Swaps sources at the given ranges. + # + # @param node_or_range1 [Parser::Source::Range, RuboCop::AST::Node] + # @param node_or_range2 [Parser::Source::Range, RuboCop::AST::Node] + # + # source://rubocop//lib/rubocop/cop/corrector.rb#85 + def swap(node_or_range1, node_or_range2); end + + private + + # source://rubocop//lib/rubocop/cop/corrector.rb#119 + def check_range_validity(node_or_range); end + + # source://rubocop//lib/rubocop/cop/corrector.rb#104 + def to_range(node_or_range); end + + # source://rubocop//lib/rubocop/cop/corrector.rb#123 + def validate_buffer(buffer); end + + class << self + # Duck typing for get to a ::Parser::Source::Buffer + # + # source://rubocop//lib/rubocop/cop/corrector.rb#15 + def source_buffer(source); end + end +end + +# noop +# +# source://rubocop//lib/rubocop/cop/corrector.rb#12 +RuboCop::Cop::Corrector::NOOP_CONSUMER = T.let(T.unsafe(nil), Proc) + +# Common functionality for checking def nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/def_node.rb#6 +module RuboCop::Cop::DefNode + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#21 + def non_public_modifier?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#12 + def non_public?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#16 + def preceding_non_public_modifier?(node); end +end + +# Helpers for builtin documentation +# +# source://rubocop//lib/rubocop/cop/documentation.rb#6 +module RuboCop::Cop::Documentation + private + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#24 + def base_url_for(cop_class, config); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#34 + def default_base_url; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#10 + def department_to_basename(department); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#15 + def url_for(cop_class, config = T.unsafe(nil)); end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#24 + def base_url_for(cop_class, config); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#34 + def default_base_url; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#10 + def department_to_basename(department); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/documentation.rb#15 + def url_for(cop_class, config = T.unsafe(nil)); end + end +end + +# Common functionality for checking documentation. +# +# source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#6 +module RuboCop::Cop::DocumentationComment + extend ::RuboCop::AST::NodePattern::Macros + + private + + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#47 + def annotation_keywords; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#11 + def documentation_comment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#39 + def interpreter_directive_comment?(comment); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#31 + def precede?(node1, node2); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#25 + def preceding_comment?(node1, node2); end + + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#35 + def preceding_lines(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#43 + def rubocop_directive_comment?(comment); end +end + +# Common functionality for dealing with duplication. +# +# source://rubocop//lib/rubocop/cop/mixin/duplication.rb#6 +module RuboCop::Cop::Duplication + private + + # Returns the consecutive duplicates, leaving out the first instance of + # the duplicated elements. + # + # @param collection [Array] an array to return consecutive duplicates for + # @return [Array] the consecutive duplicates + # + # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#31 + def consecutive_duplicates(collection); end + + # Returns all duplicates, including the first instance of the duplicated + # elements. + # + # @param collection [Array] an array to return duplicates for + # @return [Array] all the duplicates + # + # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#22 + def duplicates(collection); end + + # Whether the `collection` contains any duplicates. + # + # @param collection [Array] an array to check for duplicates + # @return [Boolean] whether the array contains any duplicates + # + # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#13 + def duplicates?(collection); end + + # Returns a hash of grouped duplicates. The key will be the first + # instance of the element, and the value an `array` of the initial + # element and all duplicate instances. + # + # @param collection [Array] an array to group duplicates for + # @return [Array] the grouped duplicates + # + # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#41 + def grouped_duplicates(collection); end +end + +# This class autocorrects `#each` enumeration to `for` iteration. +# +# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#6 +class RuboCop::Cop::EachToForCorrector + extend ::RuboCop::AST::NodePattern::Macros + + # @return [EachToForCorrector] a new instance of EachToForCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#12 + def initialize(block_node); end + + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#18 + def call(corrector); end + + private + + # Returns the value of attribute argument_node. + # + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24 + def argument_node; end + + # Returns the value of attribute block_node. + # + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24 + def block_node; end + + # Returns the value of attribute collection_node. + # + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24 + def collection_node; end + + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#26 + def correction; end + + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#36 + def offending_range; end + + # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#44 + def replacement_range(end_pos); end +end + +# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#10 +RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#9 +RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String) + +# This class does empty line autocorrection +# +# source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#6 +class RuboCop::Cop::EmptyLineCorrector + class << self + # source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#8 + def correct(corrector, node); end + + # source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#19 + def insert_before(corrector, node); end + end +end + +# Common code for empty parameter cops. +# +# source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#6 +module RuboCop::Cop::EmptyParameter + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#12 + def empty_arguments?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#16 + def check(node); end +end + +# Functions for checking the alignment of the `end` keyword. +# +# source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#6 +module RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#60 + def accept_end_kw_alignment?(end_loc); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#50 + def add_offense_for_misalignment(node, align_with); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#19 + def check_end_kw_alignment(node, align_ranges); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#15 + def check_end_kw_in_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#75 + def line_break_before_keyword?(whole_expression, rhs); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#35 + def matching_ranges(end_loc, align_ranges); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#41 + def start_line_range(node); end + + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#65 + def style_parameter_name; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#69 + def variable_alignment?(whole_expression, rhs, end_alignment_style); end +end + +# source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#10 +RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for enforcing a specific superclass. +# +# IMPORTANT: RuboCop core depended on this module when it supported Rails department. +# Rails department has been extracted to RuboCop Rails gem. +# +# It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility +# with existing RuboCop Rails 2.8 or lower. +# +# @api private +# @deprecated This module is deprecated and will be removed by RuboCop 2.0. +# +# source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#15 +module RuboCop::Cop::EnforceSuperclass + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#35 + def on_class(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#39 + def on_send(node); end + + class << self + # @api private + # @private + # + # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#16 + def included(base); end + end +end + +# Common functionality for checking for a line break before the first +# element in a multi-line collection. +# +# source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#7 +module RuboCop::Cop::FirstElementLineBreak + private + + # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#23 + def check_children_line_break(node, children, start = T.unsafe(nil), ignore_last: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#10 + def check_method_line_break(node, children, ignore_last: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#37 + def first_by_line(nodes); end + + # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#41 + def last_line(nodes, ignore_last:); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#18 + def method_uses_parens?(node, limit); end +end + +# This class autocorrects `for` iteration to `#each` enumeration. +# +# source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#6 +class RuboCop::Cop::ForToEachCorrector + extend ::RuboCop::AST::NodePattern::Macros + + # @return [ForToEachCorrector] a new instance of ForToEachCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#11 + def initialize(for_node); end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#17 + def call(corrector); end + + private + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#55 + def collection_end; end + + # Returns the value of attribute collection_node. + # + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#23 + def collection_node; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#29 + def collection_source; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#25 + def correction; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#43 + def end_position; end + + # Returns the value of attribute for_node. + # + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#23 + def for_node; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#51 + def keyword_begin; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#63 + def offending_range; end + + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#67 + def replacement_range(end_pos); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#37 + def requires_parentheses?; end + + # Returns the value of attribute variable_node. + # + # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#23 + def variable_node; end +end + +# source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#9 +RuboCop::Cop::ForToEachCorrector::CORRECTION = T.let(T.unsafe(nil), String) + +# A scaffold for concrete forces. +# +# source://rubocop//lib/rubocop/cop/force.rb#6 +class RuboCop::Cop::Force + # @return [Force] a new instance of Force + # + # source://rubocop//lib/rubocop/cop/force.rb#22 + def initialize(cops); end + + # Returns the value of attribute cops. + # + # source://rubocop//lib/rubocop/cop/force.rb#7 + def cops; end + + # source://rubocop//lib/rubocop/cop/force.rb#38 + def investigate(_processed_source); end + + # source://rubocop//lib/rubocop/cop/force.rb#26 + def name; end + + # source://rubocop//lib/rubocop/cop/force.rb#30 + def run_hook(method_name, *args); end + + class << self + # source://rubocop//lib/rubocop/cop/force.rb#9 + def all; end + + # source://rubocop//lib/rubocop/cop/force.rb#18 + def force_name; end + + # @private + # + # source://rubocop//lib/rubocop/cop/force.rb#13 + def inherited(subclass); end + end +end + +# Common functionality for dealing with frozen string literals. +# +# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#6 +module RuboCop::Cop::FrozenStringLiteral + private + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#35 + def frozen_heredoc?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#21 + def frozen_string_literal?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#15 + def frozen_string_literal_comment_exists?; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#66 + def frozen_string_literal_specified?; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#60 + def frozen_string_literals_disabled?; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#41 + def frozen_string_literals_enabled?; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#76 + def leading_comment_lines; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#72 + def leading_magic_comments; end + + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#31 + def uninterpolated_string?(node); end + + class << self + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#15 + def frozen_string_literal_comment_exists?; end + end +end + +# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#9 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#10 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_ENABLED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#11 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_TYPES_RUBY27 = T.let(T.unsafe(nil), Array) + +# Common functionality for checking gem declarations. +# +# source://rubocop//lib/rubocop/cop/mixin/gem_declaration.rb#6 +module RuboCop::Cop::GemDeclaration + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/gem_declaration.rb#10 + def gem_declaration?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#5 +module RuboCop::Cop::Gemspec; end + +# Enforce that gem dependency version specifications or a commit reference (branch, +# ref, or tag) are either required or forbidden. +# +# @example EnforcedStyle: required (default) +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# @example EnforcedStyle: forbidden +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser' +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#53 +class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#67 + def add_dependency_method_declaration?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#78 + def includes_commit_reference?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#73 + def includes_version_specification?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#82 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#120 + def add_dependency_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#96 + def allowed_gem?(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#100 + def allowed_gems; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#134 + def forbidden_offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#140 + def forbidden_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#114 + def match_block_variable_name?(receiver_name); end + + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#104 + def message(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#124 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#128 + def required_offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#144 + def required_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#148 + def version_specification?(expression); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#61 +RuboCop::Cop::Gemspec::DependencyVersion::ADD_DEPENDENCY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#58 +RuboCop::Cop::Gemspec::DependencyVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#57 +RuboCop::Cop::Gemspec::DependencyVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#64 +RuboCop::Cop::Gemspec::DependencyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#59 +RuboCop::Cop::Gemspec::DependencyVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks that deprecated attributes are not set in a gemspec file. +# Removing deprecated attributes allows the user to receive smaller packed gems. +# +# @example +# +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# spec.test_files = Dir.glob('test/**/*') +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# spec.test_files += Dir.glob('test/**/*') +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#28 +class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#35 + def gem_specification(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#43 + def on_block(block_node); end + + private + + # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#86 + def format_message_from; end + + # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#63 + def node_and_method_name(node, attribute); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#72 + def use_deprecated_attributes?(node, block_parameter); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#32 +RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::MSG = T.let(T.unsafe(nil), String) + +# Enforce that development dependencies for a gem are specified in +# `Gemfile`, rather than in the `gemspec` using +# `add_development_dependency`. Alternatively, using `EnforcedStyle: +# gemspec`, enforce that all dependencies are specified in `gemspec`, +# rather than in `Gemfile`. +# +# @example EnforcedStyle: Gemfile (default) +# # Specify runtime dependencies in your gemspec, +# # but all other dependencies in your Gemfile. +# +# # bad +# # example.gemspec +# s.add_development_dependency "foo" +# +# # good +# # Gemfile +# gem "foo" +# +# # good +# # gems.rb +# gem "foo" +# +# # good (with AllowedGems: ["bar"]) +# # example.gemspec +# s.add_development_dependency "bar" +# @example EnforcedStyle: gems.rb +# # Specify runtime dependencies in your gemspec, +# # but all other dependencies in your Gemfile. +# # +# # Identical to `EnforcedStyle: Gemfile`, but with a different error message. +# # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`. +# +# # bad +# # example.gemspec +# s.add_development_dependency "foo" +# +# # good +# # Gemfile +# gem "foo" +# +# # good +# # gems.rb +# gem "foo" +# +# # good (with AllowedGems: ["bar"]) +# # example.gemspec +# s.add_development_dependency "bar" +# @example EnforcedStyle: gemspec +# # Specify all dependencies in your gemspec. +# +# # bad +# # Gemfile +# gem "foo" +# +# # good +# # example.gemspec +# s.add_development_dependency "foo" +# +# # good (with AllowedGems: ["bar"]) +# # Gemfile +# gem "bar" +# +# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#70 +class RuboCop::Cop::Gemspec::DevelopmentDependencies < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#77 + def add_development_dependency?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#82 + def gem?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#86 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#97 + def forbidden_gem?(gem_name); end + + # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#101 + def message(_range); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#73 +RuboCop::Cop::Gemspec::DevelopmentDependencies::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#74 +RuboCop::Cop::Gemspec::DevelopmentDependencies::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# An attribute assignment method calls should be listed only once +# in a gemspec. +# +# Assigning to an attribute with the same name using `spec.foo =` will be +# an unintended usage. On the other hand, duplication of methods such +# as `spec.requirements`, `spec.add_runtime_dependency`, and others are +# permitted because it is the intended use of appending values. +# +# @example +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'rubocop' +# spec.name = 'rubocop2' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.name = 'rubocop' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.requirements << 'libmagick, v6.0' +# spec.requirements << 'A good graphics card' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_runtime_dependency('parallel', '~> 1.10') +# spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0') +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#37 +class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#45 + def assignment_method_declarations(param0); end + + # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#50 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#68 + def duplicated_assignment_method_nodes; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#62 + def match_block_variable_name?(receiver_name); end + + # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#76 + def register_offense(node, assignment, line_of_first_occurrence); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#41 +RuboCop::Cop::Gemspec::DuplicatedAssignment::MSG = T.let(T.unsafe(nil), String) + +# Dependencies in the gemspec should be alphabetically sorted. +# +# @example +# # bad +# spec.add_dependency 'rubocop' +# spec.add_dependency 'rspec' +# +# # good +# spec.add_dependency 'rspec' +# spec.add_dependency 'rubocop' +# +# # good +# spec.add_dependency 'rubocop' +# +# spec.add_dependency 'rspec' +# +# # bad +# spec.add_development_dependency 'rubocop' +# spec.add_development_dependency 'rspec' +# +# # good +# spec.add_development_dependency 'rspec' +# spec.add_development_dependency 'rubocop' +# +# # good +# spec.add_development_dependency 'rubocop' +# +# spec.add_development_dependency 'rspec' +# +# # bad +# spec.add_runtime_dependency 'rubocop' +# spec.add_runtime_dependency 'rspec' +# +# # good +# spec.add_runtime_dependency 'rspec' +# spec.add_runtime_dependency 'rubocop' +# +# # good +# spec.add_runtime_dependency 'rubocop' +# +# spec.add_runtime_dependency 'rspec' +# @example TreatCommentsAsGroupSeparators: true (default) +# # good +# # For code quality +# spec.add_dependency 'rubocop' +# # For tests +# spec.add_dependency 'rspec' +# @example TreatCommentsAsGroupSeparators: false +# # bad +# # For code quality +# spec.add_dependency 'rubocop' +# # For tests +# spec.add_dependency 'rspec' +# +# source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#61 +class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#95 + def dependency_declarations(param0); end + + # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#69 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#90 + def get_dependency_name(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#84 + def previous_declaration(node); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#65 +RuboCop::Cop::Gemspec::OrderedDependencies::MSG = T.let(T.unsafe(nil), String) + +# Requires a gemspec to have `rubygems_mfa_required` metadata set. +# +# This setting tells RubyGems that MFA (Multi-Factor Authentication) is +# required for accounts to be able perform privileged operations, such as +# (see RubyGems' documentation for the full list of privileged +# operations): +# +# * `gem push` +# * `gem yank` +# * `gem owner --add/remove` +# * adding or removing owners using gem ownership page +# +# This helps make your gem more secure, as users can be more +# confident that gem updates were pushed by maintainers. +# +# @example +# # bad +# Gem::Specification.new do |spec| +# # no `rubygems_mfa_required` metadata specified +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'true' +# } +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'true' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'false' +# } +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'true' +# } +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'false' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'true' +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#63 +class RuboCop::Cop::Gemspec::RequireMFA < ::RuboCop::Cop::Base + include ::RuboCop::Cop::GemspecHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#70 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#87 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#78 + def rubygems_mfa_required(param0); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#83 + def true_string?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#115 + def autocorrect(corrector, node, block_var, metadata); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#139 + def change_value(corrector, value); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#125 + def correct_metadata(corrector, metadata); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#133 + def insert_mfa_required(corrector, node, block_var); end + + # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#108 + def mfa_value(metadata_value); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#67 +RuboCop::Cop::Gemspec::RequireMFA::MSG = T.let(T.unsafe(nil), String) + +# Checks that `required_ruby_version` in a gemspec file is set to a valid +# value (non-blank) and matches `TargetRubyVersion` as set in RuboCop's +# configuration for the gem. +# +# This ensures that RuboCop is using the same Ruby version as the gem. +# +# @example +# # When `TargetRubyVersion` of .rubocop.yml is `2.5`. +# +# # bad +# Gem::Specification.new do |spec| +# # no `required_ruby_version` specified +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.4.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.6.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.5.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.5' +# end +# +# # accepted but not recommended +# Gem::Specification.new do |spec| +# spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0'] +# end +# +# # accepted but not recommended, since +# # Ruby does not really follow semantic versioning +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '~> 2.5' +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#55 +class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#70 + def defined_ruby_version(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#78 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#82 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#65 + def required_ruby_version?(param0); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#94 + def dynamic_version?(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#100 + def extract_ruby_version(required_ruby_version); end + + # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#116 + def not_equal_message(required_ruby_version, target_ruby_version); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#62 +RuboCop::Cop::Gemspec::RequiredRubyVersion::MISSING_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#59 +RuboCop::Cop::Gemspec::RequiredRubyVersion::NOT_EQUAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#58 +RuboCop::Cop::Gemspec::RequiredRubyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that `RUBY_VERSION` constant is not used in gemspec. +# Using `RUBY_VERSION` is dangerous because value of the +# constant is determined by `rake release`. +# It's possible to have dependency based on ruby version used +# to execute `rake release` and not user's ruby version. +# +# @example +# +# # bad +# Gem::Specification.new do |spec| +# if RUBY_VERSION >= '3.0' +# spec.add_runtime_dependency 'gem_a' +# else +# spec.add_runtime_dependency 'gem_b' +# end +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_runtime_dependency 'gem_a' +# end +# +# source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#28 +class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Base + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#36 + def on_const(node); end + + # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#34 + def ruby_version?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#44 + def gem_spec_with_ruby_version?(node); end +end + +# source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#31 +RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking gem declarations. +# +# source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#6 +module RuboCop::Cop::GemspecHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#20 + def gem_specification(param0); end + + # source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#10 + def gem_specification?(param0 = T.unsafe(nil)); end +end + +# Source and spec generator for new cops +# +# This generator will take a cop name and generate a source file +# and spec file when given a valid qualified cop name. +# +# @api private +# +# source://rubocop//lib/rubocop/cop/generator.rb#10 +class RuboCop::Cop::Generator + # @api private + # @raise [ArgumentError] + # @return [Generator] a new instance of Generator + # + # source://rubocop//lib/rubocop/cop/generator.rb#113 + def initialize(name, output: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#133 + def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#129 + def inject_require(root_file_path: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#146 + def todo; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#121 + def write_source; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#125 + def write_spec; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#160 + def badge; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#183 + def generate(template); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#175 + def generated_source; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#179 + def generated_spec; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#160 + def output; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#208 + def snake_case(camel_case_string); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#198 + def source_path; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#188 + def spec_path; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/generator.rb#162 + def write_unless_file_exists(path, contents); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/generator.rb#109 +RuboCop::Cop::Generator::CONFIGURATION_ADDED_MESSAGE = T.let(T.unsafe(nil), String) + +# A class that injects a require directive into the root RuboCop file. +# It looks for other directives that require files in the same (cop) +# namespace and injects the provided one in alpha +# +# source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#9 +class RuboCop::Cop::Generator::ConfigurationInjector + # @return [ConfigurationInjector] a new instance of ConfigurationInjector + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#17 + def initialize(configuration_file_path:, badge:, version_added: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#24 + def inject; end + + private + + # Returns the value of attribute badge. + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39 + def badge; end + + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#41 + def configuration_entries; end + + # Returns the value of attribute configuration_file_path. + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39 + def configuration_file_path; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#59 + def cop_name_line?(yaml); end + + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#49 + def find_target_line; end + + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#45 + def new_configuration_entry; end + + # Returns the value of attribute output. + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39 + def output; end + + # Returns the value of attribute version_added. + # + # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39 + def version_added; end +end + +# source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#10 +RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String) + +# A class that injects a require directive into the root RuboCop file. +# It looks for other directives that require files in the same (cop) +# namespace and injects the provided one in alpha +# +# source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#9 +class RuboCop::Cop::Generator::RequireFileInjector + # @return [RequireFileInjector] a new instance of RequireFileInjector + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#12 + def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#19 + def inject; end + + private + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#64 + def injectable_require_directive; end + + # Returns the value of attribute output. + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29 + def output; end + + # Returns the value of attribute require_entries. + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29 + def require_entries; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#31 + def require_exists?; end + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#68 + def require_path; end + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#58 + def require_path_fragments(require_directive); end + + # Returns the value of attribute root_file_path. + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29 + def root_file_path; end + + # Returns the value of attribute source_path. + # + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29 + def source_path; end + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#39 + def target_line; end + + # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#35 + def updated_directives; end +end + +# source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#10 +RuboCop::Cop::Generator::RequireFileInjector::REQUIRE_PATH = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop//lib/rubocop/cop/generator.rb#11 +RuboCop::Cop::Generator::SOURCE_TEMPLATE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/cop/generator.rb#85 +RuboCop::Cop::Generator::SPEC_TEMPLATE = T.let(T.unsafe(nil), String) + +# Common functionality for checking hash alignment. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#6 +module RuboCop::Cop::HashAlignmentStyles; end + +# Handles calculation of deltas when the enforced style is 'key'. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#8 +class RuboCop::Cop::HashAlignmentStyles::KeyAlignment + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#9 + def checkable_layout?(_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#20 + def deltas(first_pair, current_pair); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#13 + def deltas_for_first_pair(first_pair, _node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#34 + def separator_delta(pair); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#45 + def value_delta(pair); end +end + +# Handles calculation of deltas for `kwsplat` nodes. +# This is a special case that just ensures the kwsplat is aligned with the rest of the hash +# since a `kwsplat` does not have a key, separator or value. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#145 +class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#146 + def deltas(first_pair, current_pair); end +end + +# Handles calculation of deltas when the enforced style is 'separator'. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#120 +class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#123 + def deltas_for_first_pair(*_nodes); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#133 + def hash_rocket_delta(first_pair, current_pair); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#129 + def key_delta(first_pair, current_pair); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#137 + def value_delta(first_pair, current_pair); end +end + +# Handles calculation of deltas when the enforced style is 'table'. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#81 +class RuboCop::Cop::HashAlignmentStyles::TableAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + + # @return [TableAlignment] a new instance of TableAlignment + # + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#84 + def initialize; end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#88 + def deltas_for_first_pair(first_pair, node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#106 + def hash_rocket_delta(first_pair, current_pair); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#102 + def key_delta(first_pair, current_pair); end + + # Returns the value of attribute max_key_width. + # + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#100 + def max_key_width; end + + # Sets the attribute max_key_width + # + # @param value the value to set the attribute max_key_width to. + # + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#100 + def max_key_width=(_arg0); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#110 + def value_delta(first_pair, current_pair); end +end + +# Common functionality for checking alignment of hash values. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#56 +module RuboCop::Cop::HashAlignmentStyles::ValueAlignment + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#57 + def checkable_layout?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#61 + def deltas(first_pair, current_pair); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#71 + def separator_delta(first_pair, current_pair, key_delta); end +end + +# This module checks for Ruby 3.1's hash value omission syntax. +# +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#7 +module RuboCop::Cop::HashShorthandSyntax + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#14 + def on_hash_for_mixed_shorthand(hash_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#26 + def on_pair(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#125 + def brackets?(method_dispatch_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#155 + def breakdown_value_types_of_hash(hash_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#102 + def def_node_that_require_parentheses(node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#179 + def each_omittable_value_pair(hash_value_type_breakdown, &block); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#175 + def each_omitted_value_pair(hash_value_type_breakdown, &block); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#80 + def enforced_shorthand_syntax; end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#117 + def find_ancestor_method_dispatch_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#167 + def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#171 + def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#74 + def ignore_hash_shorthand_syntax?(pair_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#69 + def ignore_mixed_hash_shorthand_syntax?(hash_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#140 + def last_expression?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#148 + def method_dispatch_as_argument?(method_dispatch_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#183 + def mixed_shorthand_syntax_check(hash_value_type_breakdown); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#199 + def no_mixed_shorthand_syntax_check(hash_value_type_breakdown); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#49 + def register_offense(node, message, replacement); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#84 + def require_hash_value?(hash_key_source, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#93 + def require_hash_value_for_around_hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#129 + def use_element_of_hash_literal_as_receiver?(ancestor, parent); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#134 + def use_modifier_form_without_parenthesized_method_call?(ancestor); end +end + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#12 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_EXPLICIT_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#10 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_MSG_PREFIX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#11 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_OMIT_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#209 +class RuboCop::Cop::HashShorthandSyntax::DefNode < ::Struct + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#218 + def first_argument; end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#222 + def last_argument; end + + # Returns the value of attribute node + # + # @return [Object] the current value of node + def node; end + + # Sets the attribute node + # + # @param value [Object] the value to set the attribute node to. + # @return [Object] the newly set value + def node=(_); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#210 + def selector; end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#9 +RuboCop::Cop::HashShorthandSyntax::EXPLICIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#8 +RuboCop::Cop::HashShorthandSyntax::OMIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) + +# Common functionality for Style/HashTransformKeys and +# Style/HashTransformValues +# +# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#7 +module RuboCop::Cop::HashTransformMethod + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#13 + def array_receiver?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#17 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#34 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#27 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#108 + def execute_correction(corrector, node, correction); end + + # @abstract + # @raise [NotImplementedError] + # @return [Captures] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#83 + def extract_captures(_match); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#60 + def handle_possible_offense(node, match, match_desc); end + + # @abstract + # @raise [NotImplementedError] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#90 + def new_method_name; end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#41 + def on_bad_each_with_object(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#46 + def on_bad_hash_brackets_map(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#51 + def on_bad_map_to_h(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#56 + def on_bad_to_h(_node); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#94 + def prepare_correction(node); end +end + +# Internal helper class to hold autocorrect data +# +# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#136 +class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct + # Returns the value of attribute block_node + # + # @return [Object] the current value of block_node + def block_node; end + + # Sets the attribute block_node + # + # @param value [Object] the value to set the attribute block_node to. + # @return [Object] the newly set value + def block_node=(_); end + + # Returns the value of attribute leading + # + # @return [Object] the current value of leading + def leading; end + + # Sets the attribute leading + # + # @param value [Object] the value to set the attribute leading to. + # @return [Object] the newly set value + def leading=(_); end + + # Returns the value of attribute match + # + # @return [Object] the current value of match + def match; end + + # Sets the attribute match + # + # @param value [Object] the value to set the attribute match to. + # @return [Object] the newly set value + def match=(_); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#177 + def set_new_arg_name(transformed_argname, corrector); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#181 + def set_new_body_expression(transforming_body_expr, corrector); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#167 + def set_new_method_name(new_method_name, corrector); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#161 + def strip_prefix_and_suffix(node, corrector); end + + # Returns the value of attribute trailing + # + # @return [Object] the current value of trailing + def trailing; end + + # Sets the attribute trailing + # + # @param value [Object] the value to set the attribute trailing to. + # @return [Object] the newly set value + def trailing=(_); end + + class << self + def [](*_arg0); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#137 + def from_each_with_object(node, match); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#141 + def from_hash_brackets_map(node, match); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#145 + def from_map_to_h(node, match); end + + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#157 + def from_to_h(node, match); end + + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# Internal helper class to hold match data +# +# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#118 +class RuboCop::Cop::HashTransformMethod::Captures < ::Struct + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#119 + def noop_transformation?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#124 + def transformation_uses_both_args?; end + + # Returns the value of attribute transformed_argname + # + # @return [Object] the current value of transformed_argname + def transformed_argname; end + + # Sets the attribute transformed_argname + # + # @param value [Object] the value to set the attribute transformed_argname to. + # @return [Object] the newly set value + def transformed_argname=(_); end + + # Returns the value of attribute transforming_body_expr + # + # @return [Object] the current value of transforming_body_expr + def transforming_body_expr; end + + # Sets the attribute transforming_body_expr + # + # @param value [Object] the value to set the attribute transforming_body_expr to. + # @return [Object] the newly set value + def transforming_body_expr=(_); end + + # Returns the value of attribute unchanged_body_expr + # + # @return [Object] the current value of unchanged_body_expr + def unchanged_body_expr; end + + # Sets the attribute unchanged_body_expr + # + # @param value [Object] the value to set the attribute unchanged_body_expr to. + # @return [Object] the newly set value + def unchanged_body_expr=(_); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#128 + def use_transformed_argname?; end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#10 +RuboCop::Cop::HashTransformMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Common functionality for working with heredoc strings. +# +# source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#6 +module RuboCop::Cop::Heredoc + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9 + def on_dstr(node); end + + # @raise [NotImplementedError] + # + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#17 + def on_heredoc(_node); end + + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9 + def on_str(node); end + + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9 + def on_xstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#28 + def delimiter_string(node); end + + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#34 + def heredoc_type(node); end + + # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#23 + def indent_level(str); end +end + +# source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#7 +RuboCop::Cop::Heredoc::OPENING_DELIMITER = T.let(T.unsafe(nil), Regexp) + +# This class autocorrects `if...then` structures to a multiline `if` statement +# +# source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#6 +class RuboCop::Cop::IfThenCorrector + # @return [IfThenCorrector] a new instance of IfThenCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#9 + def initialize(if_node, indentation: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#14 + def call(corrector); end + + private + + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#50 + def branch_body_indentation; end + + # Returns the value of attribute if_node. + # + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#20 + def if_node; end + + # Returns the value of attribute indentation. + # + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#20 + def indentation; end + + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#22 + def replacement(node = T.unsafe(nil), indentation = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#36 + def rewrite_else_branch(else_branch, indentation); end +end + +# source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#7 +RuboCop::Cop::IfThenCorrector::DEFAULT_INDENTATION_WIDTH = T.let(T.unsafe(nil), Integer) + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#40 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# Handles adding and checking ignored nodes. +# +# source://rubocop//lib/rubocop/cop/ignored_node.rb#6 +module RuboCop::Cop::IgnoredNode + # source://rubocop//lib/rubocop/cop/ignored_node.rb#7 + def ignore_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/ignored_node.rb#24 + def ignored_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/ignored_node.rb#11 + def part_of_ignored_node?(node); end + + private + + # source://rubocop//lib/rubocop/cop/ignored_node.rb#31 + def ignored_nodes; end +end + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#54 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# Common functionality for checking integer nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/integer_node.rb#6 +module RuboCop::Cop::IntegerNode + private + + # source://rubocop//lib/rubocop/cop/mixin/integer_node.rb#9 + def integer_part(node); end +end + +# Common functionality for working with string interpolations. +# +# @abstract Subclasses are expected to implement {#on_interpolation}. +# +# source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#8 +module RuboCop::Cop::Interpolation + # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9 + def on_dstr(node); end + + # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9 + def on_dsym(node); end + + # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#17 + def on_node_with_interpolations(node); end + + # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9 + def on_regexp(node); end + + # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9 + def on_xstr(node); end +end + +# This class autocorrects lambda literal to method notation. +# +# source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#6 +class RuboCop::Cop::LambdaLiteralToMethodCorrector + # @return [LambdaLiteralToMethodCorrector] a new instance of LambdaLiteralToMethodCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#7 + def initialize(block_node); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#13 + def call(corrector); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#118 + def arg_to_unparenthesized_call?; end + + # Returns the value of attribute arguments. + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34 + def arguments; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#102 + def arguments_begin_pos; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#98 + def arguments_end_pos; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#110 + def block_begin; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#106 + def block_end; end + + # Returns the value of attribute block_node. + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34 + def block_node; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#59 + def insert_arguments(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#43 + def insert_separating_space(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#88 + def lambda_arg_string; end + + # Returns the value of attribute method. + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34 + def method; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#92 + def needs_separating_space?; end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#53 + def remove_arguments(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#66 + def remove_leading_whitespace(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#74 + def remove_trailing_whitespace(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#36 + def remove_unparenthesized_whitespace(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#79 + def replace_delimiters(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#49 + def replace_selector(corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#114 + def selector_end; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#134 + def separating_space?; end +end + +# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#5 +module RuboCop::Cop::Layout; end + +# Bare access modifiers (those not applying to specific methods) should be +# indented as deep as method definitions, or as deep as the class/module +# keyword, depending on configuration. +# +# @example EnforcedStyle: indent (default) +# # bad +# class Plumbus +# private +# def smooth; end +# end +# +# # good +# class Plumbus +# private +# def smooth; end +# end +# @example EnforcedStyle: outdent +# # bad +# class Plumbus +# private +# def smooth; end +# end +# +# # good +# class Plumbus +# private +# def smooth; end +# end +# +# source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#35 +class RuboCop::Cop::Layout::AccessModifierIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43 + def on_sclass(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#54 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#58 + def check_body(body, node); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#65 + def check_modifier(send_node, end_range); end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#88 + def expected_indent_offset; end + + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#84 + def message(range); end + + # An offset that is not expected, but correct if the configuration is + # changed. + # + # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#94 + def unexpected_indent_offset; end +end + +# source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#41 +RuboCop::Cop::Layout::AccessModifierIndentation::MSG = T.let(T.unsafe(nil), String) + +# Here we check if the arguments on a multi-line method +# definition are aligned. +# +# @example EnforcedStyle: with_first_argument (default) +# # good +# +# foo :bar, +# :baz, +# key: value +# +# foo( +# :bar, +# :baz, +# key: value +# ) +# +# # bad +# +# foo :bar, +# :baz, +# key: value +# +# foo( +# :bar, +# :baz, +# key: value +# ) +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# foo :bar, +# :baz, +# key: value +# +# # bad +# +# foo :bar, +# :baz, +# key: value +# +# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#46 +class RuboCop::Cop::Layout::ArgumentAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#55 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#55 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#92 + def arguments_or_first_arg_pairs(node); end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#80 + def arguments_with_last_arg_pairs(node); end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#108 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#68 + def autocorrect_incompatible_with_other_cops?; end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#124 + def base_column(node, first_argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#144 + def enforce_hash_argument_with_separator?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#116 + def fixed_indentation?; end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#72 + def flattened_arguments(node); end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#152 + def hash_argument_config; end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#112 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#101 + def multiple_arguments?(node); end + + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#135 + def target_method_lineno(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#120 + def with_first_argument_style?; end +end + +# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#50 +RuboCop::Cop::Layout::ArgumentAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#52 +RuboCop::Cop::Layout::ArgumentAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Here we check if the elements of a multi-line array literal are +# aligned. +# +# @example EnforcedStyle: with_first_element (default) +# # good +# +# array = [1, 2, 3, +# 4, 5, 6] +# array = ['run', +# 'forrest', +# 'run'] +# +# # bad +# +# array = [1, 2, 3, +# 4, 5, 6] +# array = ['run', +# 'forrest', +# 'run'] +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# array = [1, 2, 3, +# 4, 5, 6] +# +# # bad +# +# array = [1, 2, 3, +# 4, 5, 6] +# +# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#36 +class RuboCop::Cop::Layout::ArrayAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#46 + def on_array(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#55 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#67 + def base_column(node, args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#63 + def fixed_indentation?; end + + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#59 + def message(_range); end + + # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#78 + def target_method_lineno(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#40 +RuboCop::Cop::Layout::ArrayAlignment::ALIGN_ELEMENTS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#43 +RuboCop::Cop::Layout::ArrayAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first line of the +# right-hand-side of a multi-line assignment. +# +# The indentation of the remaining lines can be corrected with +# other cops such as `IndentationConsistency` and `EndAlignment`. +# +# @example +# # bad +# value = +# if foo +# 'bar' +# end +# +# # good +# value = +# if foo +# 'bar' +# end +# +# source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#24 +class RuboCop::Cop::Layout::AssignmentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + private + + # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#42 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#33 + def check_assignment(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#46 + def leftmost_multiple_assignment(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#29 +RuboCop::Cop::Layout::AssignmentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keyword of `begin` is aligned properly. +# +# Two modes are supported through the `EnforcedStyleAlignWith` configuration +# parameter. If it's set to `start_of_line` (which is the default), the +# `end` shall be aligned with the start of the line where the `begin` +# keyword is. If it's set to `begin`, the `end` shall be aligned with the +# `begin` keyword. +# +# `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`) +# by default. On the other hand, `||= begin` that this cop targets tends to +# align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`. +# These style can be configured by each cop. +# +# @example EnforcedStyleAlignWith: start_of_line (default) +# # bad +# foo ||= begin +# do_something +# end +# +# # good +# foo ||= begin +# do_something +# end +# @example EnforcedStyleAlignWith: begin +# # bad +# foo ||= begin +# do_something +# end +# +# # good +# foo ||= begin +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#41 +class RuboCop::Cop::Layout::BeginEndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#48 + def on_kwbegin(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#63 + def alignment_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#59 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#54 + def check_begin_alignment(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#46 +RuboCop::Cop::Layout::BeginEndAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords are aligned properly for do +# end blocks. +# +# Three modes are supported through the `EnforcedStyleAlignWith` +# configuration parameter: +# +# `start_of_block` : the `end` shall be aligned with the +# start of the line where the `do` appeared. +# +# `start_of_line` : the `end` shall be aligned with the +# start of the line where the expression started. +# +# `either` (which is the default) : the `end` is allowed to be in either +# location. The autofixer will default to `start_of_line`. +# +# @example EnforcedStyleAlignWith: either (default) +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# foo.bar +# .each do +# baz +# end +# @example EnforcedStyleAlignWith: start_of_block +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# foo.bar +# .each do +# baz +# end +# @example EnforcedStyleAlignWith: start_of_line +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# foo.bar +# .each do +# baz +# end +# +# source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#66 +class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#74 + def block_end_align_target?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#83 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#83 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#89 + def style_parameter_name; end + + private + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#228 + def add_space_before(corrector, loc, delta); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#205 + def alt_start_msg(start_loc, source_line_column); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#155 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#105 + def block_end_align_target(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#123 + def check_block_alignment(start_node, block_node); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#178 + def compute_do_source_line_column(node, end_loc); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#220 + def compute_start_col(ancestor_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#119 + def disqualified_parent?(parent, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#115 + def end_align_target?(node, parent); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#168 + def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#215 + def format_source_line_column(source_line_column); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#197 + def loc_to_source_line_column(loc); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#136 + def register_offense(block_node, start_loc, end_loc, do_source_line_column); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#232 + def remove_space_before(corrector, end_pos, delta); end + + # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#95 + def start_for_block_node(block_node); end +end + +# source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#71 +RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end statement of a do..end block +# is on its own line. +# +# @example +# # bad +# blah do |i| +# foo(i) end +# +# # good +# blah do |i| +# foo(i) +# end +# +# # bad +# blah { |i| +# foo(i) } +# +# # good +# blah { |i| +# foo(i) +# } +# +# source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#27 +class RuboCop::Cop::Layout::BlockEndNewline < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#33 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#33 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#66 + def last_heredoc_argument(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#62 + def message(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#76 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#49 + def register_offense(node, offense_range); end +end + +# source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#31 +RuboCop::Cop::Layout::BlockEndNewline::MSG = T.let(T.unsafe(nil), String) + +# Checks how the `when` and ``in``s of a `case` expression +# are indented in relation to its `case` or `end` keyword. +# +# It will register a separate offense for each misaligned `when` and `in`. +# +# @example +# # If Layout/EndAlignment is set to keyword style (default) +# # *case* and *end* should always be aligned to same depth, +# # and therefore *when* should always be aligned to both - +# # regardless of configuration. +# +# # bad for all styles +# case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good for all styles +# case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# @example EnforcedStyle: case (default) +# # if EndAlignment is set to other style such as +# # start_of_line (as shown below), then *when* alignment +# # configuration does have an effect. +# +# # bad +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# @example EnforcedStyle: end +# # bad +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#112 +class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#120 + def on_case(case_node); end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#127 + def on_case_match(case_match_node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#193 + def base_column(case_node, base); end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#150 + def check_when(when_node, branch_type); end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#182 + def detect_incorrect_style(when_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#136 + def end_and_last_conditional_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#146 + def enforced_style_end?; end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#169 + def incorrect_style(when_node, branch_type); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#161 + def indent_one_step?; end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#165 + def indentation_width; end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#207 + def replacement(node); end + + # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#200 + def whitespace_range(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#118 +RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks if the code style follows the ExpectedOrder configuration: +# +# `Categories` allows us to map macro names into a category. +# +# Consider an example of code style that covers the following order: +# +# * Module inclusion (include, prepend, extend) +# * Constants +# * Associations (has_one, has_many) +# * Public attribute macros (attr_accessor, attr_writer, attr_reader) +# * Other macros (validates, validate) +# * Public class methods +# * Initializer +# * Public instance methods +# * Protected attribute macros (attr_accessor, attr_writer, attr_reader) +# * Protected instance methods +# * Private attribute macros (attr_accessor, attr_writer, attr_reader) +# * Private instance methods +# +# You can configure the following order: +# +# [source,yaml] +# ---- +# Layout/ClassStructure: +# ExpectedOrder: +# - module_inclusion +# - constants +# - association +# - public_attribute_macros +# - public_delegate +# - macros +# - public_class_methods +# - initializer +# - public_methods +# - protected_attribute_macros +# - protected_methods +# - private_attribute_macros +# - private_delegate +# - private_methods +# ---- +# +# Instead of putting all literals in the expected order, is also +# possible to group categories of macros. Visibility levels are handled +# automatically. +# +# [source,yaml] +# ---- +# Layout/ClassStructure: +# Categories: +# association: +# - has_many +# - has_one +# attribute_macros: +# - attr_accessor +# - attr_reader +# - attr_writer +# macros: +# - validates +# - validate +# module_inclusion: +# - include +# - prepend +# - extend +# ---- +# +# @example +# # bad +# # Expect extend be before constant +# class Person < ApplicationRecord +# has_many :orders +# ANSWER = 42 +# +# extend SomeModule +# include AnotherModule +# end +# +# # good +# class Person +# # extend and include go first +# extend SomeModule +# include AnotherModule +# +# # inner classes +# CustomError = Class.new(StandardError) +# +# # constants are next +# SOME_CONSTANT = 20 +# +# # afterwards we have public attribute macros +# attr_reader :name +# +# # followed by other macros (if any) +# validates :name +# +# # then we have public delegate macros +# delegate :to_s, to: :name +# +# # public class methods are next in line +# def self.some_method +# end +# +# # initialization goes between class methods and instance methods +# def initialize +# end +# +# # followed by other public instance methods +# def some_method +# end +# +# # protected attribute macros and methods go next +# protected +# +# attr_reader :protected_name +# +# def some_protected_method +# end +# +# # private attribute macros, delegate macros and methods +# # are grouped near the end +# private +# +# attr_reader :private_name +# +# delegate :some_private_delegate, to: :name +# +# def some_private_method +# end +# end +# +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#142 +class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::CommentsHelp + extend ::RuboCop::Cop::AutoCorrector + + # Validates code style on class declaration. + # Add offense when find a node out of expected order. + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158 + def on_class(class_node); end + + # Validates code style on class declaration. + # Add offense when find a node out of expected order. + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158 + def on_sclass(class_node); end + + private + + # Autocorrect by swapping between two nodes autocorrecting them + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#174 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#305 + def begin_pos_with_comment(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#328 + def buffer; end + + # Setting categories hash allow you to group methods in group to match + # in the {expected_order}. + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#340 + def categories; end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#234 + def class_elements(class_node); end + + # Classifies a node to match with something in the {expected_order} + # + # @param node to be analysed + # @return String when the node type is a `:block` then + # {classify} recursively with the first children + # @return String when the node type is a `:send` then {find_category} + # by method name + # @return String otherwise trying to {humanize_node} of the current node + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#194 + def classify(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#271 + def dynamic_constant?(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#295 + def end_position_for(node); end + + # Load expected order from `ExpectedOrder` config. + # Define new terms in the expected order by adding new {categories}. + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#334 + def expected_order; end + + # Categorize a node according to the {expected_order} + # Try to match {categories} values against the node's method_name given + # also its visibility. + # + # @param node to be analysed. + # @return [String] with the key category or the `method_name` as string + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#212 + def find_category(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#324 + def find_heredoc(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#262 + def humanize_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#246 + def ignore?(node, classification); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#253 + def ignore_for_autocorrect?(node, sibling); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#289 + def marked_as_private_constant?(node, name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#279 + def private_constant?(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#320 + def start_line_position(node); end + + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#225 + def walk_over_nested_class_definition(class_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#316 + def whole_line_comment_at_line?(line); end +end + +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#147 +RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#154 +RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of here document closings. +# +# @example +# +# # bad +# class Foo +# def bar +# <<~SQL +# 'Hi' +# SQL +# end +# end +# +# # good +# class Foo +# def bar +# <<~SQL +# 'Hi' +# SQL +# end +# end +# +# # bad +# +# # heredoc contents is before closing heredoc. +# foo arg, +# <<~EOS +# Hi +# EOS +# +# # good +# foo arg, +# <<~EOS +# Hi +# EOS +# +# # good +# foo arg, +# <<~EOS +# Hi +# EOS +# +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#48 +class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#57 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#74 + def argument_indentation_correct?(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#82 + def closing_indentation(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#101 + def find_node_used_heredoc_argument(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#90 + def heredoc_closing(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#86 + def heredoc_opening(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#117 + def indent_level(source_line); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#94 + def indented_end(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#109 + def message(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#70 + def opening_indentation(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#53 +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#54 +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#52 +RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String) + +# Checks the indentation of hanging closing parentheses in +# method calls, method definitions, and grouped expressions. A hanging +# closing parenthesis means `)` preceded by a line break. +# +# @example +# +# # bad +# some_method( +# a, +# b +# ) +# +# some_method( +# a, b +# ) +# +# some_method(a, b, c +# ) +# +# some_method(a, +# b, +# c +# ) +# +# some_method(a, +# x: 1, +# y: 2 +# ) +# +# # Scenario 1: When First Parameter Is On Its Own Line +# +# # good: when first param is on a new line, right paren is *always* +# # outdented by IndentationWidth +# some_method( +# a, +# b +# ) +# +# # good +# some_method( +# a, b +# ) +# +# # Scenario 2: When First Parameter Is On The Same Line +# +# # good: when all other params are also on the same line, outdent +# # right paren by IndentationWidth +# some_method(a, b, c +# ) +# +# # good: when all other params are on multiple lines, but are lined +# # up, align right paren with left paren +# some_method(a, +# b, +# c +# ) +# +# # good: when other params are not lined up on multiple lines, outdent +# # right paren by IndentationWidth +# some_method(a, +# x: 1, +# y: 2 +# ) +# +# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#71 +class RuboCop::Cop::Layout::ClosingParenthesisIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#84 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#79 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#88 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#88 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#79 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#157 + def all_elements_aligned?(elements); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#95 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#99 + def check(node, elements); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#107 + def check_for_elements(node, elements); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#125 + def check_for_no_elements(node); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#171 + def correct_column_candidates(node, left_paren); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#144 + def expected_column(left_paren, elements); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#167 + def first_argument_line(elements); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#187 + def line_break_after_left_paren?(left_paren, elements); end + + # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#179 + def message(correct_column, left_paren, right_paren); end +end + +# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#77 +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#75 +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_INDENT = T.let(T.unsafe(nil), String) + +# Checks the indentation of comments. +# +# @example +# # bad +# # comment here +# def method_name +# end +# +# # comment here +# a = 'hello' +# +# # yet another comment +# if true +# true +# end +# +# # good +# # comment here +# def method_name +# end +# +# # comment here +# a = 'hello' +# +# # yet another comment +# if true +# true +# end +# @example AllowForAlignment: false (default) +# # bad +# a = 1 # A really long comment +# # spanning two lines. +# +# # good +# # A really long comment spanning one line. +# a = 1 +# @example AllowForAlignment: true +# # good +# a = 1 # A really long comment +# # spanning two lines. +# +# source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#48 +class RuboCop::Cop::Layout::CommentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#55 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#61 + def autocorrect(corrector, comment); end + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#88 + def autocorrect_one(corrector, comment); end + + # Corrects all comment lines that occur immediately before the given + # comment and have the same indentation. This is to avoid a long chain + # of correcting, saving the file, parsing and inspecting again, and + # then correcting one more line, and so on. + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#71 + def autocorrect_preceding_comments(corrector, comment); end + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#92 + def check(comment, comment_index); end + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#145 + def correct_indentation(next_line); end + + # Returns true if: + # a) the cop is configured to allow extra indentation for alignment, and + # b) the currently inspected comment is aligned with the nearest preceding end-of-line + # comment. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#121 + def correctly_aligned_with_preceding_comment?(comment_index, column); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#156 + def less_indented?(line); end + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#140 + def line_after_comment(comment); end + + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#131 + def message(column, correct_comment_indentation); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#135 + def own_line_comment?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#82 + def should_correct?(preceding_comment, reference_comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#162 + def two_alternatives?(line); end +end + +# source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#52 +RuboCop::Cop::Layout::CommentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for conditions that are not on the same line as +# if/while/until. +# +# @example +# +# # bad +# +# if +# some_condition +# do_something +# end +# @example +# +# # good +# +# if some_condition +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/layout/condition_position.rb#25 +class RuboCop::Cop::Layout::ConditionPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#31 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#37 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#37 + def on_while(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#44 + def check(node); end + + # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#58 + def message(condition); end +end + +# source://rubocop//lib/rubocop/cop/layout/condition_position.rb#29 +RuboCop::Cop::Layout::ConditionPosition::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords of method definitions are +# aligned properly. +# +# Two modes are supported through the EnforcedStyleAlignWith configuration +# parameter. If it's set to `start_of_line` (which is the default), the +# `end` shall be aligned with the start of the line where the `def` +# keyword is. If it's set to `def`, the `end` shall be aligned with the +# `def` keyword. +# +# @example EnforcedStyleAlignWith: start_of_line (default) +# # bad +# +# private def foo +# end +# +# # good +# +# private def foo +# end +# @example EnforcedStyleAlignWith: def +# # bad +# +# private def foo +# end +# +# # good +# +# private def foo +# end +# +# source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#36 +class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#43 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#43 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#48 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#63 + def autocorrect(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#41 +RuboCop::Cop::Layout::DefEndAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks the . position in multi-line method calls. +# +# @example EnforcedStyle: leading (default) +# # bad +# something. +# method +# +# # good +# something +# .method +# @example EnforcedStyle: trailing +# # bad +# something +# .method +# +# # good +# something. +# method +# +# source://rubocop//lib/rubocop/cop/layout/dot_position.rb#25 +class RuboCop::Cop::Layout::DotPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#34 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#34 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#49 + def autocorrect(corrector, dot, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#99 + def correct_dot_position_style?(dot_line, selector_line); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#126 + def end_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#122 + def heredoc?(node); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#114 + def last_heredoc_line(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#95 + def line_between?(first_line, second_line); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#64 + def message(dot); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#74 + def proper_dot_position?(node); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#106 + def receiver_end_line(node); end + + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#130 + def selector_range(node); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#30 + def autocorrect_incompatible_with; end + end +end + +# Checks the alignment of else keywords. Normally they should +# be aligned with an if/unless/while/until/begin/def/rescue keyword, but there +# are special cases when they should follow the same rules as the +# alignment of end. +# +# @example +# # bad +# if something +# code +# else +# code +# end +# +# # bad +# if something +# code +# elsif something +# code +# end +# +# # good +# if something +# code +# else +# code +# end +# +# source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#32 +class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#57 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#63 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#40 + def on_if(node, base = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#51 + def on_rescue(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#147 + def assignment_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#71 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#106 + def base_for_method_definition(node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#80 + def base_range_of_if(node, base); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#89 + def base_range_of_rescue(node); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#131 + def check_alignment(base_range, else_range); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#115 + def check_assignment(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#75 + def check_nested(node, base); end +end + +# source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#38 +RuboCop::Cop::Layout::ElseAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks empty comment. +# +# @example +# # bad +# +# # +# class Foo +# end +# +# # good +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# @example AllowBorderComment: true (default) +# # good +# +# def foo +# end +# +# ################# +# +# def bar +# end +# @example AllowBorderComment: false +# # bad +# +# def foo +# end +# +# ################# +# +# def bar +# end +# @example AllowMarginComment: true (default) +# # good +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# @example AllowMarginComment: false +# # bad +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#63 +class RuboCop::Cop::Layout::EmptyComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#69 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#131 + def allow_border_comment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#135 + def allow_margin_comment?; end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#97 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#127 + def comment_text(comment); end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#108 + def concat_consecutive_comments(comments); end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#139 + def current_token(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#117 + def empty_comment_only?(comment_text); end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#85 + def investigate(comments); end + + # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#143 + def previous_token(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#67 +RuboCop::Cop::Layout::EmptyComment::MSG = T.let(T.unsafe(nil), String) + +# Enforces empty line after guard clause. +# +# This cop allows `# :nocov:` directive after guard clause because +# SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`: +# +# [source,ruby] +# ---- +# def foo +# # :nocov: +# return if condition +# # :nocov: +# bar +# end +# ---- +# +# Refer to SimpleCov's documentation for more details: +# https://github.com/simplecov-ruby/simplecov#ignoringskipping-code +# +# @example +# +# # bad +# def foo +# return if need_return? +# bar +# end +# +# # good +# def foo +# return if need_return? +# +# bar +# end +# +# # good +# def foo +# return if something? +# return if something_different? +# +# bar +# end +# +# # also good +# def foo +# if something? +# do_something +# return if need_return? +# end +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#54 +class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#63 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#84 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#106 + def contains_guard_clause?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#99 + def correct_style?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#181 + def heredoc?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#174 + def heredoc_line(node, heredoc_node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#148 + def last_heredoc_argument(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#162 + def last_heredoc_argument_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#199 + def multiple_statements_on_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#121 + def next_line_allowed_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#117 + def next_line_empty?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#110 + def next_line_empty_or_allowed_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#127 + def next_line_rescue_or_ensure?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#141 + def next_sibling_empty_or_guard_clause?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#132 + def next_sibling_parent_empty_or_else?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#191 + def offense_location(node); end + + # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`: + # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#208 + def simplecov_directive_comment?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#185 + def use_heredoc_in_condition?(condition); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#60 +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::END_OF_HEREDOC_LINE = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#59 +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#61 +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::SIMPLE_DIRECTIVE_COMMENT_PATTERN = T.let(T.unsafe(nil), Regexp) + +# Checks for a newline after the final magic comment. +# +# @example +# # good +# # frozen_string_literal: true +# +# # Some documentation for Person +# class Person +# # Some code +# end +# +# # bad +# # frozen_string_literal: true +# # Some documentation for Person +# class Person +# # Some code +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#23 +class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#29 + def on_new_investigation; end + + private + + # Find the last magic comment in the source file. + # + # Take all comments that precede the first line of code, select the + # magic comments, and return the last magic comment in the file. + # + # @return [Parser::Source::Comment] if magic comments exist before code + # @return [nil] otherwise + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#54 + def last_magic_comment(source); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#43 + def offending_range(last_magic_comment); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#27 +RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), String) + +# Enforces empty line after multiline condition. +# +# @example +# # bad +# if multiline && +# condition +# do_something +# end +# +# # good +# if multiline && +# condition +# +# do_something +# end +# +# # bad +# case x +# when foo, +# bar +# do_something +# end +# +# # good +# case x +# when foo, +# bar +# +# do_something +# end +# +# # bad +# begin +# do_something +# rescue FooError, +# BarError +# handle_error +# end +# +# # good +# begin +# do_something +# rescue FooError, +# BarError +# +# handle_error +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#54 +class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#82 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#60 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#93 + def on_rescue(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#70 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#75 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#70 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#75 + def on_while_post(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#127 + def autocorrect(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#105 + def check_condition(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#120 + def multiline_rescue_exceptions?(exception_nodes); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#116 + def multiline_when_condition?(when_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#112 + def next_line_empty?(line); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#58 +RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks whether class/module/method definitions are +# separated by one or more empty lines. +# +# `NumberOfEmptyLines` can be an integer (default is 1) or +# an array (e.g. [1, 2]) to specify a minimum and maximum +# number of empty lines permitted. +# +# `AllowAdjacentOneLineDefs` configures whether adjacent +# one-line definitions are considered an offense. +# +# @example EmptyLineBetweenMethodDefs: true (default) +# # checks for empty lines between method definitions. +# +# # bad +# def a +# end +# def b +# end +# @example +# +# # good +# def a +# end +# +# def b +# end +# @example EmptyLineBetweenClassDefs: true (default) +# # checks for empty lines between class definitions. +# +# # bad +# class A +# end +# class B +# end +# def b +# end +# @example +# +# # good +# class A +# end +# +# class B +# end +# +# def b +# end +# @example EmptyLineBetweenModuleDefs: true (default) +# # checks for empty lines between module definitions. +# +# # bad +# module A +# end +# module B +# end +# def b +# end +# @example +# +# # good +# module A +# end +# +# module B +# end +# +# def b +# end +# @example AllowAdjacentOneLineDefs: true (default) +# +# # good +# class ErrorA < BaseError; end +# class ErrorB < BaseError; end +# class ErrorC < BaseError; end +# +# # good +# class ErrorA < BaseError; end +# +# class ErrorB < BaseError; end +# +# class ErrorC < BaseError; end +# @example AllowAdjacentOneLineDefs: false +# +# # bad +# class ErrorA < BaseError; end +# class ErrorB < BaseError; end +# class ErrorC < BaseError; end +# +# # good +# class ErrorA < BaseError; end +# +# class ErrorB < BaseError; end +# +# class ErrorC < BaseError; end +# +# source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#108 +class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#145 + def autocorrect(corrector, prev_def, node, count); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#130 + def check_defs(nodes); end + + # We operate on `begin` nodes, instead of using `OnMethodDef`, + # so that we can walk over pairs of consecutive nodes and + # efficiently access a node's predecessor; #prev_node ends up + # doing a linear scan over siblings, so we don't want to call + # it on each def. + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#123 + def on_begin(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#290 + def allowance_range?; end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#274 + def autocorrect_insert_lines(corrector, newline_pos, count); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#267 + def autocorrect_remove_lines(corrector, newline_pos, count); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#227 + def blank_lines_count_between(first_def_node, second_def_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#171 + def candidate?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#191 + def class_candidate?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#255 + def def_end(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#163 + def def_location(correction_node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#247 + def def_start(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#178 + def empty_line_between_macros; end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#259 + def end_loc(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#205 + def expected_lines; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#223 + def line_count_allowed?(count); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#239 + def lines_between_defs(first_def_node, second_def_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#182 + def macro_candidate?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#235 + def maximum_empty_lines; end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#199 + def message(node, count: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#187 + def method_candidate?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#231 + def minimum_empty_lines; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#195 + def module_candidate?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#214 + def multiple_blank_lines_groups?(first_def_node, second_def_node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#281 + def node_type(node); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#114 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#112 +RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String) + +# Checks for two or more consecutive blank lines. +# +# @example +# +# # bad - It has two empty lines. +# some_method +# # one empty line +# # two empty lines +# some_method +# +# # good +# some_method +# # one empty line +# some_method +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#21 +class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#28 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#45 + def each_extra_empty_line(lines); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#63 + def exceeds_line_offset?(line_diff); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#67 + def previous_and_current_lines_empty?(line); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#26 +RuboCop::Cop::Layout::EmptyLines::LINE_OFFSET = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#25 +RuboCop::Cop::Layout::EmptyLines::MSG = T.let(T.unsafe(nil), String) + +# Access modifiers should be surrounded by blank lines. +# +# @example EnforcedStyle: around (default) +# +# # bad +# class Foo +# def bar; end +# private +# def baz; end +# end +# +# # good +# class Foo +# def bar; end +# +# private +# +# def baz; end +# end +# @example EnforcedStyle: only_before +# +# # bad +# class Foo +# def bar; end +# private +# def baz; end +# end +# +# # good +# class Foo +# def bar; end +# +# private +# def baz; end +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#43 +class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [EmptyLinesAroundAccessModifier] a new instance of EmptyLinesAroundAccessModifier + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#56 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#62 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#71 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#76 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#87 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#115 + def allowed_only_before_style?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#164 + def block_start?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#170 + def body_end?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#158 + def class_def?(line); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#124 + def correct_next_line_if_denied_style(corrector, node, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#154 + def empty_lines_around?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#104 + def expected_empty_lines?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#180 + def message(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#189 + def message_for_around_style(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#199 + def message_for_only_before_style(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#176 + def next_empty_line_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#148 + def next_line_empty?(last_send_line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#141 + def previous_line_empty?(send_line); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#137 + def previous_line_ignoring_comments(processed_source, send_line); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#48 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#52 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#49 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#51 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#54 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks if empty lines exist around the arguments +# of a method invocation. +# +# @example +# # bad +# do_something( +# foo +# +# ) +# +# process(bar, +# +# baz: qux, +# thud: fred) +# +# some_method( +# +# [1,2,3], +# x: y +# ) +# +# # good +# do_something( +# foo +# ) +# +# process(bar, +# baz: qux, +# thud: fred) +# +# some_method( +# [1,2,3], +# x: y +# ) +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#41 +class RuboCop::Cop::Layout::EmptyLinesAroundArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#47 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#47 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#65 + def empty_lines(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#71 + def extra_lines(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#93 + def inner_lines(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#84 + def line_numbers(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#97 + def outer_lines(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#78 + def processed_lines(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#61 + def receiver_and_method_call_on_different_lines?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#45 +RuboCop::Cop::Layout::EmptyLinesAroundArguments::MSG = T.let(T.unsafe(nil), String) + +# Checks for a newline after an attribute accessor or a group of them. +# `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed +# by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options. +# +# @example +# # bad +# attr_accessor :foo +# def do_something +# end +# +# # good +# attr_accessor :foo +# +# def do_something +# end +# +# # good +# attr_accessor :foo +# attr_reader :bar +# attr_writer :baz +# attr :qux +# +# def do_something +# end +# @example AllowAliasSyntax: true (default) +# # good +# attr_accessor :foo +# alias :foo? :foo +# +# def do_something +# end +# @example AllowAliasSyntax: false +# # bad +# attr_accessor :foo +# alias :foo? :foo +# +# def do_something +# end +# +# # good +# attr_accessor :foo +# +# alias :foo? :foo +# +# def do_something +# end +# @example AllowedMethods: ['private'] +# # good +# attr_accessor :foo +# private :foo +# +# def do_something +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#63 +class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#70 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#123 + def allow_alias?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#133 + def allow_alias_syntax?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#127 + def attribute_or_allowed_method?(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#83 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#107 + def next_line_empty?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#94 + def next_line_empty_or_enable_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#101 + def next_line_enable_directive_comment?(line); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#117 + def next_line_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#111 + def require_empty_line?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#68 +RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::MSG = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of begin-end +# blocks. +# +# @example +# +# # good +# +# begin +# # ... +# end +# +# # bad +# +# begin +# +# # ... +# +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#24 +class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#30 + def on_kwbegin(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#36 + def style; end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#28 +RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of blocks match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# foo do |bar| +# # ... +# end +# @example EnforcedStyle: empty_lines +# # good +# +# foo do |bar| +# +# # ... +# +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#24 +class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#30 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#30 + def on_numblock(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#28 +RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::KIND = T.let(T.unsafe(nil), String) + +# Common functionality for checking if presence/absence of empty lines +# around some kind of body matches the configuration. +# +# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#8 +module RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#20 + def constant_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#23 + def empty_line_required?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#26 + def check(node, body, adjusted_first_line: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#81 + def check_beginning(style, first_line); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#67 + def check_both(style, first_line, last_line); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#108 + def check_deferred_empty_line(body); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#43 + def check_empty_lines_except_namespace(body, first_line, last_line); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#51 + def check_empty_lines_special(body, first_line, last_line); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#85 + def check_ending(style, last_line); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#98 + def check_line(style, line, msg); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#89 + def check_source(style, line_no, desc); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#159 + def deferred_message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#132 + def first_child_requires_empty_line?(body); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#140 + def first_empty_line_required_child(body); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#155 + def message(type, desc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#122 + def namespace?(body, with_one_child: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#148 + def previous_line_ignoring_comments(send_line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#163 + def valid_body_style?(body); end +end + +# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#15 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#13 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_EXTRA = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#14 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_MISSING = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of classes match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# class Foo +# def bar +# # ... +# end +# end +# @example EnforcedStyle: empty_lines +# # good +# +# class Foo +# +# def bar +# # ... +# end +# +# end +# @example EnforcedStyle: empty_lines_except_namespace +# # good +# +# class Foo +# class Bar +# +# # ... +# +# end +# end +# @example EnforcedStyle: empty_lines_special +# # good +# class Foo +# +# def bar; end +# +# end +# @example EnforcedStyle: beginning_only +# # good +# +# class Foo +# +# def bar +# # ... +# end +# end +# @example EnforcedStyle: ending_only +# # good +# +# class Foo +# def bar +# # ... +# end +# +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#67 +class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#73 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#79 + def on_sclass(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#71 +RuboCop::Cop::Layout::EmptyLinesAroundClassBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of `begin` +# sections. This cop doesn't check empty lines at `begin` body +# beginning/end and around method definition body. +# `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody` +# can be used for this purpose. +# +# @example +# +# # good +# +# begin +# do_something +# rescue +# do_something2 +# else +# do_something3 +# ensure +# do_something4 +# end +# +# # good +# +# def foo +# do_something +# rescue +# do_something2 +# end +# +# # bad +# +# begin +# do_something +# +# rescue +# +# do_something2 +# +# else +# +# do_something3 +# +# ensure +# +# do_something4 +# end +# +# # bad +# +# def foo +# do_something +# +# rescue +# +# do_something2 +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#61 +class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#74 + def on_kwbegin(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#81 + def check_body(body, line_of_def_or_kwbegin); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#108 + def keyword_locations(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#125 + def keyword_locations_in_ensure(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#121 + def keyword_locations_in_rescue(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#96 + def last_rescue_and_end_on_same_line(body); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#100 + def message(location, keyword); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#104 + def style; end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#65 +RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of methods. +# +# @example +# +# # good +# +# def foo +# # ... +# end +# +# # bad +# +# def bar +# +# # ... +# +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#23 +class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#29 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#29 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#36 + def style; end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#27 +RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of modules match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# module Foo +# def bar +# # ... +# end +# end +# @example EnforcedStyle: empty_lines +# # good +# +# module Foo +# +# def bar +# # ... +# end +# +# end +# @example EnforcedStyle: empty_lines_except_namespace +# # good +# +# module Foo +# module Bar +# +# # ... +# +# end +# end +# @example EnforcedStyle: empty_lines_special +# # good +# module Foo +# +# def bar; end +# +# end +# +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#47 +class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#53 + def on_module(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#51 +RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::KIND = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords are aligned properly. +# +# Three modes are supported through the `EnforcedStyleAlignWith` +# configuration parameter: +# +# If it's set to `keyword` (which is the default), the `end` +# shall be aligned with the start of the keyword (if, class, etc.). +# +# If it's set to `variable` the `end` shall be aligned with the +# left-hand-side of the variable assignment, if there is one. +# +# If it's set to `start_of_line`, the `end` shall be aligned with the +# start of the line where the matching keyword appears. +# +# This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`) +# by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with +# `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends +# to align with the start of the line. These style can be configured by each cop. +# +# @example EnforcedStyleAlignWith: keyword (default) +# # bad +# +# variable = if true +# end +# +# # good +# +# variable = if true +# end +# +# variable = +# if true +# end +# @example EnforcedStyleAlignWith: variable +# # bad +# +# variable = if true +# end +# +# # good +# +# variable = if true +# end +# +# variable = +# if true +# end +# @example EnforcedStyleAlignWith: start_of_line +# # bad +# +# variable = if true +# end +# +# puts(if true +# end) +# +# # good +# +# variable = if true +# end +# +# puts(if true +# end) +# +# variable = +# if true +# end +# +# source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#75 +class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#105 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#105 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#81 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#93 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#89 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#85 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#101 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#97 + def on_while(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#161 + def alignment_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#178 + def alignment_node_for_variable_style(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#142 + def asgn_variable_align_with(outer_node, inner_node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#196 + def assignment_or_operator_method(node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#116 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#131 + def check_asgn_alignment(outer_node, inner_node); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#120 + def check_assignment(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#152 + def check_other_alignment(node); end +end + +# Checks for Windows-style line endings in the source code. +# +# @example EnforcedStyle: native (default) +# # The `native` style means that CR+LF (Carriage Return + Line Feed) is +# # enforced on Windows, and LF is enforced on other platforms. +# +# # bad +# puts 'Hello' # Return character is LF on Windows. +# puts 'Hello' # Return character is CR+LF on other than Windows. +# +# # good +# puts 'Hello' # Return character is CR+LF on Windows. +# puts 'Hello' # Return character is LF on other than Windows. +# @example EnforcedStyle: lf +# # The `lf` style means that LF (Line Feed) is enforced on +# # all platforms. +# +# # bad +# puts 'Hello' # Return character is CR+LF on all platforms. +# +# # good +# puts 'Hello' # Return character is LF on all platforms. +# @example EnforcedStyle: crlf +# # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is +# # enforced on all platforms. +# +# # bad +# puts 'Hello' # Return character is LF on all platforms. +# +# # good +# puts 'Hello' # Return character is CR+LF on all platforms. +# +# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#40 +class RuboCop::Cop::Layout::EndOfLine < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#71 + def offense_message(line); end + + # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#47 + def on_new_investigation; end + + # If there is no LF on the last line, we don't care if there's no CR. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#67 + def unimportant_missing_cr?(index, last_line, line); end + + private + + # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#85 + def last_line(processed_source); end +end + +# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#44 +RuboCop::Cop::Layout::EndOfLine::MSG_DETECTED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#45 +RuboCop::Cop::Layout::EndOfLine::MSG_MISSING = T.let(T.unsafe(nil), String) + +# Checks for extra/unnecessary whitespace. +# +# @example +# +# # good if AllowForAlignment is true +# name = "RuboCop" +# # Some comment and an empty line +# +# website += "/rubocop/rubocop" unless cond +# puts "rubocop" if debug +# +# # bad for any configuration +# set_app("RuboCop") +# website = "https://github.com/rubocop/rubocop" +# +# # good only if AllowBeforeTrailingComments is true +# object.method(arg) # this is a comment +# +# # good even if AllowBeforeTrailingComments is false or not set +# object.method(arg) # this is a comment +# +# # good with either AllowBeforeTrailingComments or AllowForAlignment +# object.method(arg) # this is a comment +# another_object.method(arg) # this is another comment +# some_object.method(arg) # this is some comment +# +# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#31 +class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#39 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#170 + def align_column(asgn_token); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#147 + def align_equal_sign(corrector, token, align_to); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#137 + def align_equal_signs(range, corrector); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#52 + def aligned_locations(locs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#103 + def aligned_tok?(token); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#159 + def all_relevant_assignment_lines(line_number); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#179 + def allow_for_trailing_comments?; end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#72 + def check_assignment(token); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#81 + def check_other(token1, token2, ast); end + + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#62 + def check_tokens(ast, token1, token2); end + + # @yield [range_between(start_pos, end_pos)] + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#91 + def extra_space_range(token1, token2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#133 + def force_equal_sign_alignment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#111 + def ignored_range?(ast, start_pos); end + + # Returns an array of ranges that should not be reported. It's the + # extra spaces between the keys and values in a multiline hash, + # since those are handled by the Layout/HashAlignment cop. + # + # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#118 + def ignored_ranges(ast); end +end + +# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#37 +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#36 +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first argument in a method call. +# Arguments after the first one are checked by `Layout/ArgumentAlignment`, +# not by this cop. +# +# For indenting the first parameter of method _definitions_, check out +# `Layout/FirstParameterIndentation`. +# +# This cop will respect `Layout/ArgumentAlignment` and will not work when +# `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`. +# +# @example +# +# # bad +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default) +# # Same as `special_for_inner_method_call` except that the special rule +# # only applies if the outer method call encloses its arguments in +# # parentheses. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: consistent +# # The first argument should always be indented one step more than the +# # preceding line. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: consistent_relative_to_receiver +# # The first argument should always be indented one level relative to +# # the parent that is receiving the argument +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_params +# @example EnforcedStyle: special_for_inner_method_call +# # The first argument should normally be indented one step more than +# # the preceding line, but if it's a argument for a method call that +# # is itself a argument in a method call, then the inner argument +# # should be indented relative to the inner method. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# +# source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#147 +class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#222 + def eligible_method_call?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155 + def on_super(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#281 + def argument_alignment_config; end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#174 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#178 + def bare_operator?(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#198 + def base_indentation(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#226 + def base_range(send_node, arg_node); end + + # Returns the column of the given range. For single line ranges, this + # is simple. For ranges with line breaks, we look a the last code line. + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#238 + def column_of(range); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#259 + def comment_lines; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#277 + def enable_layout_first_method_argument_line_break?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#271 + def enforce_first_argument_with_fixed_indentation?; end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#182 + def message(arg_node); end + + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#267 + def on_new_investigation; end + + # Takes the line number of a given code line and returns a string + # containing the previous line that's not a comment line or a blank + # line. + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#250 + def previous_code_line(line_number); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#170 + def should_check?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#206 + def special_inner_call_indentation?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#153 +RuboCop::Cop::Layout::FirstArgumentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first element in an array literal +# where the opening bracket and the first element are on separate lines. +# The other elements' indentations are handled by the ArrayAlignment cop. +# +# By default, array literals that are arguments in a method call with +# parentheses, and where the opening square bracket of the array is on the +# same line as the opening parenthesis of the method call, shall have +# their first element indented one step (two spaces) more than the +# position inside the opening parenthesis. +# +# Other array literals shall have their first element indented one step +# more than the start of the line where the opening square bracket is. +# +# This default style is called 'special_inside_parentheses'. Alternative +# styles are 'consistent' and 'align_brackets'. Here are examples: +# +# @example EnforcedStyle: special_inside_parentheses (default) +# # The `special_inside_parentheses` style enforces that the first +# # element in an array literal where the opening bracket and first +# # element are on separate lines is indented one step (two spaces) more +# # than the position inside the opening parenthesis. +# +# # bad +# array = [ +# :value +# ] +# and_in_a_method_call([ +# :no_difference +# ]) +# +# # good +# array = [ +# :value +# ] +# but_in_a_method_call([ +# :its_like_this +# ]) +# @example EnforcedStyle: consistent +# # The `consistent` style enforces that the first element in an array +# # literal where the opening bracket and the first element are on +# # separate lines is indented the same as an array literal which is not +# # defined inside a method call. +# +# # bad +# # consistent +# array = [ +# :value +# ] +# but_in_a_method_call([ +# :its_like_this +# ]) +# +# # good +# array = [ +# :value +# ] +# and_in_a_method_call([ +# :no_difference +# ]) +# @example EnforcedStyle: align_brackets +# # The `align_brackets` style enforces that the opening and closing +# # brackets are indented to the same position. +# +# # bad +# # align_brackets +# and_now_for_something = [ +# :completely_different +# ] +# +# # good +# # align_brackets +# and_now_for_something = [ +# :completely_different +# ] +# +# source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#82 +class RuboCop::Cop::Layout::FirstArrayElementIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#91 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#95 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#95 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#104 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#142 + def base_description(indent_base_type); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#108 + def brace_alignment_style; end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#112 + def check(array_node, left_parenthesis); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#126 + def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#155 + def message(base_description); end + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#163 + def message_for_right_bracket(indent_base_type); end +end + +# source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#88 +RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first element in a +# multi-line array. +# +# @example +# +# # bad +# [ :a, +# :b] +# +# # good +# [ +# :a, +# :b] +# +# # good +# [:a, :b] +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# [ :a, { +# :b => :c +# }] +# +# # good +# [ +# :a, { +# :b => :c +# }] +# @example AllowMultilineFinalElement: true +# +# # good +# [:a, { +# :b => :c +# }] +# +# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#43 +class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#49 + def on_array(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#57 + def assignment_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#62 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#47 +RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first key in a hash literal +# where the opening brace and the first key are on separate lines. The +# other keys' indentations are handled by the HashAlignment cop. +# +# By default, Hash literals that are arguments in a method call with +# parentheses, and where the opening curly brace of the hash is on the +# same line as the opening parenthesis of the method call, shall have +# their first key indented one step (two spaces) more than the position +# inside the opening parenthesis. +# +# Other hash literals shall have their first key indented one step more +# than the start of the line where the opening curly brace is. +# +# This default style is called 'special_inside_parentheses'. Alternative +# styles are 'consistent' and 'align_braces'. Here are examples: +# +# @example EnforcedStyle: special_inside_parentheses (default) +# # The `special_inside_parentheses` style enforces that the first key +# # in a hash literal where the opening brace and the first key are on +# # separate lines is indented one step (two spaces) more than the +# # position inside the opening parentheses. +# +# # bad +# hash = { +# key: :value +# } +# and_in_a_method_call({ +# no: :difference +# }) +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# # good +# special_inside_parentheses +# hash = { +# key: :value +# } +# but_in_a_method_call({ +# its_like: :this +# }) +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# @example EnforcedStyle: consistent +# # The `consistent` style enforces that the first key in a hash +# # literal where the opening brace and the first key are on +# # separate lines is indented the same as a hash literal which is not +# # defined inside a method call. +# +# # bad +# hash = { +# key: :value +# } +# but_in_a_method_call({ +# its_like: :this +# }) +# +# # good +# hash = { +# key: :value +# } +# and_in_a_method_call({ +# no: :difference +# }) +# @example EnforcedStyle: align_braces +# # The `align_brackets` style enforces that the opening and closing +# # braces are indented to the same position. +# +# # bad +# and_now_for_something = { +# completely: :different +# } +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# # good +# and_now_for_something = { +# completely: :different +# } +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#113 +class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#126 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#122 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#126 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#233 + def argument_alignment_config; end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#137 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#191 + def base_description(indent_base_type); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#141 + def brace_alignment_style; end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#145 + def check(hash_node, left_parenthesis); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#184 + def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#164 + def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#227 + def enforce_first_argument_with_fixed_indentation?; end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#204 + def message(base_description); end + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#212 + def message_for_right_brace(indent_base_type); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#178 + def separator_style?(first_pair); end +end + +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#119 +RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first element in a +# multi-line hash. +# +# @example +# +# # bad +# { a: 1, +# b: 2} +# +# # good +# { +# a: 1, +# b: 2 } +# +# # good +# { +# a: 1, b: { +# c: 3 +# }} +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# { a: 1, b: { +# c: 3 +# }} +# @example AllowMultilineFinalElement: true +# +# # bad +# { a: 1, +# b: { +# c: 3 +# }} +# +# # good +# { a: 1, b: { +# c: 3 +# }} +# +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#46 +class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#52 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#62 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#50 +RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first argument in a +# multi-line method call. +# +# @example +# +# # bad +# method(foo, bar, +# baz) +# +# # good +# method( +# foo, bar, +# baz) +# +# # ignored +# method foo, bar, +# baz +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# method(foo, bar, { +# baz: "a", +# qux: "b", +# }) +# +# # good +# method( +# foo, bar, { +# baz: "a", +# qux: "b", +# }) +# @example AllowMultilineFinalElement: true +# +# # bad +# method(foo, +# bar, +# { +# baz: "a", +# qux: "b", +# } +# ) +# +# # good +# method(foo, bar, { +# baz: "a", +# qux: "b", +# }) +# +# # good +# method( +# foo, +# bar, +# { +# baz: "a", +# qux: "b", +# } +# ) +# +# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#66 +class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#72 + def on_super(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#91 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#70 +RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first parameter in a +# multi-line method parameter definition. +# +# @example +# +# # bad +# def method(foo, bar, +# baz) +# do_something +# end +# +# # good +# def method( +# foo, bar, +# baz) +# do_something +# end +# +# # ignored +# def method foo, +# bar +# do_something +# end +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# def method(foo, bar, baz = { +# :a => "b", +# }) +# do_something +# end +# +# # good +# def method( +# foo, bar, baz = { +# :a => "b", +# }) +# do_something +# end +# @example AllowMultilineFinalElement: true +# +# # good +# def method(foo, bar, baz = { +# :a => "b", +# }) +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#56 +class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#69 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#60 +RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first parameter in a method +# definition. Parameters after the first one are checked by +# Layout/ParameterAlignment, not by this cop. +# +# For indenting the first argument of method _calls_, check out +# Layout/FirstArgumentIndentation, which supports options related to +# nesting that are irrelevant for method _definitions_. +# +# @example +# +# # bad +# def some_method( +# first_param, +# second_param) +# 123 +# end +# @example EnforcedStyle: consistent (default) +# # The first parameter should always be indented one step more than the +# # preceding line. +# +# # good +# def some_method( +# first_param, +# second_param) +# 123 +# end +# @example EnforcedStyle: align_parentheses +# # The first parameter should always be indented one step more than the +# # opening parenthesis. +# +# # good +# def some_method( +# first_param, +# second_param) +# 123 +# end +# +# source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#44 +class RuboCop::Cop::Layout::FirstParameterIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#53 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#53 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#63 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#83 + def base_description(_); end + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#67 + def brace_alignment_style; end + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#71 + def check(def_node); end + + # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#91 + def message(base_description); end +end + +# source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#50 +RuboCop::Cop::Layout::FirstParameterIndentation::MSG = T.let(T.unsafe(nil), String) + +# Check that the keys, separators, and values of a multi-line hash +# literal are aligned according to configuration. The configuration +# options are: +# +# * key (left align keys, one space before hash rockets and values) +# * separator (align hash rockets and colons, right align keys) +# * table (left align keys, hash rockets, and values) +# +# The treatment of hashes passed as the last argument to a method call +# can also be configured. The options are: +# +# * always_inspect +# * always_ignore +# * ignore_implicit (without curly braces) +# +# Alternatively you can specify multiple allowed styles. That's done by +# passing a list of styles to EnforcedStyles. +# +# @example EnforcedHashRocketStyle: key (default) +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# @example EnforcedHashRocketStyle: separator +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# @example EnforcedHashRocketStyle: table +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# @example EnforcedColonStyle: key (default) +# # bad +# { +# foo: bar, +# ba: baz +# } +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedColonStyle: separator +# # bad +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedColonStyle: table +# # bad +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedLastArgumentHashStyle: always_inspect (default) +# # Inspect both implicit and explicit hashes. +# +# # bad +# do_something(foo: 1, +# bar: 2) +# +# # bad +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something( +# foo: 1, +# bar: 2 +# ) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something({ +# foo: 1, +# bar: 2 +# }) +# @example EnforcedLastArgumentHashStyle: always_ignore +# # Ignore both implicit and explicit hashes. +# +# # good +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# @example EnforcedLastArgumentHashStyle: ignore_implicit +# # Ignore only implicit hashes. +# +# # bad +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something(foo: 1, +# bar: 2) +# @example EnforcedLastArgumentHashStyle: ignore_explicit +# # Ignore only explicit hashes. +# +# # bad +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# +# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#178 +class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashAlignmentStyles + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Returns the value of attribute column_deltas. + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218 + def column_deltas; end + + # Sets the attribute column_deltas + # + # @param value the value to set the attribute column_deltas to. + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218 + def column_deltas=(_arg0); end + + # Returns the value of attribute offenses_by. + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218 + def offenses_by; end + + # Sets the attribute offenses_by + # + # @param value the value to set the attribute offenses_by to. + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218 + def offenses_by=(_arg0); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#208 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195 + def on_super(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195 + def on_yield(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#265 + def add_offenses; end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#371 + def adjust(corrector, delta, range); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#300 + def alignment_for(pair); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#314 + def alignment_for_colons; end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#310 + def alignment_for_hash_rockets; end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#390 + def argument_alignment_config; end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#233 + def argument_before_hash(hash_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#222 + def autocorrect_incompatible_with_other_cops?(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#283 + def check_delta(delta, node:, alignment:); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#246 + def check_pairs(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#337 + def correct_key_value(corrector, delta, key, value, separator); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#333 + def correct_no_value(corrector, key_delta, key); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#318 + def correct_node(corrector, node, delta); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#242 + def double_splat?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#384 + def enforce_first_argument_with_fixed_indentation?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#380 + def good_alignment?(column_deltas); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#291 + def ignore_hash_argument?(node); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#353 + def new_alignment(key); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#273 + def register_offenses_with_format(offenses, format); end + + # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#237 + def reset!; end +end + +# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#183 +RuboCop::Cop::Layout::HashAlignment::MESSAGES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#193 +RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES = T.let(T.unsafe(nil), Array) + +# Checks for the placement of the closing parenthesis +# in a method call that passes a HEREDOC string as an argument. +# It should be placed at the end of the line containing the +# opening HEREDOC tag. +# +# @example +# # bad +# +# foo(<<-SQL +# bar +# SQL +# ) +# +# foo(<<-SQL, 123, <<-NOSQL, +# bar +# SQL +# baz +# NOSQL +# ) +# +# foo( +# bar(<<-SQL +# baz +# SQL +# ), +# 123, +# ) +# +# # good +# +# foo(<<-SQL) +# bar +# SQL +# +# foo(<<-SQL, 123, <<-NOSQL) +# bar +# SQL +# baz +# NOSQL +# +# foo( +# bar(<<-SQL), +# baz +# SQL +# 123, +# ) +# +# source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#53 +class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#64 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#184 + def add_correct_closing_paren(node, corrector); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#271 + def add_correct_external_trailing_comma(node, corrector); end + + # Autocorrection note: + # + # Commas are a bit tricky to handle when the method call is + # embedded in another expression. Here's an example: + # + # [ + # first_array_value, + # foo(<<-SQL, 123, 456, + # SELECT * FROM db + # SQL + # ), + # third_array_value, + # ] + # + # The "internal" trailing comma is after `456`. + # The "external" trailing comma is after `)`. + # + # To autocorrect, we remove the latter, and move the former up: + # + # [ + # first_array_value, + # foo(<<-SQL, 123, 456), + # SELECT * FROM db + # SQL + # third_array_value, + # ] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#107 + def autocorrect(corrector, node); end + + # Closing parenthesis helpers. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#162 + def end_keyword_before_closing_parenthesis?(parenthesized_send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#222 + def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#289 + def external_trailing_comma?(node); end + + # Returns nil if no trailing external comma. + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#294 + def external_trailing_comma_offset_from_loc_end(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#137 + def extract_heredoc(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#133 + def extract_heredoc_argument(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#230 + def find_most_bottom_of_heredoc_end(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#179 + def fix_closing_parenthesis(node, corrector); end + + # External trailing comma helpers. + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#266 + def fix_external_trailing_comma(node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#149 + def heredoc_node?(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#197 + def incorrect_parenthesis_removal_begin(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#213 + def incorrect_parenthesis_removal_end(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#244 + def internal_trailing_comma?(node); end + + # Returns nil if no trailing internal comma. + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#249 + def internal_trailing_comma_offset_from_last_arg(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#115 + def outermost_send_on_same_line(heredoc); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#188 + def remove_incorrect_closing_paren(node, corrector); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#277 + def remove_incorrect_external_trailing_comma(node, corrector); end + + # Internal trailing comma helpers. + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#238 + def remove_internal_trailing_comma(node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#207 + def safe_to_remove_line_containing_closing_paren?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#126 + def send_missing_closing_parens?(parent, child, heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#153 + def single_line_send_with_heredoc_receiver?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#305 + def space?(pos); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#168 + def subsequent_closing_parentheses_in_same_line?(outermost_send); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#60 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#57 +RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the here document bodies. The bodies +# are indented one step. +# +# Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default), +# this cop does not add any offenses for long here documents to +# avoid `Layout/LineLength`'s offenses. +# +# @example +# # bad +# <<-RUBY +# something +# RUBY +# +# # good +# <<~RUBY +# something +# RUBY +# +# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#24 +class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#36 + def on_heredoc(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#120 + def adjust_minus(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#115 + def adjust_squiggly(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#144 + def base_indent_level(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#155 + def heredoc_body(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#159 + def heredoc_end(node); end + + # Returns '~', '-' or nil + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#151 + def heredoc_indent_type(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#126 + def indented_body(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#133 + def indented_end(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#91 + def line_too_long?(node); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#103 + def longest_line(lines); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#111 + def max_line_length; end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#69 + def message(heredoc_indent_type); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#57 + def register_offense(node, heredoc_indent_type); end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#79 + def type_message(indentation_width, current_indent_type); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#107 + def unlimited_heredoc_length?; end + + # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#87 + def width_message(indentation_width); end +end + +# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#32 +RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#34 +RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String) + +# Checks for inconsistent indentation. +# +# The difference between `indented_internal_methods` and `normal` is +# that the `indented_internal_methods` style prescribes that in +# classes and modules the `protected` and `private` modifier keywords +# shall be indented the same as public methods and that protected and +# private members shall be indented one step more than the modifiers. +# Other than that, both styles mean that entities on the same logical +# depth shall have the same indentation. +# +# @example EnforcedStyle: normal (default) +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# @example EnforcedStyle: indented_internal_methods +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#121 +class RuboCop::Cop::Layout::IndentationConsistency < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#128 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#132 + def on_kwbegin(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#138 + def autocorrect(corrector, node); end + + # Not all nodes define `bare_access_modifier?` (for example, + # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first + # to avoid a NoMethodError. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#145 + def bare_access_modifier?(node); end + + # Returns an integer representing the correct indentation, or nil to + # indicate that the correct indentation is that of the first child that + # is not an access modifier. + # + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#152 + def base_column_for_normal_style(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#172 + def check(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#187 + def check_indented_internal_methods_style(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#180 + def check_normal_style(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#126 +RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String) + +# Checks that the indentation method is consistent. +# Either tabs only or spaces only are used for indentation. +# +# @example EnforcedStyle: spaces (default) +# # bad +# # This example uses a tab to indent bar. +# def foo +# bar +# end +# +# # good +# # This example uses spaces to indent bar. +# def foo +# bar +# end +# @example EnforcedStyle: tabs +# # bad +# # This example uses spaces to indent bar. +# def foo +# bar +# end +# +# # good +# # This example uses a tab to indent bar. +# def foo +# bar +# end +# +# source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#34 +class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#42 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#58 + def autocorrect(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#82 + def autocorrect_lambda_for_spaces(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#77 + def autocorrect_lambda_for_tabs(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#66 + def find_offense(line, lineno); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#88 + def in_string_literal?(ranges, tabs_range); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#109 + def message(_node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#92 + def string_literal_ranges(ast); end +end + +# source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#40 +RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) + +# Checks for indentation that doesn't use the specified number +# of spaces. +# +# See also the IndentationConsistency cop which is the companion to this +# one. +# +# @example +# # bad +# class A +# def test +# puts 'hello' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# end +# end +# @example AllowedPatterns: ['^\s*module'] +# # bad +# module A +# class B +# def test +# puts 'hello' +# end +# end +# end +# +# # good +# module A +# class B +# def test +# puts 'hello' +# end +# end +# end +# +# source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#45 +class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#57 + def access_modifier?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#81 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#138 + def on_case(case_node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#146 + def on_case_match(case_match); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#95 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#104 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#121 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#121 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#66 + def on_ensure(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#66 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#156 + def on_if(node, base = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#73 + def on_kwbegin(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#95 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#81 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#66 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#61 + def on_rescue(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#95 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#104 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#128 + def on_until(node, base = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#128 + def on_while(node, base = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#227 + def access_modifier_indentation_style; end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#165 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#235 + def check_assignment(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#255 + def check_if(node, body, else_clause, base_loc); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#268 + def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#169 + def check_members(base, members); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#193 + def check_members_for_indented_internal_methods_style(members); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#199 + def check_members_for_normal_style(base, members); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#341 + def check_rescue?(rescue_node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#377 + def configured_indentation_width; end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#207 + def each_member(members); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#231 + def indentation_consistency_style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#323 + def indentation_to_check?(base_loc, body_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#219 + def indented_internal_methods_style?; end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#381 + def leftmost_modifier_of(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#302 + def message(configured_indentation_width, indentation, name); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#360 + def offending_range(body_node, indentation); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#278 + def offense(body_node, indentation, style); end + + # Returns true if the given node is within another node that has + # already been marked for autocorrection by this cop. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#313 + def other_offense_in_same_range?(node); end + + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#181 + def select_check_member(member); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#345 + def skip_check?(base_loc, body_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#223 + def special_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#368 + def starts_with_access_modifier?(body_node); end +end + +# source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#53 +RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String) + +# Checks for indentation of the first non-blank non-comment +# line in a file. +# +# @example +# # bad +# class A +# def foo; end +# end +# +# # good +# class A +# def foo; end +# end +# +# source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#20 +class RuboCop::Cop::Layout::InitialIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#26 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#36 + def first_token; end + + # @yield [range_between(space_range.begin_pos, token.begin_pos)] + # + # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#40 + def space_before(token); end +end + +# source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#24 +RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks whether comments have a leading space after the +# `#` denoting the start of the comment. The leading space is not +# required for some RDoc special syntax, like `#++`, `#--`, +# `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives, +# or rackup options. +# +# @example +# +# # bad +# #Some comment +# +# # good +# # Some comment +# @example AllowDoxygenCommentStyle: false (default) +# +# # bad +# +# #** +# # Some comment +# # Another line of comment +# #* +# @example AllowDoxygenCommentStyle: true +# +# # good +# +# #** +# # Some comment +# # Another line of comment +# #* +# @example AllowGemfileRubyComment: false (default) +# +# # bad +# +# #ruby=2.7.0 +# #ruby-gemset=myproject +# @example AllowGemfileRubyComment: true +# +# # good +# +# #ruby=2.7.0 +# #ruby-gemset=myproject +# +# source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#52 +class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#58 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#95 + def allow_doxygen_comment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#103 + def allow_gemfile_ruby_comment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#79 + def allowed_on_first_line?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#99 + def doxygen_comment_style?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#107 + def gemfile?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#115 + def gemfile_ruby_comment?(comment); end + + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#75 + def hash_mark(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#91 + def rackup_config_file?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#87 + def rackup_options?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#111 + def ruby_comment_in_gemfile?(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#83 + def shebang?(comment); end +end + +# source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#56 +RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary leading blank lines at the beginning +# of a file. +# +# @example +# +# # bad +# # (start of file) +# +# class Foo +# end +# +# # bad +# # (start of file) +# +# # a comment +# +# # good +# # (start of file) +# class Foo +# end +# +# # good +# # (start of file) +# # a comment +# +# source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#30 +class RuboCop::Cop::Layout::LeadingEmptyLines < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#35 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#33 +RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String) + +# Checks that strings broken over multiple lines (by a backslash) contain +# trailing spaces instead of leading spaces (default) or leading spaces +# instead of trailing spaces. +# +# @example EnforcedStyle: trailing (default) +# # bad +# 'this text contains a lot of' \ +# ' spaces' +# +# # good +# 'this text contains a lot of ' \ +# 'spaces' +# +# # bad +# 'this text is too' \ +# ' long' +# +# # good +# 'this text is too ' \ +# 'long' +# @example EnforcedStyle: leading +# # bad +# 'this text contains a lot of ' \ +# 'spaces' +# +# # good +# 'this text contains a lot of' \ +# ' spaces' +# +# # bad +# 'this text is too ' \ +# 'long' +# +# # good +# 'this text is too' \ +# ' long' +# +# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#43 +class RuboCop::Cop::Layout::LineContinuationLeadingSpace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#54 + def on_dstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#113 + def autocorrect(corrector, offense_range, insert_pos, spaces); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#106 + def continuation?(line, line_num, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#138 + def enforced_style_leading?; end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#76 + def investigate(first_line, second_line, end_of_first_line); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#84 + def investigate_leading_style(first_line, second_line, end_of_first_line); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#95 + def investigate_trailing_style(first_line, second_line, end_of_first_line); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#118 + def leading_offense_range(end_of_first_line, matches); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#130 + def message(_range); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#72 + def raw_lines(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#124 + def trailing_offense_range(end_of_first_line, matches); end +end + +# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#49 +RuboCop::Cop::Layout::LineContinuationLeadingSpace::LEADING_STYLE_OFFENSE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#47 +RuboCop::Cop::Layout::LineContinuationLeadingSpace::LINE_1_ENDING = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#48 +RuboCop::Cop::Layout::LineContinuationLeadingSpace::LINE_2_BEGINNING = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#50 +RuboCop::Cop::Layout::LineContinuationLeadingSpace::TRAILING_STYLE_OFFENSE = T.let(T.unsafe(nil), Regexp) + +# Checks that the backslash of a line continuation is separated from +# preceding text by exactly one space (default) or zero spaces. +# +# @example EnforcedStyle: space (default) +# # bad +# 'a'\ +# 'b' \ +# 'c' +# +# # good +# 'a' \ +# 'b' \ +# 'c' +# @example EnforcedStyle: no_space +# # bad +# 'a' \ +# 'b' \ +# 'c' +# +# # good +# 'a'\ +# 'b'\ +# 'c' +# +# source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#30 +class RuboCop::Cop::Layout::LineContinuationSpacing < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#34 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#81 + def autocorrect(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#111 + def comment_ranges(comments); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#65 + def find_offensive_spacing(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#121 + def ignore_range?(backtick_range); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#91 + def ignored_literal_ranges(ast); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#125 + def ignored_ranges; end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#49 + def investigate(line, line_number); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#115 + def last_line(processed_source); end + + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#73 + def message(_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#130 + def no_space_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#134 + def space_style?; end +end + +# Checks the indentation of the next line after a line that ends with a string +# literal and a backslash. +# +# If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the +# first part. There are some exceptions, such as implicit return values, where the +# concatenated string parts shall be indented regardless of `EnforcedStyle` configuration. +# +# If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step +# more than the first line. Lines 3 and forward shall be aligned with line 2. +# +# @example +# # bad +# def some_method +# 'x' \ +# 'y' \ +# 'z' +# end +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# def some_method +# 'x' \ +# 'y' \ +# 'z' +# end +# @example EnforcedStyle: aligned (default) +# # bad +# puts 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# puts 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# @example EnforcedStyle: indented +# # bad +# result = 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# result = 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#74 +class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#97 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#83 + def on_dstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#137 + def add_offense_and_correction(node, message); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#109 + def always_indented?(dstr_node); end + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#128 + def base_column(child); end + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#113 + def check_aligned(children, start_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#122 + def check_indented(children); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#103 + def strings_concatenated_with_backslash?(dstr_node); end +end + +# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#79 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#80 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_INDENT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#81 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::PARENT_TYPES_FOR_INDENTED = T.let(T.unsafe(nil), Array) + +# Checks the length of lines in the source code. +# The maximum length is configurable. +# The tab size is configured in the `IndentationWidth` +# of the `Layout/IndentationStyle` cop. +# It also ignores a shebang line by default. +# +# This cop has some autocorrection capabilities. +# It can programmatically shorten certain long lines by +# inserting line breaks into expressions that can be safely +# split across lines. These include arrays, hashes, and +# method calls with argument lists. +# +# If autocorrection is enabled, the following Layout cops +# are recommended to further format the broken lines. +# (Many of these are enabled by default.) +# +# * ArgumentAlignment +# * ArrayAlignment +# * BlockAlignment +# * BlockDelimiters +# * BlockEndNewline +# * ClosingParenthesisIndentation +# * FirstArgumentIndentation +# * FirstArrayElementIndentation +# * FirstHashElementIndentation +# * FirstParameterIndentation +# * HashAlignment +# * IndentationWidth +# * MultilineArrayLineBreaks +# * MultilineBlockLayout +# * MultilineHashBraceLayout +# * MultilineHashKeyLineBreaks +# * MultilineMethodArgumentLineBreaks +# * MultilineMethodParameterLineBreaks +# * ParameterAlignment +# +# Together, these cops will pretty print hashes, arrays, +# method calls, etc. For example, let's say the max columns +# is 25: +# +# @example +# +# # bad +# {foo: "0000000000", bar: "0000000000", baz: "0000000000"} +# +# # good +# {foo: "0000000000", +# bar: "0000000000", baz: "0000000000"} +# +# # good (with recommended cops enabled) +# { +# foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000", +# } +# +# source://rubocop//lib/rubocop/cop/layout/line_length.rb#63 +class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckLineBreakable + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#74 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#94 + def on_investigation_end; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#88 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#74 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80 + def on_potential_breakable_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#219 + def allow_heredoc?; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#223 + def allowed_heredoc; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#183 + def allowed_line?(line, line_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#135 + def breakable_block_range(block_node); end + + # Returns the value of attribute breakable_range. + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#102 + def breakable_range; end + + # Sets the attribute breakable_range + # + # @param value the value to set the attribute breakable_range to. + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#102 + def breakable_range=(_arg0); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#143 + def breakable_range_after_semicolon(semicolon_token); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#156 + def breakable_range_by_line_index; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#250 + def check_directive_line(line, line_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#125 + def check_for_breakable_block(block_node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#104 + def check_for_breakable_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#117 + def check_for_breakable_semicolons(processed_source); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#171 + def check_line(line, line_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#267 + def check_uri_line(line, line_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#204 + def excess_range(uri_range, line, line_index); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#227 + def extract_heredocs(ast); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#160 + def heredocs; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#164 + def highlight_start(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#246 + def line_in_heredoc?(line_number); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#237 + def line_in_permitted_heredoc?(line_number); end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#215 + def max; end + + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#193 + def register_offense(loc, line, line_index, length: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/line_length.rb#189 + def shebang?(line, line_index); end +end + +# source://rubocop//lib/rubocop/cop/layout/line_length.rb#72 +RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String) + +# Checks that the closing brace in an array literal is either +# on the same line as the last array element or on a new line. +# +# When using the `symmetrical` (default) style: +# +# If an array's opening brace is on the same line as the first element +# of the array, then the closing brace should be on the same line as +# the last element of the array. +# +# If an array's opening brace is on the line above the first element +# of the array, then the closing brace should be on the line below +# the last element of the array. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line array literal must be on the line +# after the last element of the array. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line array literal must be on the same +# line as the last element of the array. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# [ :a, +# :b +# ] +# +# # bad +# [ +# :a, +# :b ] +# +# # good +# [ :a, +# :b ] +# +# # good +# [ +# :a, +# :b +# ] +# @example EnforcedStyle: new_line +# # bad +# [ +# :a, +# :b ] +# +# # bad +# [ :a, +# :b ] +# +# # good +# [ :a, +# :b +# ] +# +# # good +# [ +# :a, +# :b +# ] +# @example EnforcedStyle: same_line +# # bad +# [ :a, +# :b +# ] +# +# # bad +# [ +# :a, +# :b +# ] +# +# # good +# [ +# :a, +# :b ] +# +# # good +# [ :a, +# :b ] +# +# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#91 +class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#109 + def on_array(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#103 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#106 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#99 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#95 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each item in a multi-line array +# starts on a separate line. +# +# @example +# +# # bad +# [ +# a, b, +# c +# ] +# +# # good +# [ +# a, +# b, +# c +# ] +# +# # good +# [ +# a, +# b, +# foo( +# bar +# ) +# ] +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# [a, b, foo( +# bar +# )] +# @example AllowMultilineFinalElement: true +# +# # good +# [a, b, foo( +# bar +# )] +# +# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#47 +class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#53 + def on_array(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#59 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#51 +RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the multiline assignments have a newline +# after the assignment operator. +# +# @example EnforcedStyle: new_line (default) +# # bad +# foo = if expression +# 'bar' +# end +# +# # good +# foo = +# if expression +# 'bar' +# end +# +# # good +# foo = +# begin +# compute +# rescue => e +# nil +# end +# @example EnforcedStyle: same_line +# # good +# foo = if expression +# 'bar' +# end +# @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default) +# # good +# foo = +# if expression +# 'bar' +# end +# +# # good +# foo = +# [1].map do |i| +# i + 1 +# end +# @example SupportedTypes: ['block'] +# # good +# foo = if expression +# 'bar' +# end +# +# # good +# foo = +# [1].map do |i| +# 'bar' * i +# end +# +# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#60 +class RuboCop::Cop::Layout::MultilineAssignmentLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#72 + def check_assignment(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#81 + def check_by_enforced_style(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#90 + def check_new_line_offense(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#98 + def check_same_line_offense(node, rhs); end + + private + + # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#111 + def supported_types; end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#66 +RuboCop::Cop::Layout::MultilineAssignmentLayout::NEW_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#69 +RuboCop::Cop::Layout::MultilineAssignmentLayout::SAME_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +# Checks whether the multiline do end blocks have a newline +# after the start of the block. Additionally, it checks whether the block +# arguments, if any, are on the same line as the start of the +# block. Putting block arguments on separate lines, because the whole +# line would otherwise be too long, is accepted. +# +# @example +# # bad +# blah do |i| foo(i) +# bar(i) +# end +# +# # bad +# blah do +# |i| foo(i) +# bar(i) +# end +# +# # good +# blah do |i| +# foo(i) +# bar(i) +# end +# +# # bad +# blah { |i| foo(i) +# bar(i) +# } +# +# # good +# blah { |i| +# foo(i) +# bar(i) +# } +# +# # good +# blah { | +# long_list, +# of_parameters, +# that_would_not, +# fit_on_one_line +# | +# foo(i) +# bar(i) +# } +# +# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#51 +class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#59 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#59 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#98 + def add_offense_for_expression(node, expr, msg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#75 + def args_on_beginning_line?(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#105 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#120 + def autocorrect_arguments(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#130 + def autocorrect_body(corrector, node, block_body); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#142 + def block_arg_string(node, args); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#90 + def characters_needed_for_space_and_pipes(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#154 + def include_trailing_comma?(args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#79 + def line_break_necessary_in_args?(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#83 + def needed_length_for_args(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#56 +RuboCop::Cop::Layout::MultilineBlockLayout::ARG_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#55 +RuboCop::Cop::Layout::MultilineBlockLayout::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#57 +RuboCop::Cop::Layout::MultilineBlockLayout::PIPE_SIZE = T.let(T.unsafe(nil), Integer) + +# Checks that the closing brace in a hash literal is either +# on the same line as the last hash element, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a hash's opening brace is on the same line as the first element +# of the hash, then the closing brace should be on the same line as +# the last element of the hash. +# +# If a hash's opening brace is on the line above the first element +# of the hash, then the closing brace should be on the line below +# the last element of the hash. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line hash literal must be on the line +# after the last element of the hash. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line hash literal must be on the same +# line as the last element of the hash. +# +# @example EnforcedStyle: symmetrical (default) +# +# # bad +# { a: 1, +# b: 2 +# } +# # bad +# { +# a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 } +# +# # good +# { +# a: 1, +# b: 2 +# } +# @example EnforcedStyle: new_line +# # bad +# { +# a: 1, +# b: 2 } +# +# # bad +# { a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 +# } +# +# # good +# { +# a: 1, +# b: 2 +# } +# @example EnforcedStyle: same_line +# # bad +# { a: 1, +# b: 2 +# } +# +# # bad +# { +# a: 1, +# b: 2 +# } +# +# # good +# { +# a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 } +# +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#91 +class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#109 + def on_hash(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#103 +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#106 +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#99 +RuboCop::Cop::Layout::MultilineHashBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#95 +RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each key in a multi-line hash +# starts on a separate line. +# +# @example +# +# # bad +# { +# a: 1, b: 2, +# c: 3 +# } +# +# # good +# { +# a: 1, +# b: 2, +# c: 3 +# } +# +# # good +# { +# a: 1, +# b: { +# c: 3, +# } +# } +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# { a: 1, b: { +# c: 3, +# }} +# @example AllowMultilineFinalElement: true +# +# # good +# { a: 1, b: { +# c: 3, +# }} +# +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#46 +class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#52 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#68 + def ignore_last_element?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#64 + def starts_with_curly_brace?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#50 +RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Ensures that each argument in a multi-line method call +# starts on a separate line. +# +# NOTE: This cop does not move the first argument, if you want that to +# be on a separate line, see `Layout/FirstMethodArgumentLineBreak`. +# +# @example +# +# # bad +# foo(a, b, +# c +# ) +# +# # bad +# foo(a, b, { +# foo: "bar", +# }) +# +# # good +# foo( +# a, +# b, +# c +# ) +# +# # good +# foo(a, b, c) +# @example AllowMultilineFinalElement: false (default) +# +# # good +# foo( +# a, +# b, +# { +# foo: "bar", +# } +# ) +# @example AllowMultilineFinalElement: true +# +# # good +# foo( +# a, +# b, +# { +# foo: "bar", +# } +# ) +# +# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#56 +class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#62 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#81 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#60 +RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks that the closing brace in a method call is either +# on the same line as the last method argument, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a method call's opening brace is on the same line as the first +# argument of the call, then the closing brace should be on the same +# line as the last argument of the call. +# +# If an method call's opening brace is on the line above the first +# argument of the call, then the closing brace should be on the line +# below the last argument of the call. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line method call must be on the line +# after the last argument of the call. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line method call must be on the same +# line as the last argument of the call. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# foo(a, +# b +# ) +# +# # bad +# foo( +# a, +# b) +# +# # good +# foo(a, +# b) +# +# # good +# foo( +# a, +# b +# ) +# @example EnforcedStyle: new_line +# # bad +# foo( +# a, +# b) +# +# # bad +# foo(a, +# b) +# +# # good +# foo(a, +# b +# ) +# +# # good +# foo( +# a, +# b +# ) +# @example EnforcedStyle: same_line +# # bad +# foo(a, +# b +# ) +# +# # bad +# foo( +# a, +# b +# ) +# +# # good +# foo( +# a, +# b) +# +# # good +# foo(a, +# b) +# +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#91 +class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#109 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#115 + def children(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#119 + def ignored_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#123 + def single_line_ignoring_receiver?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#103 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#106 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#99 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#95 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Checks the indentation of the method name part in method calls +# that span more than one line. +# +# @example EnforcedStyle: aligned (default) +# # bad +# while myvariable +# .b +# # do something +# end +# +# # good +# while myvariable +# .b +# # do something +# end +# +# # good +# Thing.a +# .b +# .c +# @example EnforcedStyle: indented +# # good +# while myvariable +# .b +# +# # do something +# end +# @example EnforcedStyle: indented_relative_to_receiver +# # good +# while myvariable +# .a +# .b +# +# # do something +# end +# +# # good +# myvariable = Thing +# .a +# .b +# .c +# +# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#49 +class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + extend ::RuboCop::Cop::AutoCorrector + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#55 + def validate_config; end + + private + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#136 + def align_with_base_message(rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#152 + def alignment_base(node, rhs, given_style); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#67 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#140 + def base_source; end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#101 + def extra_indentation(given_style, parent); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#226 + def find_multiline_block_chain_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#237 + def first_call_has_a_dot(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#217 + def get_dot_right_above(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#113 + def message(node, lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#144 + def no_base_message(lhs, rhs, node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#87 + def offending_range(node, lhs, rhs, given_style); end + + # @yield [operation_rhs.first_argument] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#247 + def operation_rhs(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#257 + def operator_rhs?(node, receiver); end + + # a + # .b + # .c + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#193 + def receiver_alignment_base(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#131 + def relative_to_receiver_message(rhs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#71 + def relevant_node?(send_node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#75 + def right_hand_side(send_node); end + + # a.b + # .c + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#181 + def semantic_alignment_base(node, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#201 + def semantic_alignment_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#127 + def should_align_with_base?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#123 + def should_indent_relative_to_receiver?; end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#163 + def syntactic_alignment_base(lhs, rhs); end +end + +# Checks that the closing brace in a method definition is either +# on the same line as the last method parameter, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a method definition's opening brace is on the same line as the +# first parameter of the definition, then the closing brace should be +# on the same line as the last parameter of the definition. +# +# If an method definition's opening brace is on the line above the first +# parameter of the definition, then the closing brace should be on the +# line below the last parameter of the definition. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line method definition must be on the line +# after the last parameter of the definition. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line method definition must be on the same +# line as the last parameter of the definition. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# def foo(a, +# b +# ) +# end +# +# # bad +# def foo( +# a, +# b) +# end +# +# # good +# def foo(a, +# b) +# end +# +# # good +# def foo( +# a, +# b +# ) +# end +# @example EnforcedStyle: new_line +# # bad +# def foo( +# a, +# b) +# end +# +# # bad +# def foo(a, +# b) +# end +# +# # good +# def foo(a, +# b +# ) +# end +# +# # good +# def foo( +# a, +# b +# ) +# end +# @example EnforcedStyle: same_line +# # bad +# def foo(a, +# b +# ) +# end +# +# # bad +# def foo( +# a, +# b +# ) +# end +# +# # good +# def foo( +# a, +# b) +# end +# +# # good +# def foo(a, +# b) +# end +# +# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#103 +class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#121 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#121 + def on_defs(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#115 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#118 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#111 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#107 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each parameter in a multi-line method definition +# starts on a separate line. +# +# NOTE: This cop does not move the first argument, if you want that to +# be on a separate line, see `Layout/FirstMethodParameterLineBreak`. +# +# @example +# +# # bad +# def foo(a, b, +# c +# ) +# end +# +# # good +# def foo( +# a, +# b, +# c +# ) +# end +# +# # good +# def foo( +# a, +# b = { +# foo: "bar", +# } +# ) +# end +# +# # good +# def foo(a, b, c) +# end +# @example AllowMultilineFinalElement: false (default) +# +# # bad +# def foo(a, b = { +# foo: "bar", +# }) +# end +# @example AllowMultilineFinalElement: true +# +# # good +# def foo(a, b = { +# foo: "bar", +# }) +# end +# +# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#57 +class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#63 + def on_def(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#71 + def ignore_last_element?; end +end + +# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#61 +RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the right hand side operand in binary operations that +# span more than one line. +# +# The `aligned` style checks that operators are aligned if they are part of an `if` or `while` +# condition, an explicit `return` statement, etc. In other contexts, the second operand should +# be indented regardless of enforced style. +# +# @example EnforcedStyle: aligned (default) +# # bad +# if a + +# b +# something && +# something_else +# end +# +# # good +# if a + +# b +# something && +# something_else +# end +# @example EnforcedStyle: indented +# # bad +# if a + +# b +# something && +# something_else +# end +# +# # good +# if a + +# b +# something && +# something_else +# end +# +# source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#43 +class RuboCop::Cop::Layout::MultilineOperationIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#49 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#53 + def on_or(node); end + + # @raise [ValidationError] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#57 + def validate_config; end + + private + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#68 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#78 + def check_and_or(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#110 + def message(node, lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#84 + def offending_range(node, lhs, rhs, given_style); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#72 + def relevant_node?(node); end + + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#121 + def right_hand_side(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#97 + def should_align?(node, rhs, given_style); end +end + +# Here we check if the parameters on a multi-line method call or +# definition are aligned. +# +# To set the alignment of the first argument, use the cop +# FirstParameterIndentation. +# +# @example EnforcedStyle: with_first_parameter (default) +# # good +# +# def foo(bar, +# baz) +# 123 +# end +# +# def foo( +# bar, +# baz +# ) +# 123 +# end +# +# # bad +# +# def foo(bar, +# baz) +# 123 +# end +# +# # bad +# +# def foo( +# bar, +# baz) +# 123 +# end +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# def foo(bar, +# baz) +# 123 +# end +# +# def foo( +# bar, +# baz +# ) +# 123 +# end +# +# # bad +# +# def foo(bar, +# baz) +# 123 +# end +# +# # bad +# +# def foo( +# bar, +# baz) +# 123 +# end +# +# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#71 +class RuboCop::Cop::Layout::ParameterAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#81 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#81 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#90 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#102 + def base_column(node, args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#98 + def fixed_indentation?; end + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#94 + def message(_node); end + + # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#113 + def target_method_lineno(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#75 +RuboCop::Cop::Layout::ParameterAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#78 +RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Checks whether certain expressions, e.g. method calls, that could fit +# completely on a single line, are broken up into multiple lines unnecessarily. +# +# @example any configuration +# # bad +# foo( +# a, +# b +# ) +# +# puts 'string that fits on ' \ +# 'a single line' +# +# things +# .select { |thing| thing.cond? } +# .join('-') +# +# # good +# foo(a, b) +# +# puts 'string that fits on a single line' +# +# things.select { |thing| thing.cond? }.join('-') +# @example InspectBlocks: false (default) +# # good +# foo(a) do |x| +# puts x +# end +# @example InspectBlocks: true +# # bad +# foo(a) do |x| +# puts x +# end +# +# # good +# foo(a) { |x| puts x } +# +# source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#45 +class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#51 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#55 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#72 + def check_assignment(node, _rhs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#120 + def comment_within?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#90 + def configured_to_not_be_inspected?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#114 + def convertible_block?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#68 + def end_with_percent_blank_string?(processed_source); end + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#142 + def max_line_length; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#85 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#97 + def other_cop_takes_precedence?(node); end + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#78 + def register_offense(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#103 + def single_line_block_chain_enabled?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#107 + def suitable_as_single_line?(node); end + + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#133 + def to_single_line(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#128 + def too_long?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#49 +RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the rescue and ensure keywords are aligned +# properly. +# +# @example +# +# # bad +# begin +# something +# rescue +# puts 'error' +# end +# +# # good +# begin +# something +# rescue +# puts 'error' +# end +# +# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#24 +class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#40 + def on_ensure(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#44 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#36 + def on_resbody(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#186 + def access_modifier?(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#163 + def access_modifier_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#149 + def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#136 + def aligned_with_line_break_method?(ancestor_node, node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#195 + def alignment_location(alignment_node); end + + # We will use ancestor or wrapper with access modifier. + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#116 + def alignment_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#95 + def alignment_source(node, starting_loc); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#132 + def ancestor_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#155 + def assignment_node(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#73 + def autocorrect(corrector, node, alignment_location); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#203 + def begin_end_alignment_style; end + + # Check alignment of node with rescue or ensure modifiers. + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#57 + def check(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#83 + def format_message(alignment_node, alignment_loc, kw_loc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#173 + def modifier?(node); end + + # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#179 + def whitespace_range(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#34 +RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#32 +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#33 +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#29 +RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks if method calls are chained onto single line blocks. It considers that a +# line break before the dot improves the readability of the code. +# +# @example +# # bad +# example.select { |item| item.cond? }.join('-') +# +# # good +# example.select { |item| item.cond? } +# .join('-') +# +# # good (not a concern for this cop) +# example.select do |item| +# item.cond? +# end.join('-') +# +# source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#22 +class RuboCop::Cop::Layout::SingleLineBlockChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#32 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#55 + def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end + + # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#39 + def offending_range(node); end + + # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#61 + def selector_range(node); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#28 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#26 +RuboCop::Cop::Layout::SingleLineBlockChain::MSG = T.let(T.unsafe(nil), String) + +# Checks for colon (:) not followed by some kind of space. +# N.B. this cop does not handle spaces after a ternary operator, which are +# instead handled by Layout/SpaceAroundOperators. +# +# @example +# # bad +# def f(a:, b:2); {a:3}; end +# +# # good +# def f(a:, b: 2); {a: 3}; end +# +# source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#16 +class RuboCop::Cop::Layout::SpaceAfterColon < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#29 + def on_kwoptarg(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#21 + def on_pair(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#43 + def followed_by_space?(colon); end + + # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#39 + def register_offense(colon); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#19 +RuboCop::Cop::Layout::SpaceAfterColon::MSG = T.let(T.unsafe(nil), String) + +# Checks for comma (,) not followed by some kind of space. +# +# @example +# +# # bad +# [1,2] +# { foo:bar,} +# +# # good +# [1, 2] +# { foo:bar, } +# +# source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#17 +class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SpaceAfterPunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#26 + def kind(token); end + + # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#21 + def space_style_before_rcurly; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#32 + def before_semicolon?(token); end +end + +# Checks for space between a method name and a left parenthesis in defs. +# +# @example +# +# # bad +# def func (x) end +# def method= (y) end +# +# # good +# def func(x) end +# def method=(y) end +# +# source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#17 +class RuboCop::Cop::Layout::SpaceAfterMethodName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#23 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#23 + def on_defs(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#21 +RuboCop::Cop::Layout::SpaceAfterMethodName::MSG = T.let(T.unsafe(nil), String) + +# Checks for space after `!`. +# +# @example +# # bad +# ! something +# +# # good +# !something +# +# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#14 +class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#21 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#33 + def whitespace_after_operator?(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#18 +RuboCop::Cop::Layout::SpaceAfterNot::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#19 +RuboCop::Cop::Layout::SpaceAfterNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for semicolon (;) not followed by some kind of space. +# +# @example +# # bad +# x = 1;y = 2 +# +# # good +# x = 1; y = 2 +# +# source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#14 +class RuboCop::Cop::Layout::SpaceAfterSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SpaceAfterPunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#23 + def kind(token); end + + # source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#18 + def space_style_before_rcurly; end +end + +# Checks the spacing inside and after block parameters pipes. Line breaks +# inside parameter pipes are checked by `Layout/MultilineBlockLayout` and +# not by this cop. +# +# @example EnforcedStyleInsidePipes: no_space (default) +# # bad +# {}.each { | x, y |puts x } +# ->( x, y ) { puts x } +# +# # good +# {}.each { |x, y| puts x } +# ->(x, y) { puts x } +# @example EnforcedStyleInsidePipes: space +# # bad +# {}.each { |x, y| puts x } +# ->(x, y) { puts x } +# +# # good +# {}.each { | x, y | puts x } +# ->( x, y ) { puts x } +# +# source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#27 +class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#32 + def on_block(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#65 + def check_after_closing_pipe(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#125 + def check_arg(arg); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#103 + def check_closing_pipe_space(arguments, closing_pipe); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#121 + def check_each_arg(args); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#56 + def check_inside_pipes(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#150 + def check_no_space(space_begin_pos, space_end_pos, msg); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#73 + def check_no_space_style_inside_pipes(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#92 + def check_opening_pipe_space(arguments, opening_pipe); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#136 + def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#85 + def check_space_style_inside_pipes(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#113 + def last_end_pos_inside_pipes(arguments, range); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#44 + def pipes(arguments); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#48 + def pipes?(arguments); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#52 + def style_parameter_name; end +end + +# Checks that the equals signs in parameter default assignments +# have or don't have surrounding space depending on configuration. +# +# @example EnforcedStyle: space (default) +# # bad +# def some_method(arg1=:default, arg2=nil, arg3=[]) +# # do something... +# end +# +# # good +# def some_method(arg1 = :default, arg2 = nil, arg3 = []) +# # do something... +# end +# @example EnforcedStyle: no_space +# # bad +# def some_method(arg1 = :default, arg2 = nil, arg3 = []) +# # do something... +# end +# +# # good +# def some_method(arg1=:default, arg2=nil, arg3=[]) +# # do something... +# end +# +# source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#30 +class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#38 + def on_optarg(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#67 + def autocorrect(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#46 + def check_optarg(arg, equals, value); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#58 + def incorrect_style_detected(arg, value); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#83 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#79 + def no_surrounding_space?(arg, equals); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#75 + def space_on_both_sides?(arg, equals); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#36 +RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::MSG = T.let(T.unsafe(nil), String) + +# Checks the spacing around the keywords. +# +# @example +# +# # bad +# something 'test'do|x| +# end +# +# while(something) +# end +# +# something = 123if test +# +# # good +# something 'test' do |x| +# end +# +# while (something) +# end +# +# something = 123 if test +# +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#27 +class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#40 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#44 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#48 + def on_break(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#52 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#56 + def on_case_match(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#156 + def on_defined?(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#60 + def on_ensure(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#64 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#68 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#72 + def on_if_guard(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#76 + def on_in_pattern(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#80 + def on_kwbegin(node); end + + # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby27`. + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#85 + def on_match_pattern(node); end + + # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby30`. + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#92 + def on_match_pattern_p(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#96 + def on_next(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#100 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#104 + def on_postexe(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#108 + def on_preexe(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#112 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#116 + def on_rescue(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#120 + def on_return(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#124 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#128 + def on_super(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#136 + def on_unless_guard(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#140 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#144 + def on_when(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#148 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#152 + def on_yield(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#132 + def on_zsuper(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#235 + def accept_left_parenthesis?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#239 + def accept_left_square_bracket?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#243 + def accept_namespace_operator?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#228 + def accepted_opening_delimiter?(range, char); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#162 + def check(node, locations, begin_keyword = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#177 + def check_begin(node, range, begin_keyword); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#183 + def check_end(node, range, begin_keyword); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#196 + def check_keyword(node, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#192 + def do?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#251 + def namespace_operator?(range, pos); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#255 + def preceded_by_operator?(node, _range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#247 + def safe_navigation_call?(range, pos); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#217 + def space_after_missing?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#210 + def space_before_missing?(range); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#36 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_PAREN = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#37 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_SQUARE_BRACKET = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#38 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#33 +RuboCop::Cop::Layout::SpaceAroundKeyword::DO = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#31 +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#30 +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_BEFORE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#35 +RuboCop::Cop::Layout::SpaceAroundKeyword::NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#34 +RuboCop::Cop::Layout::SpaceAroundKeyword::SAFE_NAVIGATION = T.let(T.unsafe(nil), String) + +# Checks method call operators to not have spaces around them. +# +# @example +# # bad +# foo. bar +# foo .bar +# foo . bar +# foo. bar .buzz +# foo +# . bar +# . buzz +# foo&. bar +# foo &.bar +# foo &. bar +# foo &. bar&. buzz +# RuboCop:: Cop +# RuboCop:: Cop:: Base +# :: RuboCop::Cop +# +# # good +# foo.bar +# foo.bar.buzz +# foo +# .bar +# .buzz +# foo&.bar +# foo&.bar&.buzz +# RuboCop::Cop +# RuboCop::Cop::Base +# ::RuboCop::Cop +# +# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#37 +class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#53 + def on_const(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#45 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#45 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#87 + def check_space(begin_pos, end_pos); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#67 + def check_space_after_dot(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#81 + def check_space_after_double_colon(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#61 + def check_space_before_dot(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#43 +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#41 +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SPACES_REGEXP = T.let(T.unsafe(nil), Regexp) + +# Checks that operators have space around them, except for ** which +# should or shouldn't have surrounding space depending on configuration. +# It allows vertical alignment consisting of one or more whitespace +# around operators. +# +# This cop has `AllowForAlignment` option. When `true`, allows most +# uses of extra spacing if the intent is to align with an operator on +# the previous or next line, not counting empty lines or comment lines. +# +# @example +# # bad +# total = 3*4 +# "apple"+"juice" +# my_number = 38/4 +# +# # good +# total = 3 * 4 +# "apple" + "juice" +# my_number = 38 / 4 +# @example AllowForAlignment: true (default) +# # good +# { +# 1 => 2, +# 11 => 3 +# } +# @example AllowForAlignment: false +# # bad +# { +# 1 => 2, +# 11 => 3 +# } +# @example EnforcedStyleForExponentOperator: no_space (default) +# # bad +# a ** b +# +# # good +# a**b +# @example EnforcedStyleForExponentOperator: space +# # bad +# a**b +# +# # good +# a ** b +# @example EnforcedStyleForRationalLiterals: no_space (default) +# # bad +# 1 / 48r +# +# # good +# 1/48r +# @example EnforcedStyleForRationalLiterals: space +# # bad +# 1/48r +# +# # good +# 1 / 48r +# +# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#67 +class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RationalLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_assignment(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133 + def on_binary(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#125 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#92 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#149 + def on_match_pattern(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#141 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#84 + def on_pair(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#99 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#80 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#107 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#141 + def on_special_asgn(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#256 + def align_hash_cop_config; end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#195 + def autocorrect(corrector, range, right_operand); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#179 + def check_operator(type, operator, right_operand); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#209 + def enclose_operator_with_space(corrector, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#236 + def excess_leading_space?(type, operator, with_space); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#251 + def excess_trailing_space?(right_operand, with_space); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#274 + def force_equal_sign_alignment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#260 + def hash_table_style?; end + + # @yield [msg] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#190 + def offense(type, operator, with_space, right_operand); end + + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#222 + def offense_message(type, operator, with_space, right_operand); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#175 + def operator_with_regular_syntax?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#169 + def regular_operator?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#278 + def should_not_have_surrounding_space?(operator, right_operand); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#264 + def space_around_exponent_operator?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#268 + def space_around_slash_operator?(right_operand); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#76 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#74 +RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#73 +RuboCop::Cop::Layout::SpaceAroundOperators::IRREGULAR_METHODS = T.let(T.unsafe(nil), Array) + +# Checks that block braces have or don't have a space before the opening +# brace depending on configuration. +# +# @example EnforcedStyle: space (default) +# # bad +# foo.map{ |a| +# a.bar.to_s +# } +# +# # good +# foo.map { |a| +# a.bar.to_s +# } +# @example EnforcedStyle: no_space +# # bad +# foo.map { |a| +# a.bar.to_s +# } +# +# # good +# foo.map{ |a| +# a.bar.to_s +# } +# @example EnforcedStyleForEmptyBraces: space (default) +# # bad +# 7.times{} +# +# # good +# 7.times {} +# @example EnforcedStyleForEmptyBraces: no_space +# # bad +# 7.times {} +# +# # good +# 7.times{} +# +# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#44 +class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#56 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#56 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#124 + def autocorrect(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#144 + def block_delimiters_style; end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#83 + def check_empty(left_brace, space_plus_brace, used_style); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#100 + def check_non_empty(left_brace, space_plus_brace, used_style); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#140 + def conflict_with_block_delimiters?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#148 + def empty_braces?(loc); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#115 + def space_detected(left_brace, space_plus_brace); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#108 + def space_missing(left_brace); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#131 + def style_for_empty_braces; end + + class << self + # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#52 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#50 +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#49 +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String) + +# Checks for space between the name of a receiver and a left +# brackets. +# +# @example +# +# # bad +# collection [index_or_key] +# +# # good +# collection[index_or_key] +# +# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#17 +class RuboCop::Cop::Layout::SpaceBeforeBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#48 + def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#35 + def offense_range(node, begin_pos); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#54 + def offense_range_for_assignment(node, begin_pos); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#67 + def reference_variable_with_brackets?(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#63 + def register_offense(range); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#21 +RuboCop::Cop::Layout::SpaceBeforeBrackets::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#22 +RuboCop::Cop::Layout::SpaceBeforeBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for comma (,) preceded by space. +# +# @example +# # bad +# [1 , 2 , 3] +# a(1 , 2) +# each { |a , b| } +# +# # good +# [1, 2, 3] +# a(1, 2) +# each { |a, b| } +# +# source://rubocop//lib/rubocop/cop/layout/space_before_comma.rb#19 +class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SpaceBeforePunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_comma.rb#23 + def kind(token); end +end + +# Checks for missing space between a token and a comment on the +# same line. +# +# @example +# # bad +# 1 + 1# this operation does ... +# +# # good +# 1 + 1 # this operation does ... +# +# source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#15 +class RuboCop::Cop::Layout::SpaceBeforeComment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#20 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#18 +RuboCop::Cop::Layout::SpaceBeforeComment::MSG = T.let(T.unsafe(nil), String) + +# Checks that exactly one space is used between a method name and the +# first argument for method calls without parentheses. +# +# Alternatively, extra spaces can be added to align the argument with +# something on a preceding or following line, if the AllowForAlignment +# config parameter is true. +# +# @example +# # bad +# something x +# something y, z +# something'hello' +# +# # good +# something x +# something y, z +# something 'hello' +# +# source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#24 +class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#35 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#55 + def expect_params_after_method_name?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#64 + def no_space_between_method_name_and_first_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#51 + def regular_method_call_with_arguments?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#29 +RuboCop::Cop::Layout::SpaceBeforeFirstArg::MSG = T.let(T.unsafe(nil), String) + +# Checks for semicolon (;) preceded by space. +# +# @example +# # bad +# x = 1 ; y = 2 +# +# # good +# x = 1; y = 2 +# +# source://rubocop//lib/rubocop/cop/layout/space_before_semicolon.rb#14 +class RuboCop::Cop::Layout::SpaceBeforeSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SpaceBeforePunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_before_semicolon.rb#18 + def kind(token); end +end + +# Checks for spaces between `->` and opening parameter +# parenthesis (`(`) in lambda literals. +# +# @example EnforcedStyle: require_no_space (default) +# # bad +# a = -> (x, y) { x + y } +# +# # good +# a = ->(x, y) { x + y } +# @example EnforcedStyle: require_space +# # bad +# a = ->(x, y) { x + y } +# +# # good +# a = -> (x, y) { x + y } +# +# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#22 +class RuboCop::Cop::Layout::SpaceInLambdaLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#30 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#50 + def arrow_lambda_with_args?(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#72 + def lambda_arguments(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#65 + def range_of_offense(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#58 + def space_after_arrow(lambda_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#54 + def space_after_arrow?(lambda_node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#28 +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_NO_SPACE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#27 +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_SPACE = T.let(T.unsafe(nil), String) + +# Checks that brackets used for array literals have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that array literals have +# # no surrounding space. +# +# # bad +# array = [ a, b, c, d ] +# +# # good +# array = [a, b, c, d] +# @example EnforcedStyle: space +# # The `space` style enforces that array literals have +# # surrounding space. +# +# # bad +# array = [a, b, c, d] +# +# # good +# array = [ a, b, c, d ] +# @example EnforcedStyle: compact +# # The `compact` style normally requires a space inside +# # array brackets, with the exception that successive left +# # or right brackets are collapsed together in nested arrays. +# +# # bad +# array = [ a, [ b, c ] ] +# array = [ +# [ a ], +# [ b, c ] +# ] +# +# # good +# array = [ a, [ b, c ]] +# array = [[ a ], +# [ b, c ]] +# @example EnforcedStyleForEmptyBrackets: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBrackets style enforces that +# # empty array brackets do not contain spaces. +# +# # bad +# foo = [ ] +# bar = [ ] +# +# # good +# foo = [] +# bar = [] +# @example EnforcedStyleForEmptyBrackets: space +# # The `space` EnforcedStyleForEmptyBrackets style enforces that +# # empty array brackets contain exactly one space. +# +# # bad +# foo = [] +# bar = [ ] +# +# # good +# foo = [ ] +# bar = [ ] +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#70 +class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#78 + def on_array(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#109 + def array_brackets(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#95 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#217 + def compact(corrector, bracket, side); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#203 + def compact_corrections(corrector, node, left, right); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#195 + def compact_offense(node, token, side: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#157 + def compact_offenses(node, left, right, start_ok, end_ok); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#118 + def empty_config; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#126 + def end_has_own_line?(token); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#133 + def index_for(node, token); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#141 + def issue_offenses(node, left, right, start_ok, end_ok); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#137 + def line_and_column_for(token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#178 + def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#189 + def next_to_bracket?(token, side: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#153 + def next_to_comment?(node, token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#122 + def next_to_newline?(node, token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#170 + def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#76 +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#75 +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary additional spaces inside array percent literals +# (i.e. %i/%w). +# +# Note that blank percent literals (e.g. `%i( )`) are checked by +# `Layout/SpaceInsidePercentLiteralDelimiters`. +# +# @example +# +# # bad +# %w(foo bar baz) +# # good +# %i(foo bar baz) +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#18 +class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#26 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#30 + def on_percent_literal(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#40 + def each_unnecessary_space_match(node, &blk); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#23 +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#24 +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks that block braces have or don't have surrounding space inside +# them on configuration. For blocks taking parameters, it checks that the +# left brace has or doesn't have trailing space depending on +# configuration. +# +# @example EnforcedStyle: space (default) +# # The `space` style enforces that block braces have +# # surrounding space. +# +# # bad +# some_array.each {puts e} +# +# # good +# some_array.each { puts e } +# @example EnforcedStyle: no_space +# # The `no_space` style enforces that block braces don't +# # have surrounding space. +# +# # bad +# some_array.each { puts e } +# +# # good +# some_array.each {puts e} +# @example EnforcedStyleForEmptyBraces: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBraces style enforces that +# # block braces don't have a space in between when empty. +# +# # bad +# some_array.each { } +# some_array.each { } +# some_array.each { } +# +# # good +# some_array.each {} +# @example EnforcedStyleForEmptyBraces: space +# # The `space` EnforcedStyleForEmptyBraces style enforces that +# # block braces have at least a space in between when empty. +# +# # bad +# some_array.each {} +# +# # good +# some_array.each { } +# some_array.each { } +# some_array.each { } +# @example SpaceBeforeBlockParameters: true (default) +# # The SpaceBeforeBlockParameters style set to `true` enforces that +# # there is a space between `{` and `|`. Overrides `EnforcedStyle` +# # if there is a conflict. +# +# # bad +# [1, 2, 3].each {|n| n * 2 } +# +# # good +# [1, 2, 3].each { |n| n * 2 } +# @example SpaceBeforeBlockParameters: false +# # The SpaceBeforeBlockParameters style set to `false` enforces that +# # there is no space between `{` and `|`. Overrides `EnforcedStyle` +# # if there is a conflict. +# +# # bad +# [1, 2, 3].each { |n| n * 2 } +# +# # good +# [1, 2, 3].each {|n| n * 2 } +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#79 +class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#85 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#85 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#122 + def adjacent_braces(left_brace, right_brace); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#161 + def aligned_braces?(inner, right_brace, column); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#130 + def braces_with_contents_inside(node, inner); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#105 + def check_inside(node, left_brace, right_brace); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#137 + def check_left_brace(inner, left_brace, args_delimiter); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#145 + def check_right_brace(node, inner, left_brace, right_brace, single_line); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#165 + def inner_last_space_count(inner); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#157 + def multiline_block?(left_brace, right_brace); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#222 + def no_space(begin_pos, end_pos, msg); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#169 + def no_space_inside_left_brace(left_brace, args_delimiter); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#238 + def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#201 + def pipe?(args_delimiter); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#230 + def space(begin_pos, end_pos, msg); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#186 + def space_inside_left_brace(left_brace, args_delimiter); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#205 + def space_inside_right_brace(inner, right_brace, column); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#253 + def style_for_empty_braces; end +end + +# Checks that braces used for hash literals have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: space (default) +# # The `space` style enforces that hash literals have +# # surrounding space. +# +# # bad +# h = {a: 1, b: 2} +# +# # good +# h = { a: 1, b: 2 } +# @example EnforcedStyle: no_space +# # The `no_space` style enforces that hash literals have +# # no surrounding space. +# +# # bad +# h = { a: 1, b: 2 } +# +# # good +# h = {a: 1, b: 2} +# @example EnforcedStyle: compact +# # The `compact` style normally requires a space inside +# # hash braces, with the exception that successive left +# # braces or right braces are collapsed together in nested hashes. +# +# # bad +# h = { a: { b: 2 } } +# foo = { { a: 1 } => { b: { c: 2 } } } +# +# # good +# h = { a: { b: 2 }} +# foo = {{ a: 1 } => { b: { c: 2 }}} +# @example EnforcedStyleForEmptyBraces: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBraces style enforces that +# # empty hash braces do not contain spaces. +# +# # bad +# foo = { } +# bar = { } +# baz = { +# } +# +# # good +# foo = {} +# bar = {} +# baz = {} +# @example EnforcedStyleForEmptyBraces: space +# # The `space` EnforcedStyleForEmptyBraces style enforces that +# # empty hash braces contain space. +# +# # bad +# foo = {} +# +# # good +# foo = { } +# foo = { } +# foo = { +# } +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#70 +class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#78 + def on_hash(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#137 + def ambiguous_or_unexpected_style_detected(style, is_match); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#129 + def autocorrect(corrector, range); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#89 + def check(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#184 + def check_whitespace_only_hash(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#202 + def enforce_no_space_style_for_empty_braces?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#104 + def expect_space?(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#117 + def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#150 + def message(brace, is_empty_braces, expect_space); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#145 + def offense?(token1, expect_space); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#196 + def range_inside_hash(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#176 + def range_of_space_to_the_left(range); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#168 + def range_of_space_to_the_right(range); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#160 + def space_range(token_range); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#76 +RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::MSG = T.let(T.unsafe(nil), String) + +# Checks for spaces inside ordinary round parentheses. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that parentheses do not have spaces. +# +# # bad +# f( 3) +# g = (a + 3 ) +# f( ) +# +# # good +# f(3) +# g = (a + 3) +# f() +# @example EnforcedStyle: space +# # The `space` style enforces that parentheses have a space at the +# # beginning and end. +# # Note: Empty parentheses should not have spaces. +# +# # bad +# f(3) +# g = (a + 3) +# y( ) +# +# # good +# f( 3 ) +# g = ( a + 3 ) +# y() +# @example EnforcedStyle: compact +# # The `compact` style enforces that parentheses have a space at the +# # beginning with the exception that successive parentheses are allowed. +# # Note: Empty parentheses should not have spaces. +# +# # bad +# f(3) +# g = (a + 3) +# y( ) +# g( f( x ) ) +# g( f( x( 3 ) ), 5 ) +# g( ( ( 3 + 5 ) * f) ** x, 5 ) +# +# # good +# f( 3 ) +# g = ( a + 3 ) +# y() +# g( f( x )) +# g( f( x( 3 )), 5 ) +# g((( 3 + 5 ) * f ) ** x, 5 ) +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#57 +class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#66 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#161 + def can_be_ignored?(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#99 + def correct_extraneous_space(tokens); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#115 + def correct_extraneous_space_between_consecutive_parens(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#124 + def correct_extraneous_space_in_empty_parens(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#135 + def correct_missing_space(token1, token2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#153 + def left_parens?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#149 + def parens?(token1, token2); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#88 + def process_with_compact_style(tokens); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#81 + def process_with_space_style(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#157 + def right_parens?(token1, token2); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#63 +RuboCop::Cop::Layout::SpaceInsideParens::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#64 +RuboCop::Cop::Layout::SpaceInsideParens::MSG_SPACE = T.let(T.unsafe(nil), String) + +# Checks for unnecessary additional spaces inside the delimiters of +# %i/%w/%x literals. +# +# @example +# +# # bad +# %i( foo bar baz ) +# +# # good +# %i(foo bar baz) +# +# # bad +# %w( foo bar baz ) +# +# # good +# %w(foo bar baz) +# +# # bad +# %x( ls -l ) +# +# # good +# %x(ls -l) +# +# # bad +# %w( ) +# %w( +# ) +# +# # good +# %w() +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#36 +class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#45 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#53 + def on_percent_literal(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#49 + def on_xstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#60 + def add_offenses_for_blank_spaces(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#69 + def add_offenses_for_unnecessary_spaces(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#85 + def body_range(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#79 + def regex_matches(node, &blk); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#42 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BEGIN_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#43 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::END_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#41 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::MSG = T.let(T.unsafe(nil), String) + +# Checks for spaces inside range literals. +# +# @example +# # bad +# 1 .. 3 +# +# # good +# 1..3 +# +# # bad +# 'a' .. 'z' +# +# # good +# 'a'..'z' +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#20 +class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#29 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#25 + def on_irange(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#35 + def check(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#23 +RuboCop::Cop::Layout::SpaceInsideRangeLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks that reference brackets have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that reference brackets have +# # no surrounding space. +# +# # bad +# hash[ :key ] +# array[ index ] +# +# # good +# hash[:key] +# array[index] +# @example EnforcedStyle: space +# # The `space` style enforces that reference brackets have +# # surrounding space. +# +# # bad +# hash[:key] +# array[index] +# +# # good +# hash[ :key ] +# array[ index ] +# @example EnforcedStyleForEmptyBrackets: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBrackets style enforces that +# # empty reference brackets do not contain spaces. +# +# # bad +# foo[ ] +# foo[ ] +# foo[ +# ] +# +# # good +# foo[] +# @example EnforcedStyleForEmptyBrackets: space +# # The `space` EnforcedStyleForEmptyBrackets style enforces that +# # empty reference brackets contain exactly one space. +# +# # bad +# foo[] +# foo[ ] +# foo[ +# ] +# +# # good +# foo[ ] +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#60 +class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#70 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#92 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#121 + def closing_bracket(tokens, opening_bracket); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#137 + def empty_config; end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#110 + def left_ref_bracket(node, tokens); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#132 + def previous_token(current_token); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#104 + def reference_brackets(node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#66 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#65 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#68 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for whitespace within string interpolations. +# +# @example EnforcedStyle: no_space (default) +# # bad +# var = "This is the #{ space } example" +# +# # good +# var = "This is the #{no_space} example" +# @example EnforcedStyle: space +# # bad +# var = "This is the #{no_space} example" +# +# # good +# var = "This is the #{ space } example" +# +# source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#21 +class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#31 + def on_interpolation(begin_node); end + + private + + # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#47 + def autocorrect(corrector, begin_node); end + + # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#57 + def delimiters(begin_node); end +end + +# source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#28 +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#29 +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_MSG = T.let(T.unsafe(nil), String) + +# Looks for trailing blank lines and a final newline in the +# source code. +# +# @example EnforcedStyle: final_newline (default) +# # `final_newline` looks for one newline at the end of files. +# +# # bad +# class Foo; end +# +# # EOF +# +# # bad +# class Foo; end # EOF +# +# # good +# class Foo; end +# # EOF +# @example EnforcedStyle: final_blank_line +# # `final_blank_line` looks for one blank line followed by a new line +# # at the end of files. +# +# # bad +# class Foo; end +# # EOF +# +# # bad +# class Foo; end # EOF +# +# # good +# class Foo; end +# +# # EOF +# +# source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#40 +class RuboCop::Cop::Layout::TrailingEmptyLines < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#45 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#90 + def end_with_percent_blank_string?(processed_source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#80 + def ends_in_end?(processed_source); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#94 + def message(wanted_blank_lines, blank_lines); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#67 + def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end +end + +# Looks for trailing whitespace in the source code. +# +# @example +# # The line in this example contains spaces after the 0. +# # bad +# x = 0 +# +# # The line in this example ends directly after the 0. +# # good +# x = 0 +# @example AllowInHeredoc: false (default) +# # The line in this example contains spaces after the 0. +# # bad +# code = <<~RUBY +# x = 0 +# RUBY +# +# # ok +# code = <<~RUBY +# x = 0 #{} +# RUBY +# +# # good +# trailing_whitespace = ' ' +# code = <<~RUBY +# x = 0#{trailing_whitespace} +# RUBY +# @example AllowInHeredoc: true +# # The line in this example contains spaces after the 0. +# # good +# code = <<~RUBY +# x = 0 +# RUBY +# +# source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#42 +class RuboCop::Cop::Layout::TrailingWhitespace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#57 + def on_heredoc(_node); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#49 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#112 + def extract_heredocs(ast); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#103 + def find_heredoc(line_number); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#108 + def heredocs; end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#125 + def offense_range(lineno, line); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#61 + def process_line(line, lineno); end + + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#75 + def process_line_in_heredoc(corrector, range, heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#99 + def skip_heredoc?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#95 + def static?(heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#86 + def whitespace_is_indentation?(range, level); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#90 + def whitespace_only?(range); end +end + +# source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#47 +RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#5 +module RuboCop::Cop::Legacy; end + +# Legacy support for Corrector#corrections +# See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html +# +# source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#8 +class RuboCop::Cop::Legacy::CorrectionsProxy + # @return [CorrectionsProxy] a new instance of CorrectionsProxy + # + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#9 + def initialize(corrector); end + + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#13 + def <<(callable); end + + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#21 + def concat(corrections); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#17 + def empty?; end + + protected + + # Returns the value of attribute corrector. + # + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#31 + def corrector; end + + private + + # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#35 + def suppress_clobbering; end +end + +# This class handles autocorrection for code that needs to be moved +# to new lines. +# +# source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#7 +class RuboCop::Cop::LineBreakCorrector + extend ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::TrailingBody + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + class << self + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#27 + def break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#15 + def correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end + + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#35 + def move_comment(eol_comment:, node:, corrector:); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#13 + def processed_source; end + + private + + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#45 + def remove_semicolon(node, corrector); end + + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#51 + def semicolon(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#58 + def trailing_class_definition?(token, body); end + end +end + +# Help methods for determining if a line is too long. +# +# source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#6 +module RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::Alignment + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#24 + def allow_uri?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#28 + def allowed_uri_position?(line, uri_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#15 + def directive_on_source_line?(line_index); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#72 + def extend_uri_end_position(line, end_position); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#36 + def find_excessive_uri_range(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#11 + def ignore_cop_directives?; end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#59 + def indentation_difference(line); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#32 + def line_length(line); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#105 + def line_length_without_directive(line); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#51 + def match_uris(string); end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#88 + def tab_indentation_width; end + + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#93 + def uri_regexp; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#98 + def valid_uri?(uri_ish_string); end +end + +# source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#5 +module RuboCop::Cop::Lint; end + +# Checks for mistyped shorthand assignments. +# +# @example +# # bad +# x =- y +# x =+ y +# x =* y +# x =! y +# +# # good +# x -= y # or x = -y +# x += y # or x = +y +# x *= y # or x = *y +# x != y # or x = !y +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#21 +class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_asgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30 + def on_lvasgn(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#44 + def rhs(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#28 +RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#24 +RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#26 +RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# Checks for ambiguous block association with method +# when param passed without parentheses. +# +# This cop can customize allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# @example +# +# # bad +# some_method a { |val| puts val } +# @example +# +# # good +# # With parentheses, there's no ambiguity. +# some_method(a { |val| puts val }) +# # or (different meaning) +# some_method(a) { |val| puts val } +# +# # good +# # Operator methods require no disambiguation +# foo == bar { |b| b.baz } +# +# # good +# # Lambda arguments require no disambiguation +# foo = ->(bar) { bar.baz } +# @example AllowedMethods: [] (default) +# +# # bad +# expect { do_something }.to change { object.attribute } +# @example AllowedMethods: [change] +# +# # good +# expect { do_something }.to change { object.attribute } +# @example AllowedPatterns: [] (default) +# +# # bad +# expect { do_something }.to change { object.attribute } +# @example AllowedPatterns: ['change'] +# +# # good +# expect { do_something }.to change { object.attribute } +# expect { do_something }.to not_change { object.attribute } +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#54 +class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#64 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#64 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#85 + def allowed_method_pattern?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#81 + def ambiguous_block_association?(send_node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#91 + def message(send_node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#97 + def wrap_in_parentheses(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#60 +RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String) + +# Checks for ambiguous operators in the first argument of a +# method invocation without parentheses. +# +# @example +# +# # bad +# +# # The `*` is interpreted as a splat operator but it could possibly be +# # a `*` method invocation (i.e. `do_something.*(some_array)`). +# do_something *some_array +# @example +# +# # good +# +# # With parentheses, there's no ambiguity. +# do_something(*some_array) +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#23 +class RuboCop::Cop::Lint::AmbiguousOperator < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#45 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#64 + def find_offense_node_by(diagnostic); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#82 + def message(diagnostic); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#92 + def offense_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#88 + def offense_position?(node, diagnostic); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#101 + def unary_operator?(node, diagnostic); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#41 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#26 +RuboCop::Cop::Lint::AmbiguousOperator::AMBIGUITIES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#36 +RuboCop::Cop::Lint::AmbiguousOperator::MSG_FORMAT = T.let(T.unsafe(nil), String) + +# Looks for expressions containing multiple binary operators +# where precedence is ambiguous due to lack of parentheses. For example, +# in `1 + 2 * 3`, the multiplication will happen before the addition, but +# lexically it appears that the addition will happen first. +# +# The cop does not consider unary operators (ie. `!a` or `-b`) or comparison +# operators (ie. `a =~ b`) because those are not ambiguous. +# +# NOTE: Ranges are handled by `Lint/AmbiguousRange`. +# +# @example +# # bad +# a + b * c +# a || b && c +# a ** b + c +# +# # good (different precedence) +# a + (b * c) +# a || (b && c) +# (a ** b) + c +# +# # good (same precedence) +# a + b + c +# a * b / c % d +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#30 +class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#54 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#47 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#65 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#105 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#89 + def greater_precedence?(node1, node2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#85 + def operator?(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#97 + def operator_name(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#79 + def precedence(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#45 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::MSG = T.let(T.unsafe(nil), String) + +# See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#34 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::PRECEDENCE = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#44 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for ambiguous ranges. +# +# Ranges have quite low precedence, which leads to unexpected behavior when +# using a range with other operators. This cop avoids that by making ranges +# explicit by requiring parenthesis around complex range boundaries (anything +# that is not a literal: numerics, strings, symbols, etc.). +# +# This cop can be configured with `RequireParenthesesForMethodChains` in order to +# specify whether method chains (including `self.foo`) should be wrapped in parens +# by this cop. +# +# NOTE: Regardless of this configuration, if a method receiver is a basic literal +# value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`. +# +# @example +# # bad +# x || 1..2 +# (x || 1..2) +# 1..2.to_a +# +# # good, unambiguous +# 1..2 +# 'a'..'z' +# :bar..:baz +# MyClass::MIN..MyClass::MAX +# @min..@max +# a..b +# -a..b +# +# # good, ambiguity removed +# x || (1..2) +# (x || 1)..2 +# (x || 1)..(y || 2) +# (1..2).to_a +# @example RequireParenthesesForMethodChains: false (default) +# # good +# a.foo..b.bar +# (a.foo)..(b.bar) +# @example RequireParenthesesForMethodChains: true +# # bad +# a.foo..b.bar +# +# # good +# (a.foo)..(b.bar) +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#59 +class RuboCop::Cop::Lint::AmbiguousRange < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#64 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#64 + def on_irange(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#82 + def acceptable?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#89 + def acceptable_call?(node); end + + # @yield [range.begin] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#77 + def each_boundary(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#99 + def require_parentheses_for_method_chain?; end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#62 +RuboCop::Cop::Lint::AmbiguousRange::MSG = T.let(T.unsafe(nil), String) + +# Checks for ambiguous regexp literals in the first argument of +# a method invocation without parentheses. +# +# @example +# +# # bad +# +# # This is interpreted as a method invocation with a regexp literal, +# # but it could possibly be `/` method invocations. +# # (i.e. `do_something./(pattern)./(i)`) +# do_something /pattern/i +# @example +# +# # good +# +# # With parentheses, there's no ambiguity. +# do_something(/pattern/i) +# +# source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#24 +class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#31 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#56 + def find_offense_node(node, regexp_receiver); end + + # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#49 + def find_offense_node_by(diagnostic); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#67 + def first_argument_is_regexp?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#71 + def method_chain_to_regexp_receiver?(node, regexp_receiver); end +end + +# source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#27 +RuboCop::Cop::Lint::AmbiguousRegexpLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks for assignments in the conditions of +# if/while/until. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example +# # bad +# if some_var = value +# do_something +# end +# +# # good +# if some_var == value +# do_something +# end +# @example AllowSafeAssignment: true (default) +# # good +# if (some_var = value) +# do_something +# end +# @example AllowSafeAssignment: false +# # bad +# if (some_var = value) +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#41 +class RuboCop::Cop::Lint::AssignmentInCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55 + def on_while(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#82 + def allowed_construct?(asgn_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#86 + def conditional_assignment?(asgn_node); end + + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#74 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#90 + def skip_children?(asgn_node); end + + # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#96 + def traverse_node(node, &block); end +end + +# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#53 +RuboCop::Cop::Lint::AssignmentInCondition::ASGN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#50 +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#46 +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +# `BigDecimal.new()` is deprecated since BigDecimal 1.3.3. +# This cop identifies places where `BigDecimal.new()` +# can be replaced by `BigDecimal()`. +# +# @example +# # bad +# BigDecimal.new(123.456, 3) +# +# # good +# BigDecimal(123.456, 3) +# +# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#17 +class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#25 + def big_decimal_new(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#30 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#20 +RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#22 +RuboCop::Cop::Lint::BigDecimalNew::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where binary operator has identical operands. +# +# It covers arithmetic operators: `-`, `/`, `%`; +# comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`; +# bitwise operators: `|`, `^`, `&`; +# boolean operators: `&&`, `||` +# and "spaceship" operator - `<=>`. +# +# Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`. +# Although these can be rewritten in a different way, it should not be necessary to +# do so. This does not include operations such as `-` or `/` where the result will +# always be the same (`x - x` will always be 0; `x / x` will always be 1), and +# thus are legitimate offenses. +# +# @example +# # bad +# x / x +# x.top >= x.top +# +# if a.x != 0 && a.x != 0 +# do_something +# end +# +# def child? +# left_child || left_child +# end +# +# # good +# x + x +# 1 << 1 +# +# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#48 +class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#61 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#61 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#52 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#50 +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::ALLOWED_MATH_OPERATORS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#49 +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(nil), String) + +# Checks for `:true` and `:false` symbols. +# In most cases it would be a typo. +# +# @example +# +# # bad +# :true +# +# # good +# true +# @example +# +# # bad +# :false +# +# # good +# false +# +# source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#29 +class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#35 + def boolean_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#37 + def on_sym(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#50 + def autocorrect(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#32 +RuboCop::Cop::Lint::BooleanSymbol::MSG = T.let(T.unsafe(nil), String) + +# Checks for circular argument references in optional keyword +# arguments and optional ordinal arguments. +# +# This cop mirrors a warning produced by MRI since 2.2. +# +# @example +# +# # bad +# +# def bake(pie: pie) +# pie.heat_up +# end +# @example +# +# # good +# +# def bake(pie:) +# pie.refrigerate +# end +# @example +# +# # good +# +# def bake(pie: self.pie) +# pie.feed_to(user) +# end +# @example +# +# # bad +# +# def cook(dry_ingredients = dry_ingredients) +# dry_ingredients.reduce(&:+) +# end +# @example +# +# # good +# +# def cook(dry_ingredients = self.dry_ingredients) +# dry_ingredients.combine +# end +# +# source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#50 +class RuboCop::Cop::Lint::CircularArgumentReference < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#53 + def on_kwoptarg(node); end + + # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#57 + def on_optarg(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#63 + def check_for_circular_argument_references(arg_name, arg_value); end +end + +# source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#51 +RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String) + +# Do not define constants within a block, since the block's scope does not +# isolate or namespace the constant in any way. +# +# If you are trying to define that constant once, define it outside of +# the block instead, or use a variable or method if defining the constant +# in the outer scope would be problematic. +# +# For meta-programming, use `const_set`. +# +# @example +# # bad +# task :lint do +# FILES_TO_LINT = Dir['lib/*.rb'] +# end +# +# # bad +# describe 'making a request' do +# class TestRequest; end +# end +# +# # bad +# module M +# extend ActiveSupport::Concern +# included do +# LIST = [] +# end +# end +# +# # good +# task :lint do +# files_to_lint = Dir['lib/*.rb'] +# end +# +# # good +# describe 'making a request' do +# let(:test_request) { Class.new } +# # see also `stub_const` for RSpec +# end +# +# # good +# module M +# extend ActiveSupport::Concern +# included do +# const_set(:LIST, []) +# end +# end +# @example AllowedMethods: ['enums'] (default) +# # good +# +# # `enums` for Typed Enums via `T::Enum` in Sorbet. +# # https://sorbet.org/docs/tenum +# class TestEnum < T::Enum +# enums do +# Foo = new("foo") +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#64 +class RuboCop::Cop::Lint::ConstantDefinitionInBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#70 + def constant_assigned_in_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#75 + def module_defined_in_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#79 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#85 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#85 + def on_module(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#94 + def method_name(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#67 +RuboCop::Cop::Lint::ConstantDefinitionInBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for overwriting an exception with an exception result by use `rescue =>`. +# +# You intended to write as `rescue StandardError`. +# However, you have written `rescue => StandardError`. +# In that case, the result of `rescue` will overwrite `StandardError`. +# +# @example +# +# # bad +# begin +# something +# rescue => StandardError +# end +# +# # good +# begin +# something +# rescue StandardError +# end +# +# source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#26 +class RuboCop::Cop::Lint::ConstantOverwrittenInRescue < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#41 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#33 + def overwritten_constant(param0 = T.unsafe(nil)); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#37 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#30 +RuboCop::Cop::Lint::ConstantOverwrittenInRescue::MSG = T.let(T.unsafe(nil), String) + +# Check that certain constants are fully qualified. +# +# This is not enabled by default because it would mark a lot of offenses +# unnecessarily. +# +# Generally, gems should fully qualify all constants to avoid conflicts with +# the code that uses the gem. Enable this cop without using `Only`/`Ignore` +# +# Large projects will over time end up with one or two constant names that +# are problematic because of a conflict with a library or just internally +# using the same name a namespace and a class. To avoid too many unnecessary +# offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]` +# +# NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent +# conflicting rules. Because it respects user configurations that want to enable +# this cop which is disabled by default. +# +# @example +# # By default checks every constant +# +# # bad +# User +# +# # bad +# User::Login +# +# # good +# ::User +# +# # good +# ::User::Login +# @example Only: ['Login'] +# # Restrict this cop to only being concerned about certain constants +# +# # bad +# Login +# +# # good +# ::Login +# +# # good +# User::Login +# @example Ignore: ['Login'] +# # Restrict this cop not being concerned about certain constants +# +# # bad +# User +# +# # good +# ::User::Login +# +# # good +# Login +# +# source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#62 +class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#70 + def on_const(node); end + + # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#66 + def unqualified_const?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#83 + def allowed_names; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#78 + def const_name?(name); end + + # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#87 + def ignored_names; end +end + +# source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#63 +RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String) + +# Checks for debug calls (such as `debugger` or `binding.pry`) that should +# not be kept for production code. +# +# The cop can be configured using `DebuggerMethods`. By default, a number of gems +# debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`, +# `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added. +# +# Specific default groups can be disabled if necessary: +# +# [source,yaml] +# ---- +# Lint/Debugger: +# DebuggerMethods: +# WebConsole: ~ +# ---- +# +# You can also add your own methods by adding a new category: +# +# [source,yaml] +# ---- +# Lint/Debugger: +# DebuggerMethods: +# MyDebugger: +# MyDebugger.debug_this +# ---- +# +# @example +# +# # bad (ok during development) +# +# # using pry +# def some_method +# binding.pry +# do_something +# end +# @example +# +# # bad (ok during development) +# +# # using byebug +# def some_method +# byebug +# do_something +# end +# @example +# +# # good +# +# def some_method +# do_something +# end +# @example DebuggerMethods: [my_debugger] +# +# # bad (ok during development) +# +# def some_method +# my_debugger +# end +# +# source://rubocop//lib/rubocop/cop/lint/debugger.rb#67 +class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#117 + def assumed_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#96 + def assumed_usage_context?(node); end + + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#106 + def chained_method_name(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#90 + def debugger_method?(send_node); end + + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#83 + def debugger_methods; end + + # source://rubocop//lib/rubocop/cop/lint/debugger.rb#79 + def message(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/debugger.rb#69 +RuboCop::Cop::Lint::Debugger::BLOCK_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/debugger.rb#68 +RuboCop::Cop::Lint::Debugger::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the deprecated class method usages. +# +# @example +# +# # bad +# File.exists?(some_path) +# Dir.exists?(some_path) +# iterator? +# attr :name, true +# attr :name, false +# ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7. +# ENV.clone +# ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1. +# Socket.gethostbyname(host) +# Socket.gethostbyaddr(host) +# +# # good +# File.exist?(some_path) +# Dir.exist?(some_path) +# block_given? +# attr_accessor :name +# attr_reader :name +# ENV # `ENV.freeze` cannot prohibit changes to environment variables. +# ENV.to_h +# ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash. +# Addrinfo.getaddrinfo(nodename, service) +# Addrinfo.tcp(host, port).getnameinfo +# +# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#33 +class RuboCop::Cop::Lint::DeprecatedClassMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#53 + def deprecated_class_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#63 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#112 + def dir_env_file_const?(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#83 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#93 + def preferred_method(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#108 + def socket_const?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#50 +RuboCop::Cop::Lint::DeprecatedClassMethods::DIR_ENV_FILE_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#36 +RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#41 +RuboCop::Cop::Lint::DeprecatedClassMethods::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#37 +RuboCop::Cop::Lint::DeprecatedClassMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for deprecated constants. +# +# It has `DeprecatedConstants` config. If there is an alternative method, you can set +# alternative value as `Alternative`. And you can set the deprecated version as +# `DeprecatedVersion`. These options can be omitted if they are not needed. +# +# DeprecatedConstants: +# 'DEPRECATED_CONSTANT': +# Alternative: 'alternative_value' +# DeprecatedVersion: 'deprecated_version' +# +# By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`, +# `Struct::Group`, and `Struct::Passwd` are configured. +# +# @example +# +# # bad +# NIL +# TRUE +# FALSE +# Net::HTTPServerException +# Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class. +# Struct::Group +# Struct::Passwd +# +# # good +# nil +# true +# false +# Net::HTTPClientException +# Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2. +# Etc::Group +# Etc::Passwd +# +# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#40 +class RuboCop::Cop::Lint::DeprecatedConstants < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#46 + def on_const(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#66 + def constant_name(node, nested_constant_name); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#82 + def deprecated_constants; end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#72 + def message(good, bad, deprecated_version); end +end + +# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#44 +RuboCop::Cop::Lint::DeprecatedConstants::DO_NOT_USE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#43 +RuboCop::Cop::Lint::DeprecatedConstants::SUGGEST_GOOD_MSG = T.let(T.unsafe(nil), String) + +# Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest` +# deprecated since OpenSSL version 2.2.0. Prefer passing a string +# instead. +# +# @example +# +# # Example for OpenSSL::Cipher instantiation. +# +# # bad +# OpenSSL::Cipher::AES.new(128, :GCM) +# +# # good +# OpenSSL::Cipher.new('aes-128-gcm') +# @example +# +# # Example for OpenSSL::Digest instantiation. +# +# # bad +# OpenSSL::Digest::SHA256.new +# +# # good +# OpenSSL::Digest.new('SHA256') +# @example +# +# # Example for ::Digest inherited class methods. +# +# # bad +# OpenSSL::Digest::SHA256.digest('foo') +# +# # good +# OpenSSL::Digest.digest('SHA256', 'foo') +# +# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#40 +class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#49 + def algorithm_const(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#59 + def digest_const?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#63 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#110 + def algorithm_name(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#75 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#139 + def build_cipher_arguments(node, algorithm_name, no_arguments); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#102 + def correction_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#87 + def message(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#106 + def openssl_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#128 + def replacement_args(node); end + + # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#120 + def sanitize_arguments(arguments); end +end + +# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#44 +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#46 +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::NO_ARG_ALGORITHM = T.let(T.unsafe(nil), Array) + +# Checks constructors for disjunctive assignments (`||=`) that should +# be plain assignments. +# +# So far, this cop is only concerned with disjunctive assignment of +# instance variables. +# +# In ruby, an instance variable is nil until a value is assigned, so the +# disjunction is unnecessary. A plain assignment has the same effect. +# +# @example +# # bad +# def initialize +# @x ||= 1 +# end +# +# # good +# def initialize +# @x = 1 +# end +# +# source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#48 +class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#53 + def on_def(node); end + + private + + # @param node [DefNode] a constructor definition + # + # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#60 + def check(node); end + + # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#66 + def check_body(body); end + + # @param lines [Array] the logical lines of the constructor + # + # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#78 + def check_body_lines(lines); end + + # Add an offense if the LHS of the given disjunctive assignment is + # an instance variable. + # + # For now, we only care about assignments to instance variables. + # + # @param node [Node] a disjunctive assignment + # + # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#99 + def check_disjunctive_assignment(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#51 +RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated bodies +# within `if/unless`, `case-when`, `case-in` and `rescue` constructs. +# +# With `IgnoreLiteralBranches: true`, branches are not registered +# as offenses if they return a basic literal value (string, symbol, +# integer, float, rational, complex, `true`, `false`, or `nil`), or +# return an array, hash, regexp or range that only contains one of +# the above basic literal values. +# +# With `IgnoreConstantBranches: true`, branches are not registered +# as offenses if they return a constant value. +# +# @example +# # bad +# if foo +# do_foo +# do_something_else +# elsif bar +# do_foo +# do_something_else +# end +# +# # good +# if foo || bar +# do_foo +# do_something_else +# end +# +# # bad +# case x +# when foo +# do_foo +# when bar +# do_foo +# else +# do_something_else +# end +# +# # good +# case x +# when foo, bar +# do_foo +# else +# do_something_else +# end +# +# # bad +# begin +# do_something +# rescue FooError +# handle_error +# rescue BarError +# handle_error +# end +# +# # good +# begin +# do_something +# rescue FooError, BarError +# handle_error +# end +# @example IgnoreLiteralBranches: true +# # good +# case size +# when "small" then 100 +# when "medium" then 250 +# when "large" then 1000 +# else 250 +# end +# @example IgnoreConstantBranches: true +# # good +# case size +# when "small" then SMALL_SIZE +# when "medium" then MEDIUM_SIZE +# when "large" then LARGE_SIZE +# else MEDIUM_SIZE +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#86 +class RuboCop::Cop::Lint::DuplicateBranch < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89 + def on_branching_statement(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89 + def on_rescue(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#117 + def branches(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#121 + def consider_branch?(branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#147 + def const_branch?(branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#132 + def ignore_constant_branches?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#128 + def ignore_literal_branches?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#136 + def literal_branch?(branch); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#103 + def offense_range(duplicate_branch); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#87 +RuboCop::Cop::Lint::DuplicateBranch::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated conditions +# used in case 'when' expressions. +# +# @example +# +# # bad +# +# case x +# when 'first' +# do_something +# when 'first' +# do_something_else +# end +# @example +# +# # good +# +# case x +# when 'first' +# do_something +# when 'second' +# do_something_else +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#30 +class RuboCop::Cop::Lint::DuplicateCaseCondition < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#33 + def on_case(case_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#31 +RuboCop::Cop::Lint::DuplicateCaseCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated conditions used in if 'elsif'. +# +# @example +# # bad +# if x == 1 +# do_something +# elsif x == 1 +# do_something_else +# end +# +# # good +# if x == 1 +# do_something +# elsif x == 2 +# do_something_else +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#23 +class RuboCop::Cop::Lint::DuplicateElsifCondition < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#26 + def on_if(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#24 +RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for duplicated keys in hash literals. +# This cop considers both primitive types and constants for the hash keys. +# +# This cop mirrors a warning in Ruby 2.2. +# +# @example +# +# # bad +# +# hash = { food: 'apple', food: 'orange' } +# @example +# +# # good +# +# hash = { food: 'apple', other_food: 'orange' } +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#22 +class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Duplication + + # source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#27 + def on_hash(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#25 +RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String) + +# Checks for duplicated magic comments. +# +# @example +# +# # bad +# +# # encoding: ascii +# # encoding: ascii +# +# # good +# +# # encoding: ascii +# +# # bad +# +# # frozen_string_literal: true +# # frozen_string_literal: true +# +# # good +# +# # frozen_string_literal: true +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#28 +class RuboCop::Cop::Lint::DuplicateMagicComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#35 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#51 + def magic_comment_lines; end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#65 + def register_offense(range); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#33 +RuboCop::Cop::Lint::DuplicateMagicComment::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated patterns used in `in` keywords. +# +# @example +# +# # bad +# case x +# in 'first' +# do_something +# in 'first' +# do_something_else +# end +# +# # good +# case x +# in 'first' +# do_something +# in 'second' +# do_something_else +# end +# +# # bad - repeated alternate patterns with the same conditions don't depend on the order +# case x +# in foo | bar +# first_method +# in bar | foo +# second_method +# end +# +# # good +# case x +# in foo | bar +# first_method +# in bar | baz +# second_method +# end +# +# # bad - repeated hash patterns with the same conditions don't depend on the order +# case x +# in foo: a, bar: b +# first_method +# in bar: b, foo: a +# second_method +# end +# +# # good +# case x +# in foo: a, bar: b +# first_method +# in bar: b, baz: c +# second_method +# end +# +# # bad - repeated array patterns with elements in the same order +# case x +# in [foo, bar] +# first_method +# in [foo, bar] +# second_method +# end +# +# # good +# case x +# in [foo, bar] +# first_method +# in [bar, foo] +# second_method +# end +# +# # bad - repeated the same patterns and guard conditions +# case x +# in foo if bar +# first_method +# in foo if bar +# second_method +# end +# +# # good +# case x +# in foo if bar +# first_method +# in foo if baz +# second_method +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#90 +class RuboCop::Cop::Lint::DuplicateMatchPattern < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#97 + def on_case_match(case_node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#108 + def pattern_identity(pattern); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#93 +RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) + +# Checks for duplicated instance (or singleton) method +# definitions. +# +# @example +# +# # bad +# +# def foo +# 1 +# end +# +# def foo +# 2 +# end +# @example +# +# # bad +# +# def foo +# 1 +# end +# +# alias foo bar +# @example +# +# # good +# +# def foo +# 1 +# end +# +# def bar +# 2 +# end +# @example +# +# # good +# +# def foo +# 1 +# end +# +# alias bar foo +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#52 +class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base + # @return [DuplicateMethods] a new instance of DuplicateMethods + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#57 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#98 + def alias_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#85 + def method_alias?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#89 + def on_alias(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#63 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#72 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#104 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#103 + def sym_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#117 + def check_const_receiver(node, name, const_name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#124 + def check_self_receiver(node, name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#208 + def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#136 + def found_instance_method(node, name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#159 + def found_method(node, method_name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#149 + def found_sclass_method(node, name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#186 + def location(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#218 + def lookup_constant(node, const_name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#131 + def message_for_dup(node, method_name, key); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#178 + def method_key(node, method_name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#194 + def on_attr(node, attr_name, args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#250 + def possible_dsl?(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#236 + def qualified_name(enclosing, namespace, mod_name); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#260 + def source_location(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#55 +RuboCop::Cop::Lint::DuplicateMethods::DEF_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#53 +RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#54 +RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for duplicate elements in Regexp character classes. +# +# @example +# +# # bad +# r = /[xyx]/ +# +# # bad +# r = /[0-9x0-9]/ +# +# # good +# r = /[xy]/ +# +# # good +# r = /[0-9x]/ +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#21 +class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#37 + def each_repeated_character_class_element_loc(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#29 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#102 + def escaped_octal?(string); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#54 + def group_expressions(node, expressions); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#110 + def interpolation_locs(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#106 + def octal?(char); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#71 + def pop_octal_digits(current_child, expressions); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#89 + def skip_expression?(expr); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#80 + def source_range(children); end + + # Since we blank interpolations with a space for every char of the interpolation, we would + # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes + # that are within an interpolation. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#96 + def within_interpolation?(node, child); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#25 +RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::MSG_REPEATED_ELEMENT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#27 +RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::OCTAL_DIGITS_AFTER_ESCAPE = T.let(T.unsafe(nil), Integer) + +# Checks for duplicate ``require``s and ``require_relative``s. +# +# @example +# # bad +# require 'foo' +# require 'bar' +# require 'foo' +# +# # good +# require 'foo' +# require 'bar' +# +# # good +# require 'foo' +# require_relative 'foo' +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#26 +class RuboCop::Cop::Lint::DuplicateRequire < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#39 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#45 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#35 + def require_call?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#30 +RuboCop::Cop::Lint::DuplicateRequire::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#31 +RuboCop::Cop::Lint::DuplicateRequire::REQUIRE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#32 +RuboCop::Cop::Lint::DuplicateRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks that there are no repeated exceptions +# used in 'rescue' expressions. +# +# @example +# # bad +# begin +# something +# rescue FirstException +# handle_exception +# rescue FirstException +# handle_other_exception +# end +# +# # good +# begin +# something +# rescue FirstException +# handle_exception +# rescue SecondException +# handle_other_exception +# end +# +# source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#28 +class RuboCop::Cop::Lint::DuplicateRescueException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + + # source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#33 + def on_rescue(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#31 +RuboCop::Cop::Lint::DuplicateRescueException::MSG = T.let(T.unsafe(nil), String) + +# Checks if each_with_object is called with an immutable +# argument. Since the argument is the object that the given block shall +# make calls on to build something based on the enumerable that +# each_with_object iterates over, an immutable argument makes no sense. +# It's definitely a bug. +# +# @example +# +# # bad +# +# sum = numbers.each_with_object(0) { |e, a| a += e } +# @example +# +# # good +# +# num = 0 +# sum = numbers.each_with_object(num) { |e, a| a += e } +# +# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#24 +class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#29 + def each_with_object?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#33 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#33 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#25 +RuboCop::Cop::Lint::EachWithObjectArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#26 +RuboCop::Cop::Lint::EachWithObjectArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for odd `else` block layout - like +# having an expression on the same line as the `else` keyword, +# which is usually a mistake. +# +# Its autocorrection tweaks layout to keep the syntax. So, this autocorrection +# is compatible correction for bad case syntax, but if your code makes a mistake +# with `elsif` and `else`, you will have to correct it manually. +# +# @example +# +# # bad +# +# if something +# # ... +# else do_this +# do_that +# end +# @example +# +# # good +# +# # This code is compatible with the bad case. It will be autocorrected like this. +# if something +# # ... +# else +# do_this +# do_that +# end +# +# # This code is incompatible with the bad case. +# # If `do_this` is a condition, `elsif` should be used instead of `else`. +# if something +# # ... +# elsif do_this +# do_that +# end +# +# source://rubocop//lib/rubocop/cop/lint/else_layout.rb#43 +class RuboCop::Cop::Lint::ElseLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#50 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#81 + def autocorrect(corrector, node, first_else); end + + # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#61 + def check(node); end + + # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#71 + def check_else(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/else_layout.rb#48 +RuboCop::Cop::Lint::ElseLayout::MSG = T.let(T.unsafe(nil), String) + +# Checks for blocks without a body. +# Such empty blocks are typically an oversight or we should provide a comment +# to clarify what we're aiming for. +# +# Empty lambdas and procs are ignored by default. +# +# NOTE: For backwards compatibility, the configuration that allows/disallows +# empty lambdas and procs is called `AllowEmptyLambdas`, even though it also +# applies to procs. +# +# @example +# # bad +# items.each { |item| } +# +# # good +# items.each { |item| puts item } +# @example AllowComments: true (default) +# # good +# items.each do |item| +# # TODO: implement later (inner comment) +# end +# +# items.each { |item| } # TODO: implement later (inline comment) +# @example AllowComments: false +# # bad +# items.each do |item| +# # TODO: implement later (inner comment) +# end +# +# items.each { |item| } # TODO: implement later (inline comment) +# @example AllowEmptyLambdas: true (default) +# # good +# allow(subject).to receive(:callable).and_return(-> {}) +# +# placeholder = lambda do +# end +# (callable || placeholder).call +# +# proc { } +# +# Proc.new { } +# @example AllowEmptyLambdas: false +# # bad +# allow(subject).to receive(:callable).and_return(-> {}) +# +# placeholder = lambda do +# end +# (callable || placeholder).call +# +# proc { } +# +# Proc.new { } +# +# source://rubocop//lib/rubocop/cop/lint/empty_block.rb#63 +class RuboCop::Cop::Lint::EmptyBlock < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#66 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#76 + def allow_comment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#83 + def allow_empty_lambdas?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#87 + def comment_disables_cop?(comment); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_block.rb#64 +RuboCop::Cop::Lint::EmptyBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for classes and metaclasses without a body. +# Such empty classes and metaclasses are typically an oversight or we should provide a comment +# to be clearer what we're aiming for. +# +# @example +# # bad +# class Foo +# end +# +# class Bar +# class << self +# end +# end +# +# class << obj +# end +# +# # good +# class Foo +# def do_something +# # ... code +# end +# end +# +# class Bar +# class << self +# attr_reader :bar +# end +# end +# +# class << obj +# attr_reader :bar +# end +# @example AllowComments: false (default) +# # bad +# class Foo +# # TODO: implement later +# end +# +# class Bar +# class << self +# # TODO: implement later +# end +# end +# +# class << obj +# # TODO: implement later +# end +# @example AllowComments: true +# # good +# class Foo +# # TODO: implement later +# end +# +# class Bar +# class << self +# # TODO: implement later +# end +# end +# +# class << obj +# # TODO: implement later +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#72 +class RuboCop::Cop::Lint::EmptyClass < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#76 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#81 + def on_sclass(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#87 + def body_or_allowed_comment_lines?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#73 +RuboCop::Cop::Lint::EmptyClass::CLASS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#74 +RuboCop::Cop::Lint::EmptyClass::METACLASS_MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `if`, `elsif` and `unless` branches without a body. +# +# NOTE: empty `else` branches are handled by `Style/EmptyElse`. +# +# @example +# # bad +# if condition +# end +# +# # bad +# unless condition +# end +# +# # bad +# if condition +# do_something +# elsif other_condition +# end +# +# # good +# if condition +# do_something +# end +# +# # good +# unless condition +# do_something +# end +# +# # good +# if condition +# do_something +# elsif other_condition +# do_something_else +# end +# @example AllowComments: true (default) +# # good +# if condition +# do_something +# elsif other_condition +# # noop +# end +# @example AllowComments: false +# # bad +# if condition +# do_something +# elsif other_condition +# # noop +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#63 +class RuboCop::Cop::Lint::EmptyConditionalBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#70 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#156 + def all_branches_body_missing?(node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#83 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#142 + def branch_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#104 + def correct_other_branches(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#162 + def deletion_range(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#137 + def else_branch?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#131 + def empty_elsif_branch?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#123 + def empty_if_branch?(node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#89 + def remove_comments(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#96 + def remove_empty_branch(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#116 + def require_other_branches_correction?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#68 +RuboCop::Cop::Lint::EmptyConditionalBody::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty `ensure` blocks +# +# @example +# +# # bad +# +# def some_method +# do_something +# ensure +# end +# @example +# +# # bad +# +# begin +# do_something +# ensure +# end +# @example +# +# # good +# +# def some_method +# do_something +# ensure +# do_something_else +# end +# @example +# +# # good +# +# begin +# do_something +# ensure +# do_something_else +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#45 +class RuboCop::Cop::Lint::EmptyEnsure < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#50 + def on_ensure(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#48 +RuboCop::Cop::Lint::EmptyEnsure::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of empty expressions. +# +# @example +# +# # bad +# +# foo = () +# if () +# bar +# end +# @example +# +# # good +# +# foo = (some_expression) +# if (some_expression) +# bar +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#25 +class RuboCop::Cop::Lint::EmptyExpression < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#28 + def on_begin(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#36 + def empty_expression?(begin_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#26 +RuboCop::Cop::Lint::EmptyExpression::MSG = T.let(T.unsafe(nil), String) + +# Enforces that Ruby source files are not empty. +# +# @example +# # bad +# # Empty file +# +# # good +# # File containing non commented source lines +# @example AllowComments: true (default) +# # good +# # File consisting only of comments +# @example AllowComments: false +# # bad +# # File consisting only of comments +# +# source://rubocop//lib/rubocop/cop/lint/empty_file.rb#23 +class RuboCop::Cop::Lint::EmptyFile < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#28 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#42 + def contains_only_comments?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#38 + def empty_file?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#34 + def offending?; end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_file.rb#26 +RuboCop::Cop::Lint::EmptyFile::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `in` pattern branches without a body. +# +# @example +# +# # bad +# case condition +# in [a] +# do_something +# in [a, b] +# end +# +# # good +# case condition +# in [a] +# do_something +# in [a, b] +# nil +# end +# @example AllowComments: true (default) +# +# # good +# case condition +# in [a] +# do_something +# in [a, b] +# # noop +# end +# @example AllowComments: false +# +# # bad +# case condition +# in [a] +# do_something +# in [a, b] +# # noop +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#45 +class RuboCop::Cop::Lint::EmptyInPattern < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#53 + def on_case_match(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#49 +RuboCop::Cop::Lint::EmptyInPattern::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty interpolation. +# +# @example +# +# # bad +# +# "result is #{}" +# @example +# +# # good +# +# "result is #{some_result}" +# +# source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#19 +class RuboCop::Cop::Lint::EmptyInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#25 + def on_interpolation(begin_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#23 +RuboCop::Cop::Lint::EmptyInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `when` branches without a body. +# +# @example +# +# # bad +# case foo +# when bar +# do_something +# when baz +# end +# @example +# +# # good +# case condition +# when foo +# do_something +# when bar +# nil +# end +# @example AllowComments: true (default) +# +# # good +# case condition +# when foo +# do_something +# when bar +# # noop +# end +# @example AllowComments: false +# +# # bad +# case condition +# when foo +# do_something +# when bar +# # do nothing +# end +# +# source://rubocop//lib/rubocop/cop/lint/empty_when.rb#47 +class RuboCop::Cop::Lint::EmptyWhen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + + # source://rubocop//lib/rubocop/cop/lint/empty_when.rb#52 + def on_case(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/empty_when.rb#50 +RuboCop::Cop::Lint::EmptyWhen::MSG = T.let(T.unsafe(nil), String) + +# Checks for `return` from an `ensure` block. +# `return` from an ensure block is a dangerous code smell as it +# will take precedence over any exception being raised, +# and the exception will be silently thrown away as if it were rescued. +# +# If you want to rescue some (or all) exceptions, best to do it explicitly +# +# @example +# +# # bad +# +# def foo +# do_something +# ensure +# cleanup +# return self +# end +# @example +# +# # good +# +# def foo +# do_something +# self +# ensure +# cleanup +# end +# +# # also good +# +# def foo +# begin +# do_something +# rescue SomeException +# # Let's ignore this exception +# end +# self +# ensure +# cleanup +# end +# +# source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#47 +class RuboCop::Cop::Lint::EnsureReturn < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#53 + def on_ensure(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#51 +RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String) + +# Emulates the following Ruby warnings in Ruby 2.6. +# +# [source,console] +# ---- +# $ cat example.rb +# ERB.new('hi', nil, '-', '@output_buffer') +# $ ruby -rerb example.rb +# example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is +# deprecated. Do not use it, and specify other arguments as keyword arguments. +# example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is +# deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead. +# example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is +# deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead. +# ---- +# +# Now non-keyword arguments other than first one are softly deprecated +# and will be removed when Ruby 2.5 becomes EOL. +# `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0. +# Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`. +# This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can +# be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`. +# +# @example +# # Target codes supports Ruby 2.6 and higher only +# # bad +# ERB.new(str, nil, '-', '@output_buffer') +# +# # good +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# +# # Target codes supports Ruby 2.5 and lower only +# # good +# ERB.new(str, nil, '-', '@output_buffer') +# +# # Target codes supports Ruby 2.6, 2.5 and lower +# # bad +# ERB.new(str, nil, '-', '@output_buffer') +# +# # good +# # Ruby standard library style +# # https://github.com/ruby/ruby/commit/3406c5d +# if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+ +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# else +# ERB.new(str, nil, '-', '@output_buffer') +# end +# +# # good +# # Use `RUBY_VERSION` style +# if RUBY_VERSION >= '2.6' +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# else +# ERB.new(str, nil, '-', '@output_buffer') +# end +# +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#61 +class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#83 + def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#88 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#153 + def arguments_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#108 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#123 + def build_kwargs(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#119 + def correct_arguments?(arguments); end + + # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#140 + def override_by_legacy_args(kwargs, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#68 +RuboCop::Cop::Lint::ErbNewArguments::MESSAGES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#80 +RuboCop::Cop::Lint::ErbNewArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for uses of flip-flop operator +# based on the Ruby Style Guide. +# +# Here is the history of flip-flops in Ruby. +# flip-flop operator is deprecated in Ruby 2.6.0 and +# the deprecation has been reverted by Ruby 2.7.0 and +# backported to Ruby 2.6. +# See: https://bugs.ruby-lang.org/issues/5400 +# +# @example +# # bad +# (1..20).each do |x| +# puts x if (x == 5) .. (x == 10) +# end +# +# # good +# (1..20).each do |x| +# puts x if (x >= 5) && (x <= 10) +# end +# +# source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#25 +class RuboCop::Cop::Lint::FlipFlop < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#32 + def on_eflipflop(node); end + + # source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#28 + def on_iflipflop(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#26 +RuboCop::Cop::Lint::FlipFlop::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of precise comparison of floating point numbers. +# +# Floating point values are inherently inaccurate, and comparing them for exact equality +# is almost never the desired semantics. Comparison via the `==/!=` operators checks +# floating-point value representation to be exactly the same, which is very unlikely +# if you perform any arithmetic operations involving precision loss. +# +# # good - comparing against zero +# x == 0.0 +# x != 0.0 +# +# # good +# (x - 0.1).abs < Float::EPSILON +# +# # good +# tolerance = 0.0001 +# (x - 0.1).abs < tolerance +# +# # Or some other epsilon based type of comparison: +# # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/ +# +# @example +# # bad +# x == 0.1 +# x != 0.1 +# +# # good - using BigDecimal +# x.to_d == 0.1.to_d +# +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#35 +class RuboCop::Cop::Lint::FloatComparison < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#44 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#89 + def check_numeric_returning_method(node); end + + # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#73 + def check_send(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#53 + def float?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#68 + def literal_zero?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#38 +RuboCop::Cop::Lint::FloatComparison::EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#40 +RuboCop::Cop::Lint::FloatComparison::FLOAT_INSTANCE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#39 +RuboCop::Cop::Lint::FloatComparison::FLOAT_RETURNING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#36 +RuboCop::Cop::Lint::FloatComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#42 +RuboCop::Cop::Lint::FloatComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies Float literals which are, like, really really really +# really really really really really big. Too big. No-one needs Floats +# that big. If you need a float that big, something is wrong with you. +# +# @example +# +# # bad +# +# float = 3.0e400 +# @example +# +# # good +# +# float = 42.9 +# +# source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#21 +class RuboCop::Cop::Lint::FloatOutOfRange < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#24 + def on_float(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#22 +RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String) + +# This lint sees if there is a mismatch between the number of +# expected fields for format/sprintf/#% and what is actually +# passed as arguments. +# +# In addition it checks whether different formats are used in the same +# format string. Do not mix numbered, unnumbered, and named formats in +# the same format string. +# +# @example +# +# # bad +# +# format('A value: %s and another: %i', a_value) +# @example +# +# # good +# +# format('A value: %s and another: %i', a_value, another) +# @example +# +# # bad +# +# format('Unnumbered format: %s and numbered: %2$s', a_value, another) +# @example +# +# # good +# +# format('Numbered format: %1$s and numbered %2$s', a_value, another) +# +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#38 +class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#100 + def called_on_string?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#49 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#137 + def count_format_matches(node); end + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#119 + def count_matches(node); end + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#141 + def count_percent_matches(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#129 + def countable_format?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#133 + def countable_percent?(node); end + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#153 + def expected_fields_count(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#168 + def format?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#146 + def format_method?(name, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#64 + def format_string?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#115 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#68 + def invalid_format_string?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#91 + def matched_arguments_count?(expected, passed); end + + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#186 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#105 + def method_with_format_args?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#77 + def offending_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#176 + def percent?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#109 + def splat_args?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#172 + def sprintf?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#195 + def string_type?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#44 +RuboCop::Cop::Lint::FormatParameterMismatch::KERNEL = T.let(T.unsafe(nil), String) + +# http://rubular.com/r/CvpbxkcTzy +# +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#39 +RuboCop::Cop::Lint::FormatParameterMismatch::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#41 +RuboCop::Cop::Lint::FormatParameterMismatch::MSG_INVALID = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#47 +RuboCop::Cop::Lint::FormatParameterMismatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#45 +RuboCop::Cop::Lint::FormatParameterMismatch::SHOVEL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#46 +RuboCop::Cop::Lint::FormatParameterMismatch::STRING_TYPES = T.let(T.unsafe(nil), Array) + +# Prefer using `Hash#compare_by_identity` rather than using `object_id` +# for hash keys. +# +# This cop looks for hashes being keyed by objects' `object_id`, using +# one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`. +# +# @example +# # bad +# hash = {} +# hash[foo.object_id] = :bar +# hash.key?(baz.object_id) +# +# # good +# hash = {}.compare_by_identity +# hash[foo] = :bar +# hash.key?(baz) +# +# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#31 +class RuboCop::Cop::Lint::HashCompareByIdentity < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#37 + def id_as_hash_key?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#41 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#34 +RuboCop::Cop::Lint::HashCompareByIdentity::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#32 +RuboCop::Cop::Lint::HashCompareByIdentity::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the ordering of a method call where +# the receiver of the call is a HEREDOC. +# +# @example +# # bad +# <<-SQL +# bar +# SQL +# .strip_indent +# +# <<-SQL +# bar +# SQL +# .strip_indent +# .trim +# +# # good +# <<~SQL +# bar +# SQL +# +# <<~SQL.trim +# bar +# SQL +# +# source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#31 +class RuboCop::Cop::Lint::HeredocMethodCallPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#37 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#37 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#97 + def all_on_same_line?(nodes); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#50 + def autocorrect(corrector, node, heredoc); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#77 + def call_after_heredoc_range(heredoc); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#107 + def call_end_pos(node); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#116 + def call_line_range(node); end + + # Returns nil if no range can be safely repositioned. + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#122 + def call_range_to_safely_reposition(node, heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#86 + def calls_on_multiple_lines?(node, _heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#82 + def correctly_positioned?(node, heredoc); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#111 + def heredoc_begin_line_range(heredoc); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#103 + def heredoc_end_pos(heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#73 + def heredoc_node?(node); end + + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#59 + def heredoc_node_descendent_receiver(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#67 + def send_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#146 + def trailing_comma?(call_source, call_line_source); end +end + +# source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#35 +RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String) + +# Prefer `equal?` over `==` when comparing `object_id`. +# +# `Object#equal?` is provided to compare objects for identity, and in contrast +# `Object#==` is provided for the purpose of doing value comparison. +# +# @example +# # bad +# foo.object_id == bar.object_id +# +# # good +# foo.equal?(bar) +# +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#18 +class RuboCop::Cop::Lint::IdentityComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#40 + def compare_between_object_id_by_double_equal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#44 + def object_id_method?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#21 +RuboCop::Cop::Lint::IdentityComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#22 +RuboCop::Cop::Lint::IdentityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for implicit string concatenation of string literals +# which are on the same line. +# +# @example +# +# # bad +# +# array = ['Item 1' 'Item 2'] +# @example +# +# # good +# +# array = ['Item 1Item 2'] +# array = ['Item 1' + 'Item 2'] +# array = [ +# 'Item 1' \ +# 'Item 2' +# ] +# +# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#25 +class RuboCop::Cop::Lint::ImplicitStringConcatenation < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#33 + def on_dstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#83 + def display_str(node); end + + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#50 + def each_bad_cons(node); end + + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#65 + def ending_delimiter(str); end + + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#91 + def str_content(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#75 + def string_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#79 + def string_literals?(node1, node2); end +end + +# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#28 +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_ARRAY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#30 +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#26 +RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String) + +# Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0. +# +# When an array of IO objects waiting for an exception (the third argument of `IO.select`) +# is used as an argument, there is no alternative API, so offenses are not registered. +# +# NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`, +# and the return value of `io.wait_readable` and `io.wait_writable` are `self`. +# They are not autocorrected when assigning a return value because these types are different. +# It's up to user how to handle the return value. +# +# @example +# +# # bad +# IO.select([io], [], [], timeout) +# +# # good +# io.wait_readable(timeout) +# +# # bad +# IO.select([], [io], [], timeout) +# +# # good +# io.wait_writable(timeout) +# +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#34 +class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#41 + def io_select(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#46 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#69 + def preferred_method(read, write, timeout); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#63 + def scheduler_compatible?(io1, io2); end +end + +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#37 +RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#38 +RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `private` or `protected` access modifiers which are +# applied to a singleton method. These access modifiers do not make +# singleton methods private/protected. `private_class_method` can be +# used for that. +# +# @example +# +# # bad +# +# class C +# private +# +# def self.method +# puts 'hi' +# end +# end +# @example +# +# # good +# +# class C +# def self.method +# puts 'hi' +# end +# +# private_class_method :method +# end +# @example +# +# # good +# +# class C +# class << self +# private +# +# def method +# puts 'hi' +# end +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#48 +class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#59 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#59 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#55 + def private_class_methods(param0); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#109 + def access_modifier?(node); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#66 + def check_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#113 + def correct_visibility?(node, modifier, ignored_methods); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#78 + def format_message(modifier); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#91 + def ineffective_modifier(node, ignored_methods = T.unsafe(nil), modifier = T.unsafe(nil), &block); end + + # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#74 + def private_class_method_names(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#51 +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PRIVATE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#52 +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PROTECTED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#49 +RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String) + +# Looks for error classes inheriting from `Exception`. +# It is configurable to suggest using either `StandardError` (default) or +# `RuntimeError` instead. +# +# @example EnforcedStyle: standard_error (default) +# # bad +# +# class C < Exception; end +# +# C = Class.new(Exception) +# +# # good +# +# class C < StandardError; end +# +# C = Class.new(StandardError) +# @example EnforcedStyle: runtime_error +# # bad +# +# class C < Exception; end +# +# C = Class.new(Exception) +# +# # good +# +# class C < RuntimeError; end +# +# C = Class.new(RuntimeError) +# +# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#40 +class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#53 + def class_new_call?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#59 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#70 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#87 + def exception_class?(class_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#91 + def inherit_exception_class_with_omitted_namespace?(class_node); end + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#83 + def message(node); end + + # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#99 + def preferred_base_class; end +end + +# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#44 +RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#45 +RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#50 +RuboCop::Cop::Lint::InheritException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for interpolation in a single quoted string. +# +# @example +# +# # bad +# +# foo = 'something with #{interpolation} inside' +# @example +# +# # good +# +# foo = "something with #{interpolation} inside" +# +# source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#25 +class RuboCop::Cop::Lint::InterpolationCheck < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#31 + def on_str(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#42 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#53 + def heredoc?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#28 +RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String) + +# Checks uses of lambda without a literal block. +# It emulates the following warning in Ruby 3.0: +# +# $ ruby -vwe 'lambda(&proc {})' +# ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] +# -e:1: warning: lambda without a literal block is deprecated; use the proc without +# lambda instead +# +# This way, proc object is never converted to lambda. +# Autocorrection replaces with compatible proc argument. +# +# @example +# +# # bad +# lambda(&proc { do_something }) +# lambda(&Proc.new { do_something }) +# +# # good +# proc { do_something } +# Proc.new { do_something } +# lambda { do_something } # If you use lambda. +# +# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#28 +class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#35 + def lambda_with_symbol_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#39 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#31 +RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#32 +RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for literals used as the conditions or as +# operands in and/or expressions serving as the conditions of +# if/while/until/case-when/case-in. +# +# NOTE: Literals in `case-in` condition where the match variable is used in +# `in` are accepted as a pattern matching. +# +# @example +# +# # bad +# if 20 +# do_something +# end +# +# # bad +# if some_var && true +# do_something +# end +# +# # good +# if some_var && some_condition +# do_something +# end +# +# # good +# # When using a boolean value for an infinite loop. +# while true +# break if condition +# end +# +# source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#35 +class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#93 + def message(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#58 + def on_case(case_node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#73 + def on_case_match(case_match_node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#40 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#87 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#51 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#51 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#44 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#44 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#108 + def basic_literal?(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#138 + def check_case(case_node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#99 + def check_for_literal(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#120 + def check_node(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#147 + def condition(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#130 + def handle_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#116 + def primitive_array?(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#155 + def when_conditions_range(when_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#38 +RuboCop::Cop::Lint::LiteralAsCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for literal assignments in the conditions of `if`, `while`, and `until`. +# It emulates the following Ruby warning: +# +# [source,console] +# ---- +# $ ruby -we 'if x = true; end' +# -e:1: warning: found `= literal' in conditional, should be == +# ---- +# +# As a lint cop, it cannot be determined if `==` is appropriate as intended, +# therefore this cop does not provide autocorrection. +# +# @example +# +# # bad +# if x = 42 +# do_something +# end +# +# # good +# if x == 42 +# do_something +# end +# +# # good +# if x = y +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#35 +class RuboCop::Cop::Lint::LiteralAssignmentInCondition < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39 + def on_while(node); end + + private + + # @yield [node] + # + # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#56 + def traverse_node(node, &block); end +end + +# source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#36 +RuboCop::Cop::Lint::LiteralAssignmentInCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for interpolated literals. +# +# @example +# +# # bad +# +# "result is #{10}" +# @example +# +# # good +# +# "result is 10" +# +# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#19 +class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#28 + def on_interpolation(begin_node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#62 + def autocorrected_value(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#108 + def autocorrected_value_for_array(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#114 + def autocorrected_value_for_hash(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#84 + def autocorrected_value_for_string(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#92 + def autocorrected_value_for_symbol(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#125 + def autocorrected_value_in_hash(node); end + + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#99 + def autocorrected_value_in_hash_for_symbol(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#155 + def ends_heredoc_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#163 + def in_array_percent_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#48 + def offending?(node); end + + # Does node print its own source when converted to a string? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#146 + def prints_as_self?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#151 + def space_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#56 + def special_keyword?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#26 +RuboCop::Cop::Lint::LiteralInInterpolation::COMPOSITE = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#25 +RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of `begin...end while/until something`. +# +# @example +# +# # bad +# +# # using while +# begin +# do_something +# end while some_condition +# @example +# +# # bad +# +# # using until +# begin +# do_something +# end until some_condition +# @example +# +# # good +# +# # while replacement +# loop do +# do_something +# break unless some_condition +# end +# @example +# +# # good +# +# # until replacement +# loop do +# do_something +# break if some_condition +# end +# +# source://rubocop//lib/rubocop/cop/lint/loop.rb#50 +class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/loop.rb#59 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/lint/loop.rb#55 + def on_while_post(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/loop.rb#79 + def build_break_line(node); end + + # source://rubocop//lib/rubocop/cop/lint/loop.rb#75 + def keyword_and_condition_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/loop.rb#65 + def register_offense(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/loop.rb#53 +RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String) + +# cop disables on wide ranges of code, that latter contributors to +# a file wouldn't be aware of. +# +# @example +# # Lint/MissingCopEnableDirective: +# # MaximumRangeSize: .inf +# +# # good +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # rubocop:enable Layout/SpaceAroundOperators +# # y = 1 +# # EOF +# +# # bad +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # EOF +# @example +# # Lint/MissingCopEnableDirective: +# # MaximumRangeSize: 2 +# +# # good +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # With the previous, there are 2 lines on which cop is disabled. +# # rubocop:enable Layout/SpaceAroundOperators +# +# # bad +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# x += 1 +# # Including this, that's 3 lines on which the cop is disabled. +# # rubocop:enable Layout/SpaceAroundOperators +# +# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#45 +class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#51 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#70 + def acceptable_range?(cop, line_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#104 + def department_enabled?(cop, comment); end + + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#64 + def each_missing_enable; end + + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#87 + def max_range; end + + # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#91 + def message(cop, comment, type = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#48 +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#49 +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), String) + +# Checks for the presence of constructors and lifecycle callbacks +# without calls to `super`. +# +# This cop does not consider `method_missing` (and `respond_to_missing?`) +# because in some cases it makes sense to overtake what is considered a +# missing method. In other cases, the theoretical ideal handling could be +# challenging or verbose for no actual gain. +# +# Autocorrection is not supported because the position of `super` cannot be +# determined automatically. +# +# `Object` and `BasicObject` are allowed by this cop because of their +# stateless nature. However, sometimes you might want to allow other parent +# classes from this cop, for example in the case of an abstract class that is +# not meant to be called with `super`. In those cases, you can use the +# `AllowedParentClasses` option to specify which classes should be allowed +# *in addition to* `Object` and `BasicObject`. +# +# @example +# # bad +# class Employee < Person +# def initialize(name, salary) +# @salary = salary +# end +# end +# +# # good +# class Employee < Person +# def initialize(name, salary) +# super(name) +# @salary = salary +# end +# end +# +# # bad +# Employee = Class.new(Person) do +# def initialize(name, salary) +# @salary = salary +# end +# end +# +# # good +# Employee = Class.new(Person) do +# def initialize(name, salary) +# super(name) +# @salary = salary +# end +# end +# +# # bad +# class Parent +# def self.inherited(base) +# do_something +# end +# end +# +# # good +# class Parent +# def self.inherited(base) +# super +# do_something +# end +# end +# +# # good +# class ClassWithNoParent +# def initialize +# do_something +# end +# end +# @example AllowedParentClasses: [MyAbstractClass] +# # good +# class MyConcreteClass < MyAbstractClass +# def initialize +# do_something +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#85 +class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#99 + def class_new_block(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#105 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#115 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#149 + def allowed_class?(node); end + + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#153 + def allowed_classes; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#127 + def callback_method_def?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#133 + def contains_super?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#137 + def inside_class_with_stateful_parent?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#123 + def offender?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#96 +RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#87 +RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#91 +RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#86 +RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#92 +RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#89 +RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array) + +# Checks for mixed-case character ranges since they include likely unintended characters. +# +# Offenses are registered for regexp character classes like `/[A-z]/` +# as well as range objects like `('A'..'z')`. +# +# NOTE: Range objects cannot be autocorrected. +# +# @example +# +# # bad +# r = /[A-z]/ +# +# # good +# r = /[A-Za-z]/ +# +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#28 +class RuboCop::Cop::Lint::MixedCaseRange < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#56 + def each_unsafe_regexp_range(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37 + def on_irange(node); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#48 + def on_regexp(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#72 + def build_source_range(range_start, range_end); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#76 + def range_for(char); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#82 + def range_pairs(expr); end + + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#102 + def rewrite_regexp_range(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#92 + def skip_expression?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#96 + def skip_range?(range_start, range_end); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#86 + def unsafe_range?(range_start, range_end); end +end + +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#32 +RuboCop::Cop::Lint::MixedCaseRange::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#35 +RuboCop::Cop::Lint::MixedCaseRange::RANGES = T.let(T.unsafe(nil), Array) + +# Do not mix named captures and numbered captures in a Regexp literal +# because numbered capture is ignored if they're mixed. +# Replace numbered captures with non-capturing groupings or +# named captures. +# +# @example +# # bad +# /(?FOO)(BAR)/ +# +# # good +# /(?FOO)(?BAR)/ +# +# # good +# /(?FOO)(?:BAR)/ +# +# # good +# /(FOO)(BAR)/ +# +# source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#24 +class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#27 + def on_regexp(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#25 +RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String) + +# In math and Python, we can use `x < y < z` style comparison to compare +# multiple value. However, we can't use the comparison in Ruby. However, +# the comparison is not syntax error. This cop checks the bad usage of +# comparison operators. +# +# @example +# +# # bad +# x < y < z +# 10 <= x <= 20 +# +# # good +# x < y && y < z +# 10 <= x && x <= 20 +# +# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#20 +class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#29 + def multiple_compare?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#33 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#24 +RuboCop::Cop::Lint::MultipleComparison::COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#23 +RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#26 +RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#25 +RuboCop::Cop::Lint::MultipleComparison::SET_OPERATION_OPERATORS = T.let(T.unsafe(nil), Array) + +# Checks for nested method definitions. +# +# @example +# +# # bad +# +# # `bar` definition actually produces methods in the same scope +# # as the outer `foo` method. Furthermore, the `bar` method +# # will be redefined every time `foo` is invoked. +# def foo +# def bar +# end +# end +# @example +# +# # good +# +# def foo +# bar = -> { puts 'hello' } +# bar.call +# end +# @example +# +# # good +# +# # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and +# # `module_exec` blocks are allowed by default. +# +# def foo +# self.class.class_eval do +# def bar +# end +# end +# end +# +# def foo +# self.class.module_exec do +# def bar +# end +# end +# end +# @example +# +# # good +# +# def foo +# class << self +# def bar +# end +# end +# end +# @example AllowedMethods: [] (default) +# # bad +# def do_something +# has_many :articles do +# def find_or_create_by_name(name) +# end +# end +# end +# @example AllowedMethods: ['has_many'] +# # bad +# def do_something +# has_many :articles do +# def find_or_create_by_name(name) +# end +# end +# end +# @example AllowedPatterns: [] (default) +# # bad +# def foo(obj) +# obj.do_baz do +# def bar +# end +# end +# end +# @example AllowedPatterns: ['baz'] +# # good +# def foo(obj) +# obj.do_baz do +# def bar +# end +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#97 +class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#133 + def eval_call?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#138 + def exec_call?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#103 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#103 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#126 + def allowed_method_name?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#121 + def scoping_method_call?(child); end +end + +# source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#101 +RuboCop::Cop::Lint::NestedMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for nested percent literals. +# +# @example +# +# # bad +# +# # The percent literal for nested_attributes is parsed as four tokens, +# # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"]. +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: %i[name content %i[incorrectly nested]] +# } +# +# # good +# +# # Neither is incompatible with the bad case, but probably the intended code. +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: [:name, :content, %i[incorrectly nested]] +# } +# +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: [:name, :content, [:incorrectly, :nested]] +# } +# +# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#32 +class RuboCop::Cop::Lint::NestedPercentLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + + # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#44 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#48 + def on_percent_literal(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#54 + def contains_percent_literals?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#35 +RuboCop::Cop::Lint::NestedPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +# The array of regular expressions representing percent literals that, +# if found within a percent literal expression, will cause a +# NestedPercentLiteral violation to be emitted. +# +# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#41 +RuboCop::Cop::Lint::NestedPercentLiteral::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#42 +RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array) + +# Don't omit the accumulator when calling `next` in a `reduce` block. +# +# @example +# +# # bad +# +# result = (1..4).reduce(0) do |acc, i| +# next if i.odd? +# acc + i +# end +# @example +# +# # good +# +# result = (1..4).reduce(0) do |acc, i| +# next acc if i.odd? +# acc + i +# end +# +# source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#25 +class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#28 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#51 + def on_block_body_of_reduce(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#38 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#56 + def on_numblock_body_of_reduce(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#60 + def parent_block_node(node); end + + # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#64 + def parent_numblock_node(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#26 +RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of a `return` inside a `begin..end` block +# in assignment contexts. +# In this situation, the `return` will result in an exit from the current +# method, possibly leading to unexpected behavior. +# +# @example +# +# # bad +# +# @some_variable ||= begin +# return some_value if some_condition_is_met +# +# do_something +# end +# @example +# +# # good +# +# @some_variable ||= begin +# if some_condition_is_met +# some_value +# else +# do_something +# end +# end +# +# # good +# +# some_variable = if some_condition_is_met +# return if another_condition_is_met +# +# some_value +# else +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#43 +class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#46 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#46 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#46 + def on_or_asgn(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#44 +RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-atomic file operation. +# And then replace it with a nearly equivalent and atomic method. +# +# These can cause problems that are difficult to reproduce, +# especially in cases of frequent file operations in parallel, +# such as test runs with parallel_rspec. +# +# For examples: creating a directory if there is none, has the following problems +# +# An exception occurs when the directory didn't exist at the time of `exist?`, +# but someone else created it before `mkdir` was executed. +# +# Subsequent processes are executed without the directory that should be there +# when the directory existed at the time of `exist?`, +# but someone else deleted it shortly afterwards. +# +# @example +# # bad - race condition with another process may result in an error in `mkdir` +# unless Dir.exist?(path) +# FileUtils.mkdir(path) +# end +# +# # good - atomic and idempotent creation +# FileUtils.mkdir_p(path) +# +# # bad - race condition with another process may result in an error in `remove` +# if File.exist?(path) +# FileUtils.remove(path) +# end +# +# # good - atomic and idempotent removal +# FileUtils.rm_f(path) +# +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#44 +class RuboCop::Cop::Lint::NonAtomicFileOperation < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#76 + def explicit_not_force?(param0); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#71 + def force?(param0); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#80 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#66 + def receiver_and_method_name(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#61 + def send_exist_node(param0); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#97 + def allowable_use_with_if?(if_node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#121 + def autocorrect(corrector, node, range); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#132 + def autocorrect_replace_method(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#151 + def force_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#159 + def force_method_name?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#155 + def force_option?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#91 + def if_node_child?(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#112 + def message_change_force_method(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#116 + def message_remove_file_exist_check(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#101 + def register_offense(node, exist_node); end + + # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#139 + def replacement_method(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#50 +RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_FORCE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#51 +RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#49 +RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_CHANGE_FORCE_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#47 +RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_REMOVE_FILE_EXIST_CHECK = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#54 +RuboCop::Cop::Lint::NonAtomicFileOperation::RECURSIVE_REMOVE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#52 +RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_FORCE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#53 +RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#55 +RuboCop::Cop::Lint::NonAtomicFileOperation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# `Dir[...]` and `Dir.glob(...)` do not make any guarantees about +# the order in which files are returned. The final order is +# determined by the operating system and file system. +# This means that using them in cases where the order matters, +# such as requiring files, can lead to intermittent failures +# that are hard to debug. To ensure this doesn't happen, +# always sort the list. +# +# `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0. +# So all bad cases are acceptable when Ruby 3.0 or higher are used. +# +# NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher. +# +# @example +# +# # bad +# Dir["./lib/**/*.rb"].each do |file| +# require file +# end +# +# # good +# Dir["./lib/**/*.rb"].sort.each do |file| +# require file +# end +# +# # bad +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file| +# require file +# end +# +# # good +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file| +# require file +# end +# +# # bad +# Dir['./lib/**/*.rb'].each(&method(:require)) +# +# # good +# Dir['./lib/**/*.rb'].sort.each(&method(:require)) +# +# # bad +# Dir.glob(Rails.root.join('test', '*.rb'), &method(:require)) +# +# # good +# Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require)) +# +# # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher. +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require)) +# +# source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#60 +class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#172 + def loop_variable(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#155 + def method_require?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#65 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#89 + def on_block_pass(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#77 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#145 + def unsorted_dir_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#150 + def unsorted_dir_each?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#166 + def unsorted_dir_each_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#160 + def unsorted_dir_glob_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#177 + def var_is_required?(param0, param1); end + + private + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#107 + def correct_block(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#117 + def correct_block_pass(corrector, node); end + + # Returns range of last argument including comma and whitespace. + # + # @return [Parser::Source::Range] + # + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#132 + def last_arg_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#136 + def unsorted_dir_loop?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#140 + def unsorted_dir_pass?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#63 +RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-local exits from iterators without a return +# value. It registers an offense under these conditions: +# +# * No value is returned, +# * the block is preceded by a method chain, +# * the block has arguments, +# * the method which receives the block is not `define_method` +# or `define_singleton_method`, +# * the return is not contained in an inner scope, e.g. a lambda or a +# method definition. +# +# @example +# +# class ItemApi +# rescue_from ValidationError do |e| # non-iteration block with arg +# return { message: 'validation error' } unless e.errors # allowed +# error_array = e.errors.map do |error| # block with method chain +# return if error.suppress? # warned +# return "#{error.param}: invalid" unless error.message # allowed +# "#{error.param}: #{error.message}" +# end +# { message: 'validation error', errors: error_array } +# end +# +# def update_items +# transaction do # block without arguments +# return unless update_necessary? # allowed +# find_each do |item| # block without method chain +# return if item.stock == 0 # false-negative... +# item.update!(foobar: true) +# end +# end +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#41 +class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#77 + def chained_send?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#80 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#46 + def on_return(return_node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#72 + def return_value?(return_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#68 + def scoped_node?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#42 +RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String) + +# Warns the usage of unsafe number conversions. Unsafe +# number conversion can cause unexpected error if auto type conversion +# fails. Cop prefer parsing with number class instead. +# +# Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError` +# if given input that is not numeric (eg. an empty string), whereas +# `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`). +# As such, this cop is disabled by default because it's not necessarily +# always correct to raise if a value is not numeric. +# +# NOTE: Some values cannot be converted properly using one of the `Kernel` +# method (for instance, `Time` and `DateTime` values are allowed by this +# cop by default). Similarly, Rails' duration methods do not work well +# with `Integer()` and can be allowed with `AllowedMethods`. By default, +# there are no methods to allowed. +# +# @example +# +# # bad +# +# '10'.to_i +# '10.2'.to_f +# '10'.to_c +# '1/3'.to_r +# ['1', '2', '3'].map(&:to_i) +# foo.try(:to_f) +# bar.send(:to_c) +# +# # good +# +# Integer('10', 10) +# Float('10.2') +# Complex('10') +# Rational('1/3') +# ['1', '2', '3'].map { |i| Integer(i, 10) } +# foo.try { |i| Float(i) } +# bar.send { |i| Complex(i) } +# @example AllowedMethods: [] (default) +# +# # bad +# 10.minutes.to_i +# @example AllowedMethods: [minutes] +# +# # good +# 10.minutes.to_i +# @example AllowedPatterns: [] (default) +# +# # bad +# 10.minutes.to_i +# @example AllowedPatterns: ['min*'] +# +# # good +# 10.minutes.to_i +# @example IgnoredClasses: [Time, DateTime] (default) +# +# # good +# Time.now.to_datetime.to_i +# +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#73 +class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#103 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#93 + def to_method(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#98 + def to_method_symbol(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#160 + def allow_receiver?(receiver); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#172 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#182 + def conversion_method?(method_name); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#146 + def correct_method(node, receiver); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#150 + def correct_sym_method(to_method); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#129 + def handle_as_symbol(node); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#110 + def handle_conversion_method(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#190 + def ignored_class?(name); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#186 + def ignored_classes; end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#155 + def remove_parentheses(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#176 + def top_receiver(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#89 +RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#79 +RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#90 +RuboCop::Cop::Lint::NumberConversion::METHODS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#85 +RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of numbered parameter assignment. +# It emulates the following warning in Ruby 2.7: +# +# $ ruby -ve '_1 = :value' +# ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19] +# -e:1: warning: `_1' is reserved for numbered parameter; consider another name +# +# Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0. +# +# $ ruby -ve '_1 = :value' +# ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] +# -e:1: _1 is reserved for numbered parameter +# +# NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10` +# as well to prevent confusion. +# +# @example +# +# # bad +# _1 = :value +# +# # good +# non_numbered_parameter_name = :value +# +# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#30 +class RuboCop::Cop::Lint::NumberedParameterAssignment < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#35 + def on_lvasgn(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#32 +RuboCop::Cop::Lint::NumberedParameterAssignment::LVAR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#33 +RuboCop::Cop::Lint::NumberedParameterAssignment::NUMBERED_PARAMETER_RANGE = T.let(T.unsafe(nil), Range) + +# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#31 +RuboCop::Cop::Lint::NumberedParameterAssignment::NUM_PARAM_MSG = T.let(T.unsafe(nil), String) + +# Checks for unintended or-assignment to a constant. +# +# Constants should always be assigned in the same location. And its value +# should always be the same. If constants are assigned in multiple +# locations, the result may vary depending on the order of `require`. +# +# @example +# +# # bad +# CONST ||= 1 +# +# # good +# CONST = 1 +# +# source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#24 +class RuboCop::Cop::Lint::OrAssignmentToConstant < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#29 + def on_or_asgn(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#27 +RuboCop::Cop::Lint::OrAssignmentToConstant::MSG = T.let(T.unsafe(nil), String) + +# Checks the proper ordering of magic comments and whether +# a magic comment is not placed before a shebang. +# +# @example +# # bad +# +# # frozen_string_literal: true +# # encoding: ascii +# p [''.frozen?, ''.encoding] #=> [true, #] +# +# # good +# +# # encoding: ascii +# # frozen_string_literal: true +# p [''.frozen?, ''.encoding] #=> [true, #] +# +# # good +# +# #!/usr/bin/env ruby +# # encoding: ascii +# # frozen_string_literal: true +# p [''.frozen?, ''.encoding] #=> [true, #] +# +# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#32 +class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#38 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#55 + def autocorrect(corrector, encoding_line, frozen_string_literal_line); end + + # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#63 + def magic_comment_lines; end +end + +# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#36 +RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String) + +# Looks for references of Regexp captures that are out of range +# and thus always returns nil. +# +# @example +# +# /(foo)bar/ =~ 'foobar' +# +# # bad - always returns nil +# +# puts $2 # => nil +# +# # good +# +# puts $1 # => foo +# +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#38 +class RuboCop::Cop::Lint::OutOfRangeRegexpRef < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#55 + def after_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#71 + def on_in_pattern(node); end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#51 + def on_match_with_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#47 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#77 + def on_nth_ref(node); end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#65 + def on_when(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#102 + def check_regexp(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#122 + def nth_ref_receiver?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#113 + def regexp_first_argument?(send_node); end + + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#93 + def regexp_patterns(in_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#118 + def regexp_receiver?(send_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#39 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#42 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_ARGUMENT_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#44 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_CAPTURE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#41 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_RECEIVER_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#45 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks for space between the name of a called method and a left +# parenthesis. +# +# @example +# +# # bad +# do_something (foo) +# +# # good +# do_something(foo) +# do_something (2 + 3) * 4 +# do_something (foo * bar).baz +# +# source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#18 +class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#24 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#61 + def chained_calls?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#49 + def first_argument_block_type?(first_arg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#57 + def first_argument_starts_with_left_parenthesis?(node); end + + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#86 + def space_range(expr, space_length); end + + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#70 + def spaces_before_left_parenthesis(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#66 + def ternary_expression?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#39 + def valid_context?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#53 + def valid_first_argument?(first_arg); end +end + +# source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#22 +RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::MSG = T.let(T.unsafe(nil), String) + +# Checks for quotes and commas in %w, e.g. `%w('foo', "bar")` +# +# It is more likely that the additional characters are unintended (for +# example, mistranslating an array of literals to percent string notation) +# rather than meant to be part of the resulting strings. +# +# @example +# +# # bad +# +# %w('foo', "bar") +# @example +# +# # good +# +# %w(foo bar) +# +# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#33 +class RuboCop::Cop::Lint::PercentStringArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#44 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#48 + def on_percent_literal(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#65 + def contains_quotes_or_commas?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#38 +RuboCop::Cop::Lint::PercentStringArray::LEADING_QUOTE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#41 +RuboCop::Cop::Lint::PercentStringArray::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#37 +RuboCop::Cop::Lint::PercentStringArray::QUOTES_AND_COMMAS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#39 +RuboCop::Cop::Lint::PercentStringArray::TRAILING_QUOTE = T.let(T.unsafe(nil), Regexp) + +# Checks for colons and commas in %i, e.g. `%i(:foo, :bar)` +# +# It is more likely that the additional characters are unintended (for +# example, mistranslating an array of literals to percent string notation) +# rather than meant to be part of the resulting symbols. +# +# @example +# +# # bad +# +# %i(:foo, :bar) +# @example +# +# # good +# +# %i(foo bar) +# +# source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#23 +class RuboCop::Cop::Lint::PercentSymbolArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#30 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#34 + def on_percent_literal(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#42 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#52 + def contains_colons_or_commas?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#62 + def non_alphanumeric_literal?(literal); end +end + +# source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#27 +RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String) + +# Checks for `raise` or `fail` statements which are +# raising `Exception` class. +# +# You can specify a module name that will be an implicit namespace +# using `AllowedImplicitNamespaces` option. The cop cause a false positive +# for namespaced `Exception` when a namespace is omitted. This option can +# prevent the false positive by specifying a namespace to be omitted for +# `Exception`. Alternatively, make `Exception` a fully qualified class +# name with an explicit namespace. +# +# @example +# # bad +# raise Exception, 'Error message here' +# +# # good +# raise StandardError, 'Error message here' +# @example AllowedImplicitNamespaces: ['Gem'] +# # good +# module Gem +# def self.foo +# raise Exception # This exception means `Gem::Exception`. +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#34 +class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#41 + def exception?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#46 + def exception_new_with_message?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#51 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#85 + def allow_implicit_namespaces; end + + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#57 + def check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#73 + def implicit_namespace?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#37 +RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#38 +RuboCop::Cop::Lint::RaiseException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `rand(1)` calls. +# Such calls always return `0`. +# +# @example +# +# # bad +# +# rand 1 +# Kernel.rand(-1) +# rand 1.0 +# rand(-1.0) +# @example +# +# # good +# +# 0 # just use 0 instead +# +# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#23 +class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#32 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#28 + def rand_one?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#40 + def message(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#24 +RuboCop::Cop::Lint::RandOne::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#25 +RuboCop::Cop::Lint::RandOne::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# removed without causing any offenses to be reported. It's implemented +# as a cop in that it inherits from the Cop base class and calls +# add_offense. The unusual part of its implementation is that it doesn't +# have any on_* methods or an investigate method. This means that it +# doesn't take part in the investigation phase when the other cops do +# their work. Instead, it waits until it's called in a later stage of the +# execution. The reason it can't be implemented as a normal cop is that +# it depends on the results of all other cops to do its work. +# +# @example +# # bad +# # rubocop:disable Layout/LineLength +# x += 1 +# # rubocop:enable Layout/LineLength +# +# # good +# x += 1 +# +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#28 +class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [RedundantCopDisableDirective] a new instance of RedundantCopDisableDirective + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#37 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil), offenses = T.unsafe(nil)); end + + # Returns the value of attribute offenses_to_check. + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#35 + def offenses_to_check; end + + # Sets the attribute offenses_to_check + # + # @param value the value to set the attribute offenses_to_check to. + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#35 + def offenses_to_check=(_arg0); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#42 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#323 + def add_department_marker(department); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#229 + def add_offense_for_entire_comment(comment, cops); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#244 + def add_offense_for_some_cops(comment, cops); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#219 + def add_offenses(redundant_cops); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#306 + def all_cop_names; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#190 + def all_disabled?(comment); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#69 + def comment_range_with_surrounding_space(directive_comment_range, line_comment_range); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#57 + def cop_disabled_line_ranges; end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#264 + def cop_range(comment, cop); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#210 + def department_disabled?(cop, comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#315 + def department_marker?(department); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#293 + def describe(cop); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#215 + def directive_count(comment); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#92 + def directive_range_in_list(range, ranges); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#61 + def disabled_ranges; end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#132 + def each_already_disabled(cop, line_ranges); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#113 + def each_line_range(cop, line_ranges); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#106 + def each_redundant_disable(&block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#310 + def ends_its_line?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#202 + def expected_final_disable?(cop, line_range); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#166 + def find_redundant_all(range, next_range); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#161 + def find_redundant_cop(cop, range); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#176 + def find_redundant_department(cop, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#182 + def followed_ranges?(range, next_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#194 + def ignore_offense?(line_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#258 + def leave_free_comment?(comment, range); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#271 + def matching_range(haystack, needle); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#302 + def message(cop_names); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#65 + def previous_line_blank?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#186 + def range_with_offense?(range, offenses = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#319 + def remove_department_marker(department); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#279 + def trailing_range?(ranges, range); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#32 +RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#33 +RuboCop::Cop::Lint::RedundantCopDisableDirective::DEPARTMENT_MARKER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#287 +RuboCop::Cop::Lint::RedundantCopDisableDirective::SIMILAR_COP_NAMES_CACHE = T.let(T.unsafe(nil), Hash) + +# removed. +# +# that cop checks whether any cop was actually enabled. +# +# @example +# # bad +# foo = 1 +# # rubocop:enable Layout/LineLength +# +# # good +# foo = 1 +# @example +# # bad +# # rubocop:disable Style/StringLiterals +# foo = "1" +# # rubocop:enable Style/StringLiterals +# baz +# # rubocop:enable all +# +# # good +# # rubocop:disable Style/StringLiterals +# foo = "1" +# # rubocop:enable all +# baz +# +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#37 +class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#44 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#120 + def all_or_name(name); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#76 + def comment_start(comment); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#80 + def cop_name_indention(comment, name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#124 + def department?(directive, name); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#71 + def range_of_offense(comment, name); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#95 + def range_to_remove(begin_pos, end_pos, comment); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#84 + def range_with_comma(comment, name); end + + # If the list of cops is comma-separated, but without a empty space after the comma, + # we should **not** remove the prepending empty space, thus begin_pos += 1 + # + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#114 + def range_with_comma_after(comment, start, begin_pos, end_pos); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#108 + def range_with_comma_before(start, begin_pos, end_pos); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#53 + def register_offense(comment, cop_names); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#42 +RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +# Sort globbed results by default in Ruby 3.0. +# This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`. +# +# @example +# +# # bad +# Dir.glob('./lib/**/*.rb').sort.each do |file| +# end +# +# Dir['./lib/**/*.rb'].sort.each do |file| +# end +# +# # good +# Dir.glob('./lib/**/*.rb').each do |file| +# end +# +# Dir['./lib/**/*.rb'].each do |file| +# end +# +# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#30 +class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#40 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#56 + def multiple_argument?(glob_method); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#38 +RuboCop::Cop::Lint::RedundantDirGlobSort::GLOB_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#36 +RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#37 +RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant quantifiers inside Regexp literals. +# +# It is always allowed when interpolation is used in a regexp literal, +# because it's unknown what kind of string will be expanded as a result: +# +# [source,ruby] +# ---- +# /(?:a*#{interpolation})?/x +# ---- +# +# @example +# # bad +# /(?:x+)+/ +# +# # good +# /(?:x)+/ +# +# # good +# /(?:x+)/ +# +# # bad +# /(?:x+)?/ +# +# # good +# /(?:x)*/ +# +# # good +# /(?:x*)/ +# +# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#34 +class RuboCop::Cop::Lint::RedundantRegexpQuantifiers < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#42 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#83 + def character_set?(expr); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#61 + def each_redundantly_quantified_pair(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#87 + def mergeable_quantifier(expr); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#103 + def merged_quantifier(exp1, exp2); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#119 + def message(group, child, replacement); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#115 + def quantifier_range(group, child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#75 + def redundant_group?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#79 + def redundantly_quantifiable?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#38 +RuboCop::Cop::Lint::RedundantRegexpQuantifiers::MSG_REDUNDANT_QUANTIFIER = T.let(T.unsafe(nil), String) + +# Checks for unnecessary `require` statement. +# +# The following features are unnecessary `require` statement because +# they are already loaded. e.g. Ruby 2.2: +# +# ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }' +# ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13] +# ["enumerator.so", "rational.so", "complex.so", "thread.rb"] +# +# Below are the features that each `TargetRubyVersion` targets. +# +# * 2.0+ ... `enumerator` +# * 2.1+ ... `thread` +# * 2.2+ ... Add `rational` and `complex` above +# * 2.5+ ... Add `pp` above +# * 2.7+ ... Add `ruby2_keywords` above +# * 3.1+ ... Add `fiber` above +# * 3.2+ ... `set` +# +# This cop target those features. +# +# @example +# # bad +# require 'unloaded_feature' +# require 'thread' +# +# # good +# require 'unloaded_feature' +# +# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#38 +class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#61 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#57 + def pp_const?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#51 + def redundant_require_statement?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#91 + def need_to_require_pp?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#80 + def redundant_feature?(feature_name); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#42 +RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#45 +RuboCop::Cop::Lint::RedundantRequireStatement::PRETTY_PRINT_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#43 +RuboCop::Cop::Lint::RedundantRequireStatement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#44 +RuboCop::Cop::Lint::RedundantRequireStatement::RUBY_22_LOADED_FEATURES = T.let(T.unsafe(nil), Array) + +# Checks for redundant safe navigation calls. +# Use cases where a constant, named in camel case for classes and modules is `nil` are rare, +# and an offense is not detected when the receiver is a snake case constant. +# +# For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, +# and `equal?` methods are checked by default. +# These are customizable with `AllowedMethods` option. +# +# The `AllowedMethods` option specifies nil-safe methods, +# in other words, it is a method that is allowed to skip safe navigation. +# Note that the `AllowedMethod` option is not an option that specifies methods +# for which to suppress (allow) this cop's check. +# +# In the example below, the safe navigation operator (`&.`) is unnecessary +# because `NilClass` has methods like `respond_to?` and `is_a?`. +# +# @example +# # bad +# CamelCaseConst&.do_something +# +# # bad +# do_something if attrs&.respond_to?(:[]) +# +# # good +# do_something if attrs.respond_to?(:[]) +# +# # bad +# while node&.is_a?(BeginNode) +# node = node.parent +# end +# +# # good +# CamelCaseConst.do_something +# +# # good +# while node.is_a?(BeginNode) +# node = node.parent +# end +# +# # good - without `&.` this will always return `true` +# foo&.respond_to?(:to_a) +# +# # bad - for `nil`s conversion methods return default values for the type +# foo&.to_h || {} +# foo&.to_h { |k, v| [k, v] } || {} +# foo&.to_a || [] +# foo&.to_i || 0 +# foo&.to_f || 0.0 +# foo&.to_s || '' +# +# # good +# foo.to_h +# foo.to_h { |k, v| [k, v] } +# foo.to_a +# foo.to_i +# foo.to_f +# foo.to_s +# @example AllowedMethods: [nil_safe_method] +# # bad +# do_something if attrs&.nil_safe_method(:[]) +# +# # good +# do_something if attrs.nil_safe_method(:[]) +# do_something if attrs&.not_nil_safe_method(:[]) +# +# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#77 +class RuboCop::Cop::Lint::RedundantSafeNavigation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#95 + def conversion_with_default?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#107 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#117 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#90 + def respond_to_nil_specific_method?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#134 + def check?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#144 + def condition?(parent, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#82 +RuboCop::Cop::Lint::RedundantSafeNavigation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#83 +RuboCop::Cop::Lint::RedundantSafeNavigation::MSG_LITERAL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#85 +RuboCop::Cop::Lint::RedundantSafeNavigation::NIL_SPECIFIC_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#87 +RuboCop::Cop::Lint::RedundantSafeNavigation::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +# Checks for unneeded usages of splat expansion +# +# @example +# +# # bad +# a = *[1, 2, 3] +# a = *'a' +# a = *1 +# ['a', 'b', *%w(c d e), 'f', 'g'] +# +# # good +# c = [1, 2, 3] +# a = *c +# a, b = *c +# a, *b = *c +# a = *1..10 +# a = ['a'] +# ['a', 'b', 'c', 'd', 'e', 'f', 'g'] +# +# # bad +# do_something(*['foo', 'bar', 'baz']) +# +# # good +# do_something('foo', 'bar', 'baz') +# +# # bad +# begin +# foo +# rescue *[StandardError, ApplicationError] +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, ApplicationError +# bar +# end +# +# # bad +# case foo +# when *[1, 2, 3] +# bar +# else +# baz +# end +# +# # good +# case foo +# when 1, 2, 3 +# bar +# else +# baz +# end +# @example AllowPercentLiteralArrayArgument: true (default) +# +# # good +# do_something(*%w[foo bar baz]) +# @example AllowPercentLiteralArrayArgument: false +# +# # bad +# do_something(*%w[foo bar baz]) +# +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#71 +class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#83 + def array_new?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#91 + def literal_expansion(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#95 + def on_splat(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#203 + def allow_percent_literal_array_argument?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#131 + def array_new_inside_array_literal?(array_new_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#155 + def array_splat?(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#112 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#159 + def method_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#163 + def part_of_an_array?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#170 + def redundant_brackets?(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#118 + def redundant_splat_expansion(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#178 + def remove_brackets(array); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#138 + def replacement_range_and_content(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#196 + def use_percent_literal_array_argument?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#75 +RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#80 +RuboCop::Cop::Lint::RedundantSplatExpansion::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#74 +RuboCop::Cop::Lint::RedundantSplatExpansion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#79 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_I = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#77 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_W = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#78 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#76 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String) + +# Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments, +# which is redundant. +# +# @example +# +# # bad +# +# "result is #{something.to_s}" +# print something.to_s +# puts something.to_s +# warn something.to_s +# @example +# +# # good +# +# "result is #{something}" +# print something +# puts something +# warn something +# +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#27 +class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#38 + def on_interpolation(begin_node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#46 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#36 + def to_s_without_args?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#58 + def register_offense(node, context); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#31 +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#32 +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#33 +RuboCop::Cop::Lint::RedundantStringCoercion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant `with_index`. +# +# @example +# # bad +# ary.each_with_index do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# # bad +# ary.each.with_index do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#29 +class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#36 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#36 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#56 + def redundant_with_index?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#66 + def message(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#74 + def with_index_range(send); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#33 +RuboCop::Cop::Lint::RedundantWithIndex::MSG_EACH_WITH_INDEX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#34 +RuboCop::Cop::Lint::RedundantWithIndex::MSG_WITH_INDEX = T.let(T.unsafe(nil), String) + +# Checks for redundant `with_object`. +# +# @example +# # bad +# ary.each_with_object([]) do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# # bad +# ary.each.with_object([]) do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#29 +class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#36 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#36 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#56 + def redundant_with_object?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#65 + def message(node); end + + # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#73 + def with_object_range(send); end +end + +# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#33 +RuboCop::Cop::Lint::RedundantWithObject::MSG_EACH_WITH_OBJECT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#34 +RuboCop::Cop::Lint::RedundantWithObject::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String) + +# Checks if `include` or `prepend` is called in `refine` block. +# These methods are deprecated and should be replaced with `Refinement#import_methods`. +# +# It emulates deprecation warnings in Ruby 3.1. +# +# @example +# +# # bad +# refine Foo do +# include Bar +# end +# +# # bad +# refine Foo do +# prepend Bar +# end +# +# # good +# refine Foo do +# import_methods Bar +# end +# +# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#34 +class RuboCop::Cop::Lint::RefinementImportMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#42 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#37 +RuboCop::Cop::Lint::RefinementImportMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#38 +RuboCop::Cop::Lint::RefinementImportMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for regexp literals used as `match-current-line`. +# If a regexp literal is in condition, the regexp matches `$_` implicitly. +# +# @example +# # bad +# if /foo/ +# do_something +# end +# +# # good +# if /foo/ =~ $_ +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#19 +class RuboCop::Cop::Lint::RegexpAsCondition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#26 + def on_match_current_line(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#23 +RuboCop::Cop::Lint::RegexpAsCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for expressions where there is a call to a predicate +# method with at least one argument, where no parentheses are used around +# the parameter list, and a boolean operator, && or ||, is used in the +# last argument. +# +# The idea behind warning for these constructs is that the user might +# be under the impression that the return value from the method call is +# an operand of &&/||. +# +# @example +# +# # bad +# +# if day.is? :tuesday && month == :jan +# # ... +# end +# @example +# +# # good +# +# if day.is?(:tuesday) && month == :jan +# # ... +# end +# +# source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#30 +class RuboCop::Cop::Lint::RequireParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#35 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#35 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#58 + def check_predicate(predicate, node); end + + # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#48 + def check_ternary(ternary, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#33 +RuboCop::Cop::Lint::RequireParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks that a range literal is enclosed in parentheses when the end of the range is +# at a line break. +# +# NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`. +# So, this cop does not provide autocorrection because it is left to user. +# +# [source,ruby] +# ---- +# case condition +# when 42.. +# do_something +# end +# ---- +# +# @example +# +# # bad - Represents `(1..42)`, not endless range. +# 1.. +# 42 +# +# # good - It's incompatible, but your intentions when using endless range may be: +# (1..) +# 42 +# +# # good +# 1..42 +# +# # good +# (1..42) +# +# # good +# (1.. +# 42) +# +# source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#40 +class RuboCop::Cop::Lint::RequireRangeParentheses < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#43 + def on_erange(node); end + + # source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#43 + def on_irange(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#41 +RuboCop::Cop::Lint::RequireRangeParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses a file requiring itself with `require_relative`. +# +# @example +# +# # bad +# +# # foo.rb +# require_relative 'foo' +# require_relative 'bar' +# +# # good +# +# # foo.rb +# require_relative 'bar' +# +# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#21 +class RuboCop::Cop::Lint::RequireRelativeSelfPath < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#28 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#44 + def remove_ext(file_path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#40 + def same_file?(file_path, required_feature); end +end + +# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#25 +RuboCop::Cop::Lint::RequireRelativeSelfPath::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#26 +RuboCop::Cop::Lint::RequireRelativeSelfPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `rescue` blocks targeting the Exception class. +# +# @example +# +# # bad +# +# begin +# do_something +# rescue Exception +# handle_exception +# end +# @example +# +# # good +# +# begin +# do_something +# rescue ArgumentError +# handle_exception +# end +# +# source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#27 +class RuboCop::Cop::Lint::RescueException < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#30 + def on_resbody(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#39 + def targets_exception?(rescue_arg_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#28 +RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String) + +# Check for arguments to `rescue` that will result in a `TypeError` +# if an exception is raised. +# +# @example +# # bad +# begin +# bar +# rescue nil +# baz +# end +# +# # bad +# def foo +# bar +# rescue 1, 'a', "#{b}", 0.0, [], {} +# baz +# end +# +# # good +# begin +# bar +# rescue +# baz +# end +# +# # good +# def foo +# bar +# rescue NameError +# baz +# end +# +# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#37 +class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#60 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#44 + def on_resbody(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#71 + def correction(*exceptions); end + + # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#82 + def invalid_exceptions(exceptions); end + + # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#78 + def valid_exceptions(exceptions); end +end + +# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#42 +RuboCop::Cop::Lint::RescueType::INVALID_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#40 +RuboCop::Cop::Lint::RescueType::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of a return with a value in a context +# where the value will be ignored. (initialize and setter methods) +# +# @example +# +# # bad +# def initialize +# foo +# return :qux if bar? +# baz +# end +# +# def foo=(bar) +# return 42 +# end +# @example +# +# # good +# def initialize +# foo +# return if bar? +# baz +# end +# +# def foo=(bar) +# return +# end +# +# source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#34 +class RuboCop::Cop::Lint::ReturnInVoidContext < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#37 + def on_return(return_node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#53 + def non_void_context(return_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#35 +RuboCop::Cop::Lint::ReturnInVoidContext::MSG = T.let(T.unsafe(nil), String) + +# The safe navigation operator returns nil if the receiver is +# nil. If you chain an ordinary method call after a safe +# navigation operator, it raises NoMethodError. We should use a +# safe navigation operator after a safe navigation operator. +# This cop checks for the problem outlined above. +# +# @example +# +# # bad +# +# x&.foo.bar +# x&.foo + bar +# x&.foo[bar] +# @example +# +# # good +# +# x&.foo&.bar +# x&.foo || bar +# +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#26 +class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#37 + def bad_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#44 + def on_send(node); end + + private + + # @param offense_range [Parser::Source::Range] + # @param send_node [RuboCop::AST::SendNode] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#62 + def add_safe_navigation_operator(offense_range:, send_node:); end + + # @param corrector [RuboCop::Cop::Corrector] + # @param offense_range [Parser::Source::Range] + # @param send_node [RuboCop::AST::SendNode] + # + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#81 + def autocorrect(corrector, offense_range:, send_node:); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#90 + def brackets?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#94 + def require_parentheses?(send_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#33 +RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#34 +RuboCop::Cop::Lint::SafeNavigationChain::PLUS_MINUS_METHODS = T.let(T.unsafe(nil), Array) + +# Check to make sure that if safe navigation is used for a method +# call in an `&&` or `||` condition that safe navigation is used for all +# method calls on that same object. +# +# @example +# # bad +# foo&.bar && foo.baz +# +# # bad +# foo.bar || foo&.baz +# +# # bad +# foo&.bar && (foobar.baz || foo.baz) +# +# # good +# foo.bar && foo.baz +# +# # good +# foo&.bar || foo&.baz +# +# # good +# foo&.bar && (foobar.baz || foo&.baz) +# +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#29 +class RuboCop::Cop::Lint::SafeNavigationConsistency < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#42 + def check(node); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#36 + def on_csend(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#61 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#67 + def location(node, unsafe_method_call); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#71 + def top_conditional_ancestor(node); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#82 + def unsafe_method_calls(method_calls, safe_nav_receiver); end +end + +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#34 +RuboCop::Cop::Lint::SafeNavigationConsistency::MSG = T.let(T.unsafe(nil), String) + +# Checks to make sure safe navigation isn't used with `empty?` in +# a conditional. +# +# While the safe navigation operator is generally a good idea, when +# checking `foo&.empty?` in a conditional, `foo` being `nil` will actually +# do the opposite of what the author intends. +# +# @example +# # bad +# return if foo&.empty? +# return unless foo&.empty? +# +# # good +# return if foo && foo.empty? +# return unless foo && foo.empty? +# +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#22 +class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#32 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#28 + def safe_navigation_empty_in_conditional?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#25 +RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String) + +# Checks if a file which has a shebang line as +# its first line is granted execute permission. +# +# @example +# # bad +# +# # A file which has a shebang line as its first line is not +# # granted execute permission. +# +# #!/usr/bin/env ruby +# puts 'hello, world' +# +# # good +# +# # A file which has a shebang line as its first line is +# # granted execute permission. +# +# #!/usr/bin/env ruby +# puts 'hello, world' +# +# # good +# +# # A file which has not a shebang line as its first line is not +# # granted execute permission. +# +# puts 'hello, world' +# +# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#33 +class RuboCop::Cop::Lint::ScriptPermission < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#39 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#55 + def autocorrect(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#59 + def executable?(processed_source); end + + # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#66 + def format_message_from(processed_source); end +end + +# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#36 +RuboCop::Cop::Lint::ScriptPermission::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#37 +RuboCop::Cop::Lint::ScriptPermission::SHEBANG = T.let(T.unsafe(nil), String) + +# Checks for self-assignments. +# +# @example +# # bad +# foo = foo +# foo, bar = foo, bar +# Foo = Foo +# hash['foo'] = hash['foo'] +# obj.attr = obj.attr +# +# # good +# foo = bar +# foo, bar = bar, foo +# Foo = Bar +# hash['foo'] = hash['bar'] +# obj.attr = obj.attr2 +# +# # good (method calls possibly can return different results) +# hash[foo] = hash[foo] +# +# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#26 +class RuboCop::Cop::Lint::SelfAssignment < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#69 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#57 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#36 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#65 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#69 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#36 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#103 + def handle_attribute_assignment(node); end + + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#92 + def handle_key_assignment(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#77 + def multiple_self_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#87 + def rhs_matches_lhs?(rhs, lhs); end +end + +# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#29 +RuboCop::Cop::Lint::SelfAssignment::ASSIGNMENT_TYPE_TO_RHS_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#27 +RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for `send`, `public_send`, and `__send__` methods +# when using mix-in. +# +# `include` and `prepend` methods were private methods until Ruby 2.0, +# they were mixed-in via `send` method. This cop uses Ruby 2.1 or +# higher style that can be called by public methods. +# And `extend` method that was originally a public method is also targeted +# for style unification. +# +# @example +# # bad +# Foo.send(:include, Bar) +# Foo.send(:prepend, Bar) +# Foo.send(:extend, Bar) +# +# # bad +# Foo.public_send(:include, Bar) +# Foo.public_send(:prepend, Bar) +# Foo.public_send(:extend, Bar) +# +# # bad +# Foo.__send__(:include, Bar) +# Foo.__send__(:prepend, Bar) +# Foo.__send__(:extend, Bar) +# +# # good +# Foo.include Bar +# Foo.prepend Bar +# Foo.extend Bar +# +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#36 +class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#53 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#46 + def send_with_mixin_argument?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#67 + def bad_location(node); end + + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#73 + def message(method, module_name, bad_method); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#77 + def mixin_method?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#41 +RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#40 +RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#43 +RuboCop::Cop::Lint::SendWithMixinArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#42 +RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for shadowed arguments. +# +# This cop has `IgnoreImplicitReferences` configuration option. +# It means argument shadowing is used in order to pass parameters +# to zero arity `super` when `IgnoreImplicitReferences` is `true`. +# +# @example +# +# # bad +# do_something do |foo| +# foo = 42 +# puts foo +# end +# +# def do_something(foo) +# foo = 42 +# puts foo +# end +# +# # good +# do_something do |foo| +# foo = foo + 42 +# puts foo +# end +# +# def do_something(foo) +# foo = foo + 42 +# puts foo +# end +# +# def do_something(foo) +# puts foo +# end +# @example IgnoreImplicitReferences: false (default) +# +# # bad +# def do_something(foo) +# foo = 42 +# super +# end +# +# def do_something(foo) +# foo = super +# bar +# end +# @example IgnoreImplicitReferences: true +# +# # good +# def do_something(foo) +# foo = 42 +# super +# end +# +# def do_something(foo) +# foo = super +# bar +# end +# +# source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#66 +class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#76 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#70 + def uses_var?(param0, param1); end + + private + + # Get argument references without assignments' references + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#160 + def argument_references(argument); end + + # Find the first argument assignment, which doesn't reference the + # argument at the rhs. If the assignment occurs inside a branch or + # block, it is impossible to tell whether it's executed, so precise + # shadowing location is not known. + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#120 + def assignment_without_argument_usage(argument); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#82 + def check_argument(argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#170 + def ignore_implicit_references?; end + + # Check whether the given node is nested into block or conditional. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#151 + def node_within_block_or_conditional?(node, stop_search_node); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#143 + def reference_pos(node); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#95 + def shadowing_assignment(argument); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#72 + def joining_forces; end + end +end + +# source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#67 +RuboCop::Cop::Lint::ShadowedArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for a rescued exception that get shadowed by a +# less specific exception being rescued before a more specific +# exception is rescued. +# +# An exception is considered shadowed if it is rescued after its +# ancestor is, or if it and its ancestor are both rescued in the +# same `rescue` statement. In both cases, the more specific rescue is +# unnecessary because it is covered by rescuing the less specific +# exception. (ie. `rescue Exception, StandardError` has the same behavior +# whether `StandardError` is included or not, because all ``StandardError``s +# are rescued by `rescue Exception`). +# +# @example +# +# # bad +# +# begin +# something +# rescue Exception +# handle_exception +# rescue StandardError +# handle_standard_error +# end +# +# # bad +# begin +# something +# rescue Exception, StandardError +# handle_error +# end +# +# # good +# +# begin +# something +# rescue StandardError +# handle_standard_error +# rescue Exception +# handle_exception +# end +# +# # good, however depending on runtime environment. +# # +# # This is a special case for system call errors. +# # System dependent error code depends on runtime environment. +# # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are +# # the same error code or different error code depends on environment. +# # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with +# # the same error code. +# begin +# something +# rescue Errno::EAGAIN, Errno::EWOULDBLOCK +# handle_standard_error +# end +# +# source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#61 +class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#67 + def on_rescue(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#101 + def compare_exceptions(exception, other_exception); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#94 + def contains_multiple_levels_of_exceptions?(group); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#119 + def evaluate_exceptions(group); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#152 + def find_shadowing_rescue(rescues); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#84 + def offense_range(rescues); end + + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#90 + def rescued_groups_for(rescues); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#137 + def sorted?(rescued_groups); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#115 + def system_call_err?(error); end +end + +# source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#65 +RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of local variable names from an outer scope +# in block arguments or block-local variables. This mirrors the warning +# given by `ruby -cw` prior to Ruby 2.6: +# "shadowing outer local variable - foo". +# +# NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed +# because `Ractor` should not access outer variables. +# eg. following style is encouraged: +# +# [source,ruby] +# ---- +# worker_id, pipe = env +# Ractor.new(worker_id, pipe) do |worker_id, pipe| +# end +# ---- +# +# @example +# +# # bad +# +# def some_method +# foo = 1 +# +# 2.times do |foo| # shadowing outer `foo` +# do_something(foo) +# end +# end +# @example +# +# # good +# +# def some_method +# foo = 1 +# +# 2.times do |bar| +# do_something(bar) +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#45 +class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#57 + def before_declaring_variable(variable, variable_table); end + + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#93 + def find_conditional_node_from_ascendant(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#100 + def node_or_its_ascendant_conditional?(node); end + + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#49 + def ractor_block?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#69 + def same_conditions_node_different_branch?(variable, outer_local_variable); end + + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#83 + def variable_node(variable); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#53 + def joining_forces; end + end +end + +# source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#46 +RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), String) + +# Checks unexpected overrides of the `Struct` built-in methods +# via `Struct.new`. +# +# @example +# # bad +# Bad = Struct.new(:members, :clone, :count) +# b = Bad.new([], true, 1) +# b.members #=> [] (overriding `Struct#members`) +# b.clone #=> true (overriding `Object#clone`) +# b.count #=> 1 (overriding `Enumerable#count`) +# +# # good +# Good = Struct.new(:id, :name) +# g = Good.new(1, "foo") +# g.members #=> [:id, :name] +# g.clone #=> # +# g.count #=> 2 +# +# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#24 +class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#38 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#33 + def struct_new(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#25 +RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#27 +RuboCop::Cop::Lint::StructNewOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#30 +RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#29 +RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array) + +# Checks for `rescue` blocks with no body. +# +# @example +# +# # bad +# def some_method +# do_something +# rescue +# end +# +# # bad +# begin +# do_something +# rescue +# end +# +# # good +# def some_method +# do_something +# rescue +# handle_exception +# end +# +# # good +# begin +# do_something +# rescue +# handle_exception +# end +# @example AllowComments: true (default) +# +# # good +# def some_method +# do_something +# rescue +# # do nothing +# end +# +# # good +# begin +# do_something +# rescue +# # do nothing +# end +# @example AllowComments: false +# +# # bad +# def some_method +# do_something +# rescue +# # do nothing +# end +# +# # bad +# begin +# do_something +# rescue +# # do nothing +# end +# @example AllowNil: true (default) +# +# # good +# def some_method +# do_something +# rescue +# nil +# end +# +# # good +# begin +# do_something +# rescue +# # do nothing +# end +# +# # good +# do_something rescue nil +# @example AllowNil: false +# +# # bad +# def some_method +# do_something +# rescue +# nil +# end +# +# # bad +# begin +# do_something +# rescue +# nil +# end +# +# # bad +# do_something rescue nil +# +# source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#105 +class RuboCop::Cop::Lint::SuppressedException < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#108 + def on_resbody(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#118 + def comment_between_rescue_and_end?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#126 + def nil_body?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#106 +RuboCop::Cop::Lint::SuppressedException::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of literal strings converted to +# a symbol where a literal symbol could be used instead. +# +# There are two possible styles for this cop. +# `strict` (default) will register an offense for any incorrect usage. +# `consistent` additionally requires hashes to use the same style for +# every symbol key (ie. if any symbol key needs to be quoted it requires +# all keys to be quoted). +# +# @example +# # bad +# 'string'.to_sym +# :symbol.to_sym +# 'underscored_string'.to_sym +# :'underscored_symbol' +# 'hyphenated-string'.to_sym +# "string_#{interpolation}".to_sym +# +# # good +# :string +# :symbol +# :underscored_string +# :underscored_symbol +# :'hyphenated-string' +# :"string_#{interpolation}" +# @example EnforcedStyle: strict (default) +# +# # bad +# { +# 'a': 1, +# "b": 2, +# 'c-d': 3 +# } +# +# # good (don't quote keys that don't require quoting) +# { +# a: 1, +# b: 2, +# 'c-d': 3 +# } +# @example EnforcedStyle: consistent +# +# # bad +# { +# a: 1, +# 'b-c': 2 +# } +# +# # good (quote all keys if any need quoting) +# { +# 'a': 1, +# 'b-c': 2 +# } +# +# # good (no quoting required) +# { +# a: 1, +# b: 2 +# } +# +# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#68 +class RuboCop::Cop::Lint::SymbolConversion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SymbolHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#105 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#78 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#88 + def on_sym(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#147 + def correct_hash_key(node); end + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#166 + def correct_inconsistent_hash_keys(keys); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#139 + def in_alias?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#143 + def in_percent_literal_array?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#126 + def properly_quoted?(source, value); end + + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#122 + def register_offense(node, correction:, message: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#135 + def requires_quotes?(sym_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#73 +RuboCop::Cop::Lint::SymbolConversion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#74 +RuboCop::Cop::Lint::SymbolConversion::MSG_CONSISTENCY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#76 +RuboCop::Cop::Lint::SymbolConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Repacks Parser's diagnostics/errors +# into RuboCop's offenses. +# +# source://rubocop//lib/rubocop/cop/lint/syntax.rb#8 +class RuboCop::Cop::Lint::Syntax < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/syntax.rb#9 + def on_other_file; end + + private + + # source://rubocop//lib/rubocop/cop/lint/syntax.rb#19 + def add_offense_from_diagnostic(diagnostic, ruby_version); end + + # source://rubocop//lib/rubocop/cop/lint/syntax.rb#26 + def add_offense_from_error(error); end + + # source://rubocop//lib/rubocop/cop/lint/syntax.rb#31 + def beautify_message(message); end + + # source://rubocop//lib/rubocop/cop/lint/syntax.rb#37 + def find_severity(_range, _severity); end +end + +# Ensures that `to_enum`/`enum_for`, called for the current method, +# has correct arguments. +# +# @example +# # bad +# def foo(x, y = 1) +# return to_enum(__callee__, x) # `y` is missing +# end +# +# # good +# def foo(x, y = 1) +# # Alternatives to `__callee__` are `__method__` and `:foo`. +# return to_enum(__callee__, x, y) +# end +# +# # good +# def foo(x, y = 1) +# # It is also allowed if it is wrapped in some method like Sorbet. +# return to_enum(T.must(__callee__), x, y) +# end +# +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#27 +class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#33 + def enum_conversion_call?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#38 + def method_name?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#47 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#43 + def passing_keyword_arg?(param0 = T.unsafe(nil), param1); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#78 + def argument_match?(send_arg, def_arg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#63 + def arguments_match?(arguments, def_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#28 +RuboCop::Cop::Lint::ToEnumArguments::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#30 +RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks to make sure `#to_json` includes an optional argument. +# When overriding `#to_json`, callers may invoke JSON +# generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows +# for an optional argument, your method should too. +# +# @example +# class Point +# attr_reader :x, :y +# +# # bad, incorrect arity +# def to_json +# JSON.generate([x, y]) +# end +# +# # good, preserving args +# def to_json(*args) +# JSON.generate([x, y], *args) +# end +# +# # good, discarding args +# def to_json(*_args) +# JSON.generate([x, y]) +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/to_json.rb#31 +class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/to_json.rb#36 + def on_def(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/to_json.rb#34 +RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String) + +# Checks for top level return with arguments. If there is a +# top-level return statement with an argument, then the argument is +# always ignored. This is detected automatically since Ruby 2.7. +# +# @example +# # bad +# return 1 +# +# # good +# return +# +# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#16 +class RuboCop::Cop::Lint::TopLevelReturnWithArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#21 + def on_return(return_node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#35 + def remove_arguments(corrector, return_node); end + + # This cop works by validating the ancestors of the return node. A + # top-level return node's ancestors should not be of block, def, or + # defs type. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#42 + def top_level_return?(return_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#31 + def top_level_return_with_any_argument?(return_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#19 +RuboCop::Cop::Lint::TopLevelReturnWithArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing commas in attribute declarations, such as +# `#attr_reader`. Leaving a trailing comma will nullify the next method +# definition by overriding it with a getter method. +# +# @example +# +# # bad +# class Foo +# attr_reader :foo, +# +# def bar +# puts "Unreachable." +# end +# end +# +# # good +# class Foo +# attr_reader :foo +# +# def bar +# puts "No problem!" +# end +# end +# +# source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#30 +class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#36 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#46 + def trailing_comma_range(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#34 +RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::MSG = T.let(T.unsafe(nil), String) + +# Checks for "triple quotes" (strings delimited by any odd number +# of quotes greater than 1). +# +# Ruby allows multiple strings to be implicitly concatenated by just +# being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes +# gives the impression that there is something special about triple quotes, but +# in fact it is just extra unnecessary quotes and produces the same string. Each +# pair of quotes produces an additional concatenated empty string, so the result +# is still only the "actual" string within the delimiters. +# +# NOTE: Although this cop is called triple quotes, the same behavior is present +# for strings delimited by 5, 7, etc. quotation marks. +# +# @example +# # bad +# """ +# A string +# """ +# +# # bad +# ''' +# A string +# ''' +# +# # good +# " +# A string +# " +# +# # good +# < b } +# values.sort { |*x| x[0] <=> x[1] } +# +# source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#41 +class RuboCop::Cop::Lint::UnexpectedBlockArity < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#44 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#44 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#63 + def acceptable?(node); end + + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#75 + def arg_count(node); end + + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#71 + def expected_arity(method); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#67 + def included_method?(name); end + + # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#59 + def methods; end +end + +# source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#42 +RuboCop::Cop::Lint::UnexpectedBlockArity::MSG = T.let(T.unsafe(nil), String) + +# Checks for using Fixnum or Bignum constant. +# +# @example +# +# # bad +# +# 1.is_a?(Fixnum) +# 1.is_a?(Bignum) +# @example +# +# # good +# +# 1.is_a?(Integer) +# +# source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#20 +class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#26 + def fixnum_or_bignum_const(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#30 + def on_const(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#23 +RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String) + +# Looks for `reduce` or `inject` blocks where the value returned (implicitly or +# explicitly) does not include the accumulator. A block is considered valid as +# long as at least one return value includes the accumulator. +# +# If the accumulator is not included in the return value, then the entire +# block will just return a transformation of the last element value, and +# could be rewritten as such without a loop. +# +# Also catches instances where an index of the accumulator is returned, as +# this may change the type of object being retained. +# +# NOTE: For the purpose of reducing false positives, this cop only flags +# returns in `reduce` blocks where the element is the only variable in +# the expression (since we will not be able to tell what other variables +# relate to via static analysis). +# +# @example +# +# # bad +# (1..4).reduce(0) do |acc, el| +# el * 2 +# end +# +# # bad, may raise a NoMethodError after the first iteration +# %w(a b c).reduce({}) do |acc, letter| +# acc[letter] = true +# end +# +# # good +# (1..4).reduce(0) do |acc, el| +# acc + el * 2 +# end +# +# # good, element is returned but modified using the accumulator +# values.reduce do |acc, el| +# el << acc +# el +# end +# +# # good, returns the accumulator instead of the index +# %w(a b c).reduce({}) do |acc, letter| +# acc[letter] = true +# acc +# end +# +# # good, at least one branch returns the accumulator +# values.reduce(nil) do |result, value| +# break result if something? +# value +# end +# +# # good, recursive +# keys.reduce(self) { |result, key| result[key] } +# +# # ignored as the return value cannot be determined +# enum.reduce do |acc, el| +# x = foo(acc, el) +# bar(x) +# end +# +# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#65 +class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#78 + def accumulator_index?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#83 + def element_modified?(param0, param1); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#104 + def expression_values(param0); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#93 + def lvar_used?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#115 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#115 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#70 + def reduce_with_block?(param0 = T.unsafe(nil)); end + + private + + # Determine if a return value is acceptable for the purposes of this cop + # If it is an expression containing the accumulator, it is acceptable + # Otherwise, it is only unacceptable if it contains the iterated element, since we + # otherwise do not have enough information to prevent false positives. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#190 + def acceptable_return?(return_val, element_name); end + + # Exclude `begin` nodes inside a `dstr` from being collected by `return_values` + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#198 + def allowed_type?(parent_node); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#158 + def block_arg_name(node, index); end + + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#141 + def check_return_values(block_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#175 + def potential_offense?(return_values, block_body, element_name, accumulator_name); end + + # Return values in a block are either the value given to next, + # the last line of a multiline block, or the only line of the block + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#127 + def return_values(block_body_node); end + + # Look for an index of the accumulator being returned, except where the index + # is the element. + # This is always an offense, in order to try to catch potential exceptions + # due to type mismatches + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#166 + def returned_accumulator_index(return_values, accumulator_name, element_name); end + + # If the accumulator is used in any return value, the node is acceptable since + # the accumulator has a chance to change each iteration + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#182 + def returns_accumulator_anywhere?(return_values, accumulator_name); end +end + +# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#66 +RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#67 +RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG_INDEX = T.let(T.unsafe(nil), String) + +# Checks for unreachable code. +# The check are based on the presence of flow of control +# statement in non-final position in `begin` (implicit) blocks. +# +# @example +# +# # bad +# +# def some_method +# return +# do_something +# end +# +# # bad +# +# def some_method +# if cond +# return +# else +# return +# end +# do_something +# end +# @example +# +# # good +# +# def some_method +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#37 +class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#55 + def flow_command?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#40 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#40 + def on_kwbegin(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#87 + def check_case(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#81 + def check_if(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#65 + def flow_expression?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#38 +RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String) + +# Checks for loops that will have at most one iteration. +# +# A loop that can never reach the second iteration is a possible error in the code. +# In rare cases where only one iteration (or at most one iteration) is intended behavior, +# the code should be refactored to use `if` conditionals. +# +# NOTE: Block methods that are used with ``Enumerable``s are considered to be loops. +# +# `AllowedPatterns` can be used to match against the block receiver in order to allow +# code that would otherwise be registered as an offense (eg. `times` used not in an +# `Enumerable` context). +# +# @example +# # bad +# while node +# do_something(node) +# node = node.parent +# break +# end +# +# # good +# while node +# do_something(node) +# node = node.parent +# end +# +# # bad +# def verify_list(head) +# item = head +# begin +# if verify(item) +# return true +# else +# return false +# end +# end while(item) +# end +# +# # good +# def verify_list(head) +# item = head +# begin +# if verify(item) +# item = item.next +# else +# return false +# end +# end while(item) +# +# true +# end +# +# # bad +# def find_something(items) +# items.each do |item| +# if something?(item) +# return item +# else +# raise NotFoundError +# end +# end +# end +# +# # good +# def find_something(items) +# items.each do |item| +# if something?(item) +# return item +# end +# end +# raise NotFoundError +# end +# +# # bad +# 2.times { raise ArgumentError } +# @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default) +# +# # good +# exactly(2).times { raise StandardError } +# +# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#86 +class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#143 + def break_command?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#100 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#104 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#153 + def break_statement?(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#119 + def check(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#176 + def check_case(node); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#170 + def check_if(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#194 + def conditional_continue_keyword?(break_statement); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#110 + def loop_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#184 + def preceded_by_continue_statement?(break_statement); end + + # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#130 + def statements(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#90 +RuboCop::Cop::Lint::UnreachableLoop::CONTINUE_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#89 +RuboCop::Cop::Lint::UnreachableLoop::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for cops handling unused arguments. +# +# source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#7 +module RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#10 + def after_leaving_scope(scope, _variable_table); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#16 + def check_argument(variable); end +end + +# Checks for unused block arguments. +# +# @example +# # bad +# do_something do |used, unused| +# puts used +# end +# +# do_something do |bar| +# puts :foo +# end +# +# define_method(:foo) do |bar| +# puts :baz +# end +# +# # good +# do_something do |used, _unused| +# puts used +# end +# +# do_something do +# puts :foo +# end +# +# define_method(:foo) do |_bar| +# puts :baz +# end +# @example IgnoreEmptyBlocks: true (default) +# # good +# do_something { |unused| } +# @example IgnoreEmptyBlocks: false +# # bad +# do_something { |unused| } +# @example AllowUnusedKeywordArguments: false (default) +# # bad +# do_something do |unused: 42| +# foo +# end +# @example AllowUnusedKeywordArguments: true +# # good +# do_something do |unused: 42| +# foo +# end +# +# source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#55 +class RuboCop::Cop::Lint::UnusedBlockArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#162 + def allow_unused_keyword_arguments?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#81 + def allowed_block?(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#85 + def allowed_keyword_argument?(variable); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#99 + def augment_message(message, variable); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#65 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#69 + def check_argument(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#149 + def define_method_call?(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#156 + def empty_block?(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#166 + def ignore_empty_blocks?; end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#89 + def message(variable); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#132 + def message_for_lambda(variable, all_arguments); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#120 + def message_for_normal_block(variable, all_arguments); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#144 + def message_for_underscore_prefix(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#77 + def used_block_local?(variable); end + + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#112 + def variable_type(variable); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#59 + def joining_forces; end + end +end + +# Checks for unused method arguments. +# +# @example +# # bad +# def some_method(used, unused, _unused_but_allowed) +# puts used +# end +# +# # good +# def some_method(used, _unused, _unused_but_allowed) +# puts used +# end +# @example AllowUnusedKeywordArguments: false (default) +# # bad +# def do_something(used, unused: 42) +# used +# end +# @example AllowUnusedKeywordArguments: true +# # good +# def do_something(used, unused: 42) +# used +# end +# @example IgnoreEmptyMethods: true (default) +# # good +# def do_something(unused) +# end +# @example IgnoreEmptyMethods: false +# # bad +# def do_something(unused) +# end +# @example IgnoreNotImplementedMethods: true (default) +# # good +# def do_something(unused) +# raise NotImplementedError +# end +# +# def do_something_else(unused) +# fail "TODO" +# end +# @example IgnoreNotImplementedMethods: false +# # bad +# def do_something(unused) +# raise NotImplementedError +# end +# +# def do_something_else(unused) +# fail "TODO" +# end +# +# source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#61 +class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#66 + def not_implemented?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#81 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#85 + def check_argument(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#93 + def ignored_method?(body); end + + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#98 + def message(variable); end + + class << self + # source://rubocop-performance/1.19.1/lib/rubocop-performance.rb#15 + def autocorrect_incompatible_with; end + + # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#75 + def joining_forces; end + end +end + +# Identifies places where `URI.escape` can be replaced by +# `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component` +# depending on your specific use case. +# Also this cop identifies places where `URI.unescape` can be replaced by +# `CGI.unescape`, `URI.decode_www_form`, +# or `URI.decode_www_form_component` depending on your specific use case. +# +# @example +# # bad +# URI.escape('http://example.com') +# URI.encode('http://example.com') +# +# # good +# CGI.escape('http://example.com') +# URI.encode_www_form([['example', 'param'], ['lang', 'en']]) +# URI.encode_www_form(page: 10, locale: 'en') +# URI.encode_www_form_component('http://example.com') +# +# # bad +# URI.unescape(enc_uri) +# URI.decode(enc_uri) +# +# # good +# CGI.unescape(enc_uri) +# URI.decode_www_form(enc_uri) +# URI.decode_www_form_component(enc_uri) +# +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#32 +class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#57 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#51 + def uri_escape_unescape?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#33 +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#38 +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_UNESCAPE = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#47 +RuboCop::Cop::Lint::UriEscapeUnescape::METHOD_NAMES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#44 +RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#48 +RuboCop::Cop::Lint::UriEscapeUnescape::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `URI.regexp` is obsolete and should +# not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`. +# +# @example +# # bad +# URI.regexp('http://example.com') +# +# # good +# URI::DEFAULT_PARSER.make_regexp('http://example.com') +# +# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#16 +class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#23 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#19 +RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#21 +RuboCop::Cop::Lint::UriRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#20 +RuboCop::Cop::Lint::UriRegexp::URI_CONSTANTS = T.let(T.unsafe(nil), Array) + +# Checks for redundant access modifiers, including those with no +# code, those which are repeated, and leading `public` modifiers in a +# class or module body. Conditionally-defined methods are considered as +# always being defined, and thus access modifiers guarding such methods +# are not redundant. +# +# This cop has `ContextCreatingMethods` option. The default setting value +# is an empty array that means no method is specified. +# This setting is an array of methods which, when called, are known to +# create its own context in the module's current access context. +# +# It also has `MethodCreatingMethods` option. The default setting value +# is an empty array that means no method is specified. +# This setting is an array of methods which, when called, are known to +# create other methods in the module's current access context. +# +# @example +# # bad +# class Foo +# public # this is redundant (default access is public) +# +# def method +# end +# end +# +# # bad +# class Foo +# # The following is redundant (methods defined on the class' +# # singleton class are not affected by the private modifier) +# private +# +# def self.method3 +# end +# end +# +# # bad +# class Foo +# protected +# +# define_method(:method2) do +# end +# +# protected # this is redundant (repeated from previous modifier) +# +# [1,2,3].each do |i| +# define_method("foo#{i}") do +# end +# end +# end +# +# # bad +# class Foo +# private # this is redundant (no following methods are defined) +# end +# +# # good +# class Foo +# private # this is not redundant (a method is defined) +# +# def method2 +# end +# end +# +# # good +# class Foo +# # The following is not redundant (conditionally defined methods are +# # considered as always defining a method) +# private +# +# if condition? +# def method +# end +# end +# end +# +# # good +# class Foo +# protected # this is not redundant (a method is defined) +# +# define_method(:method2) do +# end +# end +# @example ContextCreatingMethods: concerning +# # Lint/UselessAccessModifier: +# # ContextCreatingMethods: +# # - concerning +# +# # good +# require 'active_support/concern' +# class Foo +# concerning :Bar do +# def some_public_method +# end +# +# private +# +# def some_private_method +# end +# end +# +# # this is not redundant because `concerning` created its own context +# private +# +# def some_other_private_method +# end +# end +# @example MethodCreatingMethods: delegate +# # Lint/UselessAccessModifier: +# # MethodCreatingMethods: +# # - delegate +# +# # good +# require 'active_support/core_ext/module/delegation' +# class Foo +# # this is not redundant because `delegate` creates methods +# private +# +# delegate :method_a, to: :method_b +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#127 +class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#166 + def class_or_instance_eval?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#161 + def dynamic_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#139 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#139 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133 + def on_sclass(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#156 + def static_method_definition?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#182 + def access_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#280 + def any_context_creating_methods?(child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#257 + def any_method_definition?(child); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#149 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#196 + def check_child_nodes(node, unused, cur_vis); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#226 + def check_new_visibility(node, unused, new_vis, cur_vis); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#170 + def check_node(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#186 + def check_scope(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#215 + def check_send_node(node, cur_vis, unused); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#274 + def eval_call?(child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#247 + def included_block?(block_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#251 + def method_definition?(child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#270 + def start_of_new_scope?(child); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#131 +RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for every useless assignment to local variable in every +# scope. +# The basic idea for this cop was from the warning of `ruby -cw`: +# +# [source,console] +# ---- +# assigned but unused variable - foo +# ---- +# +# Currently this cop has advanced logic that detects unreferenced +# reassignments and properly handles varied cases such as branch, loop, +# rescue, ensure, etc. +# +# NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables +# can lead to a syntax error, so this case is not autocorrected. +# +# @example +# +# # bad +# +# def some_method +# some_var = 1 +# do_something +# end +# @example +# +# # good +# +# def some_method +# some_var = 1 +# do_something(some_var) +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#45 +class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#56 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#162 + def autocorrect(corrector, assignment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#103 + def chained_assignment?(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#61 + def check_for_unused_assignments(variable); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#146 + def collect_variable_like_names(scope); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#79 + def message_for_useless_assignment(assignment); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#107 + def message_specification(assignment, variable); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#117 + def multiple_assignment_message(variable_name); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#85 + def offense_range(assignment); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#122 + def operator_assignment_message(scope, assignment); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#179 + def remove_exception_assignment_part(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#203 + def remove_local_variable_assignment_part(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#192 + def remove_trailing_character_from_operator(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#188 + def rename_variable_with_underscore(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#196 + def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name); end + + # TODO: More precise handling (rescue, ensure, nested begin, etc.) + # + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#136 + def return_value_node_of_scope(scope); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#93 + def sequential_assignment?(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#129 + def similar_name_message(variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#155 + def variable_like_method_invocation?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#52 + def joining_forces; end + end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#50 +RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for useless `else` in `begin..end` without `rescue`. +# +# NOTE: This syntax is no longer valid on Ruby 2.6 or higher. +# +# @example +# +# # bad +# +# begin +# do_something +# else +# do_something_else # This will never be run. +# end +# @example +# +# # good +# +# begin +# do_something +# rescue +# handle_errors +# else +# do_something_else +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#31 +class RuboCop::Cop::Lint::UselessElseWithoutRescue < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#34 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#32 +RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String) + +# Checks for useless method definitions, specifically: empty constructors +# and methods just delegating to `super`. +# +# @example +# # bad +# def initialize +# super +# end +# +# def method +# super +# end +# +# # good - with default arguments +# def initialize(x = Object.new) +# super +# end +# +# # good +# def initialize +# super +# initialize_internals +# end +# +# def method(*args) +# super(:extra_arg, *args) +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#38 +class RuboCop::Cop::Lint::UselessMethodDefinition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#43 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#43 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#65 + def delegating?(node, def_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#57 + def method_definition_with_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#61 + def use_rest_or_optional_args?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#41 +RuboCop::Cop::Lint::UselessMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for useless `rescue`s, which only reraise rescued exceptions. +# +# @example +# # bad +# def foo +# do_something +# rescue +# raise +# end +# +# # bad +# def foo +# do_something +# rescue => e +# raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO' +# end +# +# # good +# def foo +# do_something +# rescue +# do_cleanup +# raise +# end +# +# # bad (latest rescue) +# def foo +# do_something +# rescue ArgumentError +# # noop +# rescue +# raise +# end +# +# # good (not the latest rescue) +# def foo +# do_something +# rescue ArgumentError +# raise +# rescue +# # noop +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#49 +class RuboCop::Cop::Lint::UselessRescue < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#52 + def on_rescue(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#83 + def exception_objects(resbody_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#60 + def only_reraising?(resbody_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#75 + def use_exception_variable_in_ensure?(resbody_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#50 +RuboCop::Cop::Lint::UselessRescue::MSG = T.let(T.unsafe(nil), String) + +# Looks for `ruby2_keywords` calls for methods that do not need it. +# +# `ruby2_keywords` should only be called on methods that accept an argument splat +# (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or +# a keyword splat (`**kwargs`). +# +# @example +# # good (splat argument without keyword arguments) +# ruby2_keywords def foo(*args); end +# +# # bad (no arguments) +# ruby2_keywords def foo; end +# +# # good +# def foo; end +# +# # bad (positional argument) +# ruby2_keywords def foo(arg); end +# +# # good +# def foo(arg); end +# +# # bad (double splatted argument) +# ruby2_keywords def foo(**args); end +# +# # good +# def foo(**args); end +# +# # bad (keyword arguments) +# ruby2_keywords def foo(i:, j:); end +# +# # good +# def foo(i:, j:); end +# +# # bad (splat argument with keyword arguments) +# ruby2_keywords def foo(*args, i:, j:); end +# +# # good +# def foo(*args, i:, j:); end +# +# # bad (splat argument with double splat) +# ruby2_keywords def foo(*args, **kwargs); end +# +# # good +# def foo(*args, **kwargs); end +# +# # bad (ruby2_keywords given a symbol) +# def foo; end +# ruby2_keywords :foo +# +# # good +# def foo; end +# +# # bad (ruby2_keywords with dynamic method) +# define_method(:foo) { |arg| } +# ruby2_keywords :foo +# +# # good +# define_method(:foo) { |arg| } +# +# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#66 +class RuboCop::Cop::Lint::UselessRuby2Keywords < ::RuboCop::Cop::Base + # Looks for statically or dynamically defined methods with a given name + # + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#72 + def method_definition(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#79 + def on_send(node); end + + private + + # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments + # + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#118 + def allowed_arguments(arguments); end + + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#109 + def find_method_definition(node, method_name); end + + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#91 + def inspect_def(node, def_node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#97 + def inspect_sym(node, sym_node); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#67 +RuboCop::Cop::Lint::UselessRuby2Keywords::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#68 +RuboCop::Cop::Lint::UselessRuby2Keywords::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for setter call to local variable as the final +# expression of a function definition. +# +# @example +# +# # bad +# +# def something +# x = Something.new +# x.attr = 5 +# end +# @example +# +# # good +# +# def something +# x = Something.new +# x.attr = 5 +# x +# end +# +# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#35 +class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#41 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#41 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#63 + def setter_call_to_local_variable?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#67 + def last_expression(body); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#39 +RuboCop::Cop::Lint::UselessSetterCall::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#38 +RuboCop::Cop::Lint::UselessSetterCall::MSG = T.let(T.unsafe(nil), String) + +# This class tracks variable assignments in a method body +# and if a variable contains object passed as argument at the end of +# the method. +# +# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#76 +class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker + # @return [MethodVariableTracker] a new instance of MethodVariableTracker + # + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#77 + def initialize(body_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#163 + def constructor?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#82 + def contain_local_object?(variable_name); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#152 + def process_assignment(asgn_node, rhs_node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#100 + def process_assignment_node(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#142 + def process_binary_operator_assignment(op_asgn_node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#133 + def process_logical_operator_assignment(asgn_node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#114 + def process_multiple_assignment(masgn_node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#92 + def scan(node, &block); end +end + +# Checks for uses of `Integer#times` that will never yield +# (when the integer <= 0) or that will only ever yield once +# (`1.times`). +# +# @example +# # bad +# -5.times { do_something } +# 0.times { do_something } +# 1.times { do_something } +# 1.times { |i| do_something(i) } +# +# # good +# do_something +# do_something(1) +# +# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#24 +class RuboCop::Cop::Lint::UselessTimes < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#37 + def block_arg(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#42 + def block_reassigns_arg?(param0, param1); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#46 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#32 + def times_call?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#62 + def autocorrect(corrector, count, node, proc_name); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#84 + def autocorrect_block(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#80 + def autocorrect_block_pass(corrector, node, proc_name); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#94 + def fix_indentation(source, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#72 + def never_process?(count, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#106 + def own_line?(node); end + + # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#76 + def remove_node(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#28 +RuboCop::Cop::Lint::UselessTimes::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#29 +RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for operators, variables, literals, lambda, proc and nonmutating +# methods used in void context. +# +# `each` blocks are allowed to prevent false positives. +# For example, the expression inside the `each` block below. +# It's not void, especially when the receiver is an `Enumerator`: +# +# [source,ruby] +# ---- +# enumerator = [1, 2, 3].filter +# enumerator.each { |item| item >= 2 } #=> [2, 3] +# ---- +# +# @example CheckForMethodsWithNoSideEffects: false (default) +# # bad +# def some_method +# some_num * 10 +# do_something +# end +# +# def some_method(some_var) +# some_var +# do_something +# end +# @example CheckForMethodsWithNoSideEffects: true +# # bad +# def some_method(some_array) +# some_array.sort +# do_something(some_array) +# end +# +# # good +# def some_method +# do_something +# some_num * 10 +# end +# +# def some_method(some_var) +# do_something +# some_var +# end +# +# def some_method(some_array) +# some_array.sort! +# do_something(some_array) +# end +# +# source://rubocop//lib/rubocop/cop/lint/void.rb#53 +class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/lint/void.rb#92 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#82 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#92 + def on_kwbegin(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#82 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/lint/void.rb#212 + def autocorrect_nonmutating_send(corrector, node, suggestion); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#208 + def autocorrect_void_expression(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#196 + def autocorrect_void_op(corrector, node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#99 + def check_begin(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#108 + def check_expression(expr); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#146 + def check_literal(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#170 + def check_nonmutating(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#154 + def check_self(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#128 + def check_var(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#162 + def check_void_expression(node); end + + # source://rubocop//lib/rubocop/cop/lint/void.rb#118 + def check_void_op(node, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/void.rb#221 + def entirely_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/lint/void.rb#188 + def in_void_context?(node); end +end + +# source://rubocop//lib/rubocop/cop/lint/void.rb#66 +RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#60 +RuboCop::Cop::Lint::Void::CONST_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#63 +RuboCop::Cop::Lint::Void::EXPRESSION_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#61 +RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#77 +RuboCop::Cop::Lint::Void::METHODS_REPLACEABLE_BY_EACH = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#79 +RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#70 +RuboCop::Cop::Lint::Void::NONMUTATING_METHODS_WITH_BANG_VERSION = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#64 +RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#68 +RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#58 +RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#62 +RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#67 +RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#59 +RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/lint/void.rb#69 +RuboCop::Cop::Lint::Void::VOID_CONTEXT_TYPES = T.let(T.unsafe(nil), Array) + +# Common functionality for obtaining source ranges from regexp matches +# +# source://rubocop//lib/rubocop/cop/mixin/match_range.rb#6 +module RuboCop::Cop::MatchRange + include ::RuboCop::Cop::RangeHelp + + private + + # Return a new `Range` covering the first matching group number for each + # match of `regex` inside `range` + # + # source://rubocop//lib/rubocop/cop/mixin/match_range.rb#13 + def each_match_range(range, regex); end + + # For a `match` inside `range`, return a new `Range` covering the match + # + # source://rubocop//lib/rubocop/cop/mixin/match_range.rb#18 + def match_range(range, match); end +end + +# Message Annotator class annotates a basic offense message +# based on params passed into initializer. +# +# #=> 'Cop/CopName: message (http://example.org/styleguide)' +# +# @example +# RuboCop::Cop::MessageAnnotator.new( +# config, cop_name, cop_config, @options +# ).annotate('message') +# @see #initialize +# +# source://rubocop//lib/rubocop/cop/message_annotator.rb#15 +class RuboCop::Cop::MessageAnnotator + # @option cop_config + # @option cop_config + # @option cop_config + # @option options + # @option options + # @option options + # @option options + # @param config [RuboCop::Config] Check configs for all cops + # @note Message Annotator specifically checks the + # following config options for_all_cops + # :StyleGuideBaseURL [String] URL for styleguide + # :DisplayStyleGuide [Boolean] Include styleguide and reference URLs + # :ExtraDetails [Boolean] Include cop details + # :DisplayCopNames [Boolean] Include cop name + # @param cop_name [String] for specific cop name + # @param cop_config [Hash] configs for specific cop, from config#for_cop + # @param options [Hash, nil] optional + # @return [MessageAnnotator] a new instance of MessageAnnotator + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#47 + def initialize(config, cop_name, cop_config, options); end + + # Returns the annotated message, + # based on params passed into initializer + # + # @return [String] annotated message + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#58 + def annotate(message); end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#16 + def config; end + + # Returns the value of attribute cop_config. + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#16 + def cop_config; end + + # Returns the value of attribute cop_name. + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#16 + def cop_name; end + + # Returns the value of attribute options. + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#16 + def options; end + + # source://rubocop//lib/rubocop/cop/message_annotator.rb#68 + def urls; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#111 + def debug?; end + + # source://rubocop//lib/rubocop/cop/message_annotator.rb#124 + def details; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#115 + def display_cop_names?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#98 + def display_style_guide?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#107 + def extra_details?; end + + # source://rubocop//lib/rubocop/cop/message_annotator.rb#102 + def reference_urls; end + + # Returns the base style guide URL from AllCops or the specific department + # + # @return [String] style guide URL + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#91 + def style_guide_base_url; end + + # source://rubocop//lib/rubocop/cop/message_annotator.rb#74 + def style_guide_url; end + + class << self + # Returns the value of attribute style_guide_urls. + # + # source://rubocop//lib/rubocop/cop/message_annotator.rb#21 + def style_guide_urls; end + end +end + +# This module handles measurement and reporting of complexity in methods. +# +# @api private +# +# source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#8 +module RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::ExcludeLimit + + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#37 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#24 + def on_block(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#17 + def on_def(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#17 + def on_defs(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#24 + def on_numblock(node); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#42 + def check_complexity(node, method_name); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#61 + def complexity(body); end +end + +# Common code for cops that deal with preferred methods. +# +# source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#6 +module RuboCop::Cop::MethodPreference + private + + # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#25 + def default_cop_config; end + + # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#9 + def preferred_method(method); end + + # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#13 + def preferred_methods; end +end + +# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#5 +module RuboCop::Cop::Metrics; end + +# Checks that the ABC size of methods is not higher than the +# configured maximum. The ABC size is based on assignments, branches +# (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric +# and https://en.wikipedia.org/wiki/ABC_Software_Metric. +# +# Interpreting ABC size: +# +# * <= 17 satisfactory +# * 18..30 unsatisfactory +# * > 30 dangerous +# +# You can have repeated "attributes" calls count as a single "branch". +# For this purpose, attributes are any method with no argument; no attempt +# is meant to distinguish actual `attr_reader` from other methods. +# +# This cop also takes into account `AllowedMethods` (defaults to `[]`) +# And `AllowedPatterns` (defaults to `[]`) +# +# @example CountRepeatedAttributes: false (default is true) +# +# # `model` and `current_user`, referenced 3 times each, +# # are each counted as only 1 branch each if +# # `CountRepeatedAttributes` is set to 'false' +# +# def search +# @posts = model.active.visible_by(current_user) +# .search(params[:q]) +# @posts = model.some_process(@posts, current_user) +# @posts = model.another_process(@posts, current_user) +# +# render 'pages/search/page' +# end +# +# source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#39 +class RuboCop::Cop::Metrics::AbcSize < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + include ::RuboCop::Cop::MethodComplexity + + private + + # source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#47 + def complexity(node); end +end + +# source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#42 +RuboCop::Cop::Metrics::AbcSize::MSG = T.let(T.unsafe(nil), String) + +# Checks if the length of a block exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# The cop can be configured to ignore blocks passed to certain methods. +# +# You can set constructs you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct +# will be counted as one line regardless of its actual size. +# +# NOTE: This cop does not apply for `Struct` definitions. +# +# NOTE: The `ExcludedMethods` configuration is deprecated and only kept +# for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns` +# instead. By default, there are no methods to allowed. +# +# @example CountAsOne: ['array', 'heredoc', 'method_call'] +# +# something do +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# msg = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# +# foo( # +1 +# 1, +# 2 +# ) +# end # 6 points +# +# source://rubocop//lib/rubocop/cop/metrics/block_length.rb#44 +class RuboCop::Cop::Metrics::BlockLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#51 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#51 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#80 + def cop_label; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#62 + def method_receiver_excluded?(node); end +end + +# source://rubocop//lib/rubocop/cop/metrics/block_length.rb#49 +RuboCop::Cop::Metrics::BlockLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks for excessive nesting of conditional and looping +# constructs. +# +# You can configure if blocks are considered using the `CountBlocks` +# option. When set to `false` (the default) blocks are not counted +# towards the nesting level. Set to `true` to count blocks as well. +# +# The maximum level of nesting allowed is configurable. +# +# source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#14 +class RuboCop::Cop::Metrics::BlockNesting < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#19 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#28 + def check_nesting_level(node, max, current_level); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#44 + def consider_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#54 + def count_blocks?; end + + # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#50 + def message(max); end +end + +# source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#15 +RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array) + +# Checks if the length of a class exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# +# You can set constructs you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct +# will be counted as one line regardless of its actual size. +# +# NOTE: This cop also applies for `Struct` definitions. +# +# @example CountAsOne: ['array', 'heredoc', 'method_call'] +# +# class Foo +# ARRAY = [ # +1 +# 1, +# 2 +# ] +# +# HASH = { # +3 +# key: 'value' +# } +# +# MSG = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# +# foo( # +1 +# 1, +# 2 +# ) +# end # 6 points +# +# source://rubocop//lib/rubocop/cop/metrics/class_length.rb#39 +class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#52 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#42 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#46 + def on_sclass(node); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#70 + def message(length, max_length); end +end + +# Checks for literals with extremely many entries. This is indicative of +# configuration or data that may be better extracted somewhere else, like +# a database, fetched from an API, or read from a non-code file (CSV, +# JSON, YAML, etc.). +# +# @example +# # bad +# # Huge Array literal +# [1, 2, '...', 999_999_999] +# +# # bad +# # Huge Hash literal +# { 1 => 1, 2 => 2, '...' => '...', 999_999_999 => 999_999_999} +# +# # bad +# # Huge Set "literal" +# Set[1, 2, '...', 999_999_999] +# +# # good +# # Reasonably sized Array literal +# [1, 2, '...', 10] +# +# # good +# # Reading huge Array from external data source +# # File.readlines('numbers.txt', chomp: true).map!(&:to_i) +# +# # good +# # Reasonably sized Hash literal +# { 1 => 1, 2 => 2, '...' => '...', 10 => 10} +# +# # good +# # Reading huge Hash from external data source +# CSV.foreach('numbers.csv', headers: true).each_with_object({}) do |row, hash| +# hash[row["key"].to_i] = row["value"].to_i +# end +# +# # good +# # Reasonably sized Set "literal" +# Set[1, 2, '...', 10] +# +# # good +# # Reading huge Set from external data source +# SomeFramework.config_for(:something)[:numbers].to_set +# +# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#50 +class RuboCop::Cop::Metrics::CollectionLiteralLength < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#55 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#55 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#60 + def on_index(node); end + + # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#64 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#70 + def collection_threshold; end +end + +# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#51 +RuboCop::Cop::Metrics::CollectionLiteralLength::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#53 +RuboCop::Cop::Metrics::CollectionLiteralLength::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that the cyclomatic complexity of methods is not higher +# than the configured maximum. The cyclomatic complexity is the number of +# linearly independent paths through a method. The algorithm counts +# decision points and adds one. +# +# An if statement (or unless or ?:) increases the complexity by one. An +# else branch does not, since it doesn't add a decision point. The && +# operator (or keyword and) can be converted to a nested if statement, +# and ||/or is shorthand for a sequence of ifs, so they also add one. +# Loops can be said to have an exit condition, so they add one. +# Blocks that are calls to builtin iteration methods +# (e.g. `ary.map{...}) also add one, others are ignored. +# +# def each_child_node(*types) # count begins: 1 +# unless block_given? # unless: +1 +# return to_enum(__method__, *types) +# +# children.each do |child| # each{}: +1 +# next unless child.is_a?(Node) # unless: +1 +# +# yield child if types.empty? || # if: +1, ||: +1 +# types.include?(child.type) +# end +# +# self +# end # total: 6 +# +# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#32 +class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + include ::RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::Metrics::Utils::IteratingBlock + + private + + # source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#42 + def complexity_score_for(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#49 + def count_block?(block); end +end + +# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#37 +RuboCop::Cop::Metrics::CyclomaticComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#36 +RuboCop::Cop::Metrics::CyclomaticComplexity::MSG = T.let(T.unsafe(nil), String) + +# Checks if the length of a method exceeds some maximum value. +# Comment lines can optionally be allowed. +# The maximum allowed length is configurable. +# +# You can set constructs you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct +# will be counted as one line regardless of its actual size. +# +# NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is +# deprecated and only kept for backwards compatibility. +# Please use `AllowedMethods` and `AllowedPatterns` instead. +# By default, there are no methods to allowed. +# +# @example CountAsOne: ['array', 'heredoc', 'method_call'] +# +# def m +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# +# foo( # +1 +# 1, +# 2 +# ) +# end # 6 points +# +# source://rubocop//lib/rubocop/cop/metrics/method_length.rb#42 +class RuboCop::Cop::Metrics::MethodLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#56 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#49 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#49 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#56 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#65 + def cop_label; end +end + +# source://rubocop//lib/rubocop/cop/metrics/method_length.rb#47 +RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks if the length of a module exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# +# You can set constructs you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct +# will be counted as one line regardless of its actual size. +# +# @example CountAsOne: ['array', 'heredoc', 'method_call'] +# +# module M +# ARRAY = [ # +1 +# 1, +# 2 +# ] +# +# HASH = { # +3 +# key: 'value' +# } +# +# MSG = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# +# foo( # +1 +# 1, +# 2 +# ) +# end # 6 points +# +# source://rubocop//lib/rubocop/cop/metrics/module_length.rb#37 +class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#51 + def module_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#44 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#40 + def on_module(node); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#55 + def message(length, max_length); end +end + +# Checks for methods with too many parameters. +# +# The maximum number of parameters is configurable. +# Keyword arguments can optionally be excluded from the total count, +# as they add less complexity than positional or optional parameters. +# +# Any number of arguments for `initialize` method inside a block of +# `Struct.new` and `Data.define` like this is always allowed: +# +# [source,ruby] +# ---- +# Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do +# def initialize(one:, two:, three:, four:, five:) +# end +# end +# ---- +# +# This is because checking the number of arguments of the `initialize` method +# does not make sense. +# +# NOTE: Explicit block argument `&block` is not counted to prevent +# erroneous change that is avoided by making block argument implicit. +# +# This cop also checks for the maximum number of optional parameters. +# This can be configured using the `MaxOptionalParameters` config option. +# +# @example Max: 3 +# # good +# def foo(a, b, c = 1) +# end +# @example Max: 2 +# # bad +# def foo(a, b, c = 1) +# end +# @example CountKeywordArgs: true (default) +# # counts keyword args towards the maximum +# +# # bad (assuming Max is 3) +# def foo(a, b, c, d: 1) +# end +# +# # good (assuming Max is 3) +# def foo(a, b, c: 1) +# end +# @example CountKeywordArgs: false +# # don't count keyword args towards the maximum +# +# # good (assuming Max is 3) +# def foo(a, b, c, d: 1) +# end +# @example MaxOptionalParameters: 3 (default) +# # good +# def foo(a = 1, b = 2, c = 3) +# end +# @example MaxOptionalParameters: 2 +# # bad +# def foo(a = 1, b = 2, c = 3) +# end +# +# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#70 +class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#121 + def argument_to_lambda_or_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max_optional_parameters=(value); end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#104 + def on_args(node); end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#90 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#90 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#81 + def struct_new_or_data_define_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#125 + def args_count(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#141 + def count_keyword_args?; end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#137 + def max_optional_parameters; end + + # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#133 + def max_params; end +end + +# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#74 +RuboCop::Cop::Metrics::ParameterLists::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#77 +RuboCop::Cop::Metrics::ParameterLists::NAMED_KEYWORD_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#75 +RuboCop::Cop::Metrics::ParameterLists::OPTIONAL_PARAMETERS_MSG = T.let(T.unsafe(nil), String) + +# Tries to produce a complexity score that's a measure of the +# complexity the reader experiences when looking at a method. For that +# reason it considers `when` nodes as something that doesn't add as much +# complexity as an `if` or a `&&`. Except if it's one of those special +# `case`/`when` constructs where there's no expression after `case`. Then +# the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when` +# nodes count. In contrast to the CyclomaticComplexity cop, this cop +# considers `else` nodes as adding complexity. +# +# @example +# +# def my_method # 1 +# if cond # 1 +# case var # 2 (0.8 + 4 * 0.2, rounded) +# when 1 then func_one +# when 2 then func_two +# when 3 then func_three +# when 4..10 then func_other +# end +# else # 1 +# do_something until a && b # 2 +# end # === +# end # 7 complexity points +# +# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#29 +class RuboCop::Cop::Metrics::PerceivedComplexity < ::RuboCop::Cop::Metrics::CyclomaticComplexity + private + + # source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#36 + def complexity_score_for(node); end +end + +# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#32 +RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#30 +RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#6 +module RuboCop::Cop::Metrics::Utils; end + +# > ABC is .. a software size metric .. computed by counting the number +# > of assignments, branches and conditions for a section of code. +# > http://c2.com/cgi/wiki?AbcMetric +# +# We separate the *calculator* from the *cop* so that the calculation, +# the formula itself, is easier to test. +# +# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#13 +class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + include ::RuboCop::AST::Sexp + include ::RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount + include ::RuboCop::Cop::Metrics::Utils::IteratingBlock + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + + # @return [AbcSizeCalculator] a new instance of AbcSizeCalculator + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#30 + def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#42 + def calculate; end + + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#53 + def calculate_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#65 + def else_branch?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#47 + def evaluate_branch_nodes(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#60 + def evaluate_condition_node(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#127 + def argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#86 + def assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#123 + def branch?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#119 + def capturing_variable?(name); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#95 + def compound_assignment(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#131 + def condition?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#108 + def simple_assignment?(node); end + + # @yield [node] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#71 + def visit_depth_last(node, &block); end + + class << self + # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#30 + def calculate(node, discount_repeated_attributes: T.unsafe(nil)); end + end +end + +# > Branch -- an explicit forward program branch out of scope -- a +# > function call, class method call .. +# > http://c2.com/cgi/wiki?AbcMetric +# +# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#21 +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array) + +# > Condition -- a logical/Boolean test, == != <= >= < > else case +# > default try catch ? and unary conditionals. +# > http://c2.com/cgi/wiki?AbcMetric +# +# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#26 +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::CONDITION_NODES = T.let(T.unsafe(nil), Array) + +# Helps to calculate code length for the provided node. +# +# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#8 +class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + extend ::RuboCop::AST::NodePattern::Macros + + # @return [CodeLengthCalculator] a new instance of CodeLengthCalculator + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#16 + def initialize(node, processed_source, count_comments: T.unsafe(nil), foldable_types: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#24 + def calculate; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#182 + def another_args?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#42 + def build_foldable_checks(types); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#90 + def classlike_code_length(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#138 + def classlike_node?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#66 + def code_length(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#163 + def count_comments?; end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#126 + def each_top_level_descendant(node, types, &block); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#146 + def extract_body(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#142 + def foldable_node?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#121 + def heredoc_length(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#86 + def heredoc_node?(node); end + + # Returns true for lines that shall not be included in the count. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#159 + def irrelevant_line?(source_line); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#110 + def line_numbers_of_inner_nodes(node, *types); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#106 + def namespace_module?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#186 + def node_with_heredoc?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#60 + def normalize_foldable_types(types); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#167 + def omit_length(descendant); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#178 + def parenthesized?(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#190 + def source_from_node_with_heredoc(node); end +end + +# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#13 +RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::CLASSLIKE_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#12 +RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::FOLDABLE_TYPES = T.let(T.unsafe(nil), Array) + +# Used to identify iterating blocks like `.map{}` and `.map(&:...)` +# +# source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#8 +module RuboCop::Cop::Metrics::Utils::IteratingBlock + # Returns the name of the method called with a block + # if node is a block node, or a block-pass node. + # + # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#37 + def block_method_name(node); end + + # Returns nil if node is neither a block node or a block-pass node. + # Otherwise returns true/false if method call is a known iterating call + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#53 + def iterating_block?(node); end + + # Returns true iff name is a known iterating type (e.g. :each, :transform_values) + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#47 + def iterating_method?(name); end +end + +# source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#33 +RuboCop::Cop::Metrics::Utils::IteratingBlock::KNOWN_ITERATING_METHODS = T.let(T.unsafe(nil), Set) + +# Identifies repetitions `{c}send` calls with no arguments: +# +# foo.bar +# foo.bar # => repeated +# foo.bar.baz.qux # => inner send repeated +# foo.bar.baz.other # => both inner send repeated +# foo.bar(2) # => not repeated +# +# It also invalidates sequences if a receiver is reassigned: +# +# xx.foo.bar +# xx.foo.baz # => inner send repeated +# self.xx = any # => invalidates everything so far +# xx.foo.baz # => no repetition +# self.xx.foo.baz # => all repeated +# +# @api private +# +# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#25 +module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount + include ::RuboCop::AST::Sexp + extend ::RuboCop::AST::NodePattern::Macros + + # Plug into the calculator + # + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#30 + def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#61 + def attribute_call?(param0 = T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#53 + def calculate_node(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#43 + def discount_repeated_attributes?; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#47 + def evaluate_branch_nodes(node); end + + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#92 + def root_node?(param0 = T.unsafe(nil)); end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#66 + def discount_repeated_attribute?(send_node); end + + # Returns the "known_attributes" for the `node` by walking the receiver tree + # If at any step the subdirectory does not exist, it is yielded with the + # associated key (method_name) + # If the node is not a series of `(c)send` calls with no arguments, + # then `nil` is yielded + # + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#103 + def find_attributes(node, &block); end + + # or `nil` if it is not a setter. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#126 + def setter_to_getter(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#80 + def update_repeated_attribute(node); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#117 +RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount::VAR_SETTER_TO_GETTER = T.let(T.unsafe(nil), Hash) + +# Identifies repetitions `&.` on the same variable: +# +# my_var&.foo +# my_var&.bar # => repeated +# my_var = baz # => reset +# my_var&.qux # => not repeated +# +# @api private +# +# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#15 +module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#20 + def discount_for_repeated_csend?(csend_node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#34 + def reset_on_lvasgn(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#16 + def reset_repeated_csend; end +end + +# source://rubocop//lib/rubocop/cop/migration/department_name.rb#5 +module RuboCop::Cop::Migration; end + +# department name. +# +# source://rubocop//lib/rubocop/cop/migration/department_name.rb#8 +class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#21 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#47 + def check_cop_name(name, comment, offset); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#69 + def contain_unexpected_character_for_department_name?(name); end + + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#43 + def disable_comment_offset; end + + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#73 + def qualified_legacy_cop_name(cop_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/migration/department_name.rb#63 + def valid_content_token?(content_token); end +end + +# source://rubocop//lib/rubocop/cop/migration/department_name.rb#14 +RuboCop::Cop::Migration::DepartmentName::DISABLE_COMMENT_FORMAT = T.let(T.unsafe(nil), Regexp) + +# The token that makes up a disable comment. +# `DepartmentName/CopName` or` all`. +# +# source://rubocop//lib/rubocop/cop/migration/department_name.rb#19 +RuboCop::Cop::Migration::DepartmentName::DISABLING_COPS_CONTENT_TOKEN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/migration/department_name.rb#12 +RuboCop::Cop::Migration::DepartmentName::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking minimum body length. +# +# source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#6 +module RuboCop::Cop::MinBodyLength + private + + # source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#13 + def min_body_length; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#9 + def min_body_length?(node); end +end + +# Common functionality for checking minimum branches count. +# +# source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#6 +module RuboCop::Cop::MinBranchesCount + private + + # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#29 + def if_conditional_branches(node, branches = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#22 + def min_branches_count; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#9 + def min_branches_count?(node); end +end + +# Common code for indenting the first elements in multiline +# array literals, hash literals, and method definitions. +# +# source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#7 +module RuboCop::Cop::MultilineElementIndentation + private + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#42 + def check_expected_style(styles); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#26 + def check_first(first, left_brace, left_parenthesis, offset); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#80 + def detected_styles(actual_column, offset, left_parenthesis, left_brace); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#85 + def detected_styles_for_column(column, left_parenthesis, left_brace); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#10 + def each_argument_node(node, type); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#66 + def hash_pair_where_value_beginning_with(left_brace, first); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#98 + def incorrect_style_detected(styles, first, base_column_type); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#50 + def indent_base(left_brace, first, left_parenthesis); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#72 + def key_and_value_begin_on_same_line?(pair); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#76 + def right_sibling_begins_on_subsequent_line?(pair); end +end + +# Common functionality for checking for a line break before each +# element in a multi-line collection. +# +# source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#7 +module RuboCop::Cop::MultilineElementLineBreaks + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#23 + def all_on_same_line?(nodes, ignore_last: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#10 + def check_line_breaks(_node, children, ignore_last: T.unsafe(nil)); end +end + +# Common functionality for checking multiline method calls and binary +# operations. +# +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#7 +module RuboCop::Cop::MultilineExpressionIndentation + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#14 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#14 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#132 + def argument_in_method_call(node, kind); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#188 + def assignment_rhs(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#65 + def check(range, node, lhs, rhs); end + + # The correct indentation of `node` is usually `IndentationWidth`, with + # one exception: prefix keywords. + # + # ``` + # while foo && # Here, `while` is called a "prefix keyword" + # bar # This is called "special indentation" + # baz + # end + # ``` + # + # Note that *postfix conditionals* do *not* get "special indentation". + # + # ``` + # next if foo && + # bar # normal indentation, not special + # ``` + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#55 + def correct_indentation(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#160 + def disqualified_rhs?(candidate, ancestor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#204 + def grouped_expression?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#73 + def incorrect_style_detected(range, node, lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#85 + def indentation(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#122 + def indented_keyword_expression(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#208 + def inside_arg_list_parentheses?(node, ancestor); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#99 + def keyword_message_tail(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#107 + def kw_node_with_special_indentation(node); end + + # In a chain of method calls, we regard the top call node as the base + # for indentation of all lines following the first. For example: + # a. + # b c { block }. <-- b is indented relative to a + # d <-- d is indented relative to a + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#32 + def left_hand_side(lhs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#198 + def not_for_this_cop?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#89 + def operation_description(node, rhs); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#146 + def part_of_assignment_rhs(node, candidate); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#184 + def part_of_block_body?(candidate, block_node); end + + # Returns true if `node` is a conditional whose `body` and `condition` + # begin on the same line. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#217 + def postfix_conditional?(node); end + + # The []= operator and setters (a.b = c) are parsed as :send nodes. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#176 + def valid_method_rhs_candidate?(candidate, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#165 + def valid_rhs?(candidate, ancestor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#180 + def valid_rhs_candidate?(candidate, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#221 + def within_node?(inner, outer); end +end + +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#11 +RuboCop::Cop::MultilineExpressionIndentation::ASSIGNMENT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#10 +RuboCop::Cop::MultilineExpressionIndentation::DEFAULT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#8 +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#12 +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#9 +RuboCop::Cop::MultilineExpressionIndentation::UNALIGNED_RHS_TYPES = T.let(T.unsafe(nil), Array) + +# Autocorrection logic for the closing brace of a literal either +# on the same line as the last contained elements, or a new line. +# +# source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#7 +class RuboCop::Cop::MultilineLiteralBraceCorrector + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::RangeHelp + + # @return [MultilineLiteralBraceCorrector] a new instance of MultilineLiteralBraceCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#15 + def initialize(corrector, node, processed_source); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#21 + def call; end + + private + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#61 + def content_if_comment_present(corrector, node); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#51 + def correct_heredoc_argument_method_chain(corrector, end_range); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#46 + def correct_next_line_brace(corrector, end_range); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#42 + def correct_same_line_brace(corrector); end + + # Returns the value of attribute corrector. + # + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40 + def corrector; end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#94 + def last_element_range_with_trailing_comma(node); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#103 + def last_element_trailing_comma_range(node); end + + # Returns the value of attribute node. + # + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40 + def node; end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40 + def processed_source; end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#90 + def remove_trailing_content_of_comment(corrector, range); end + + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#80 + def select_content_to_be_inserted_after_last_element(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#73 + def use_heredoc_argument_method_chain?(parent); end + + class << self + # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#11 + def correct(corrector, node, processed_source); end + end +end + +# Common functionality for checking the closing brace of a literal is +# either on the same line as the last contained elements or a new line. +# +# source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#7 +module RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + private + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#34 + def check(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#12 + def check_brace_layout(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#42 + def check_new_line(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#50 + def check_same_line(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#58 + def check_symmetrical(node); end + + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#86 + def children(node); end + + # This method depends on the fact that we have guarded + # against implicit and empty literals. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#98 + def closing_brace_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#74 + def empty_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#82 + def ignored_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#78 + def implicit_literal?(node); end + + # Starting with the parent node and recursively for the parent node's + # children, check if the node is a HEREDOC and if the HEREDOC ends below + # or on the last line of the parent node. + # + # Example: + # + # # node is `b: ...` parameter + # # last_line_heredoc?(node) => false + # foo(a, + # b: { + # a: 1, + # c: <<-EOM + # baz + # EOM + # } + # ) + # + # # node is `b: ...` parameter + # # last_line_heredoc?(node) => true + # foo(a, + # b: <<-EOM + # baz + # EOM + # ) + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#126 + def last_line_heredoc?(node, parent = T.unsafe(nil)); end + + # Returns true for the case + # [a, + # b # comment + # ].some_method + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#26 + def new_line_needed_before_closing_brace?(node); end + + # This method depends on the fact that we have guarded + # against implicit and empty literals. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#92 + def opening_brace_on_same_line?(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#5 +module RuboCop::Cop::Naming; end + +# Makes sure that accessor methods are named properly. Applies +# to both instance and class methods. +# +# NOTE: Offenses are only registered for methods with the expected +# arity. Getters (`get_attribute`) must have no arguments to be +# registered, and setters (`set_attribute(value)`) must have exactly +# one. +# +# @example +# # bad +# def set_attribute(value) +# end +# +# # good +# def attribute=(value) +# end +# +# # bad +# def get_attribute +# end +# +# # good +# def attribute +# end +# +# # accepted, incorrect arity for getter +# def get_value(attr) +# end +# +# # accepted, incorrect arity for setter +# def set_value +# end +# +# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#38 +class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#42 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#42 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#61 + def bad_reader_name?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#65 + def bad_writer_name?(node); end + + # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#53 + def message(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#39 +RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#40 +RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String) + +# Checks for non-ascii characters in identifier and constant names. +# Identifiers are always checked and whether constants are checked +# can be controlled using AsciiConstants config. +# +# @example +# # bad +# def καλημερα # Greek alphabet (non-ascii) +# end +# +# # bad +# def こんにちはと言う # Japanese character (non-ascii) +# end +# +# # bad +# def hello_🍣 # Emoji (non-ascii) +# end +# +# # good +# def say_hello +# end +# +# # bad +# 신장 = 10 # Hangul character (non-ascii) +# +# # good +# height = 10 +# +# # bad +# params[:عرض_gteq] # Arabic character (non-ascii) +# +# # good +# params[:width_gteq] +# @example AsciiConstants: true (default) +# # bad +# class Foö +# end +# +# FOÖ = "foo" +# @example AsciiConstants: false +# # good +# class Foö +# end +# +# FOÖ = "foo" +# +# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#53 +class RuboCop::Cop::Naming::AsciiIdentifiers < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#59 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#84 + def first_non_ascii_chars(string); end + + # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#74 + def first_offense_range(identifier); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#70 + def should_check?(token); end +end + +# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#57 +RuboCop::Cop::Naming::AsciiIdentifiers::CONSTANT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#56 +RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), String) + +# Makes sure that certain binary operator methods have their +# sole parameter named `other`. +# +# @example +# +# # bad +# def +(amount); end +# +# # good +# def +(other); end +# +# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#16 +class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#29 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#25 + def op_method_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#45 + def op_method?(name); end +end + +# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#22 +RuboCop::Cop::Naming::BinaryOperatorParameterName::EXCLUDED = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#19 +RuboCop::Cop::Naming::BinaryOperatorParameterName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#21 +RuboCop::Cop::Naming::BinaryOperatorParameterName::OP_LIKE_METHODS = T.let(T.unsafe(nil), Array) + +# In Ruby 3.1, anonymous block forwarding has been added. +# +# This cop identifies places where `do_something(&block)` can be replaced +# by `do_something(&)`. +# +# It also supports the opposite style by alternative `explicit` option. +# You can specify the block variable name for autocorrection with `BlockForwardingName`. +# The default variable name is `block`. If the name is already in use, it will not be +# autocorrected. +# +# @example EnforcedStyle: anonymous (default) +# +# # bad +# def foo(&block) +# bar(&block) +# end +# +# # good +# def foo(&) +# bar(&) +# end +# @example EnforcedStyle: explicit +# +# # bad +# def foo(&) +# bar(&) +# end +# +# # good +# def foo(&block) +# bar(&block) +# end +# +# source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#40 +class RuboCop::Cop::Naming::BlockForwarding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#54 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#54 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#87 + def anonymous_block_argument?(node); end + + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#119 + def block_forwarding_name; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#73 + def expected_block_forwarding_style?(node, last_argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#91 + def explicit_block_argument?(node); end + + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#95 + def register_offense(block_argument, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#111 + def use_block_argument_as_local_variable?(node, last_argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#83 + def use_kwarg_in_method_definition?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#50 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#48 +RuboCop::Cop::Naming::BlockForwarding::MSG = T.let(T.unsafe(nil), String) + +# Checks block parameter names for how descriptive they +# are. It is highly configurable. +# +# The `MinNameLength` config option takes an integer. It represents +# the minimum amount of characters the name must be. Its default is 1. +# The `AllowNamesEndingInNumbers` config option takes a boolean. When +# set to false, this cop will register offenses for names ending with +# numbers. Its default is false. The `AllowedNames` config option +# takes an array of permitted names that will never register an +# offense. The `ForbiddenNames` config option takes an array of +# restricted names that will always register an offense. +# +# @example +# # bad +# bar do |varOne, varTwo| +# varOne + varTwo +# end +# +# # With `AllowNamesEndingInNumbers` set to false +# foo { |num1, num2| num1 * num2 } +# +# # With `MinNameLength` set to number greater than 1 +# baz { |a, b, c| do_stuff(a, b, c) } +# +# # good +# bar do |thud, fred| +# thud + fred +# end +# +# foo { |speed, distance| speed * distance } +# +# baz { |age, height, gender| do_stuff(age, height, gender) } +# +# source://rubocop//lib/rubocop/cop/naming/block_parameter_name.rb#38 +class RuboCop::Cop::Naming::BlockParameterName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::UncommunicativeName + + # source://rubocop//lib/rubocop/cop/naming/block_parameter_name.rb#41 + def on_block(node); end +end + +# Checks for class and module names with +# an underscore in them. +# +# `AllowedNames` config takes an array of permitted names. +# Its default value is `['module_parent']`. +# These names can be full class/module names or part of the name. +# eg. Adding `my_class` to the `AllowedNames` config will allow names like +# `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc. +# +# @example +# # bad +# class My_Class +# end +# module My_Module +# end +# +# # good +# class MyClass +# end +# module MyModule +# end +# class module_parent::MyModule +# end +# +# source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#29 +class RuboCop::Cop::Naming::ClassAndModuleCamelCase < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#32 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#32 + def on_module(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#30 +RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String) + +# Checks whether constant names are written using +# SCREAMING_SNAKE_CASE. +# +# To avoid false positives, it ignores cases in which we cannot know +# for certain the type of value that would be assigned to a constant. +# +# @example +# # bad +# InchInCm = 2.54 +# INCHinCM = 2.54 +# Inch_In_Cm = 2.54 +# +# # good +# INCH_IN_CM = 2.54 +# +# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#20 +class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#27 + def class_or_struct_return_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#69 + def literal_receiver?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#33 + def on_casgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#56 + def allowed_assignment?(value); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#74 + def allowed_conditional_expression_on_rhs?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#63 + def allowed_method_call_on_rhs?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#78 + def contains_constant?(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#21 +RuboCop::Cop::Naming::ConstantName::MSG = T.let(T.unsafe(nil), String) + +# Use POSIX character classes, so we allow accented characters rather +# than just standard ASCII characters +# +# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#24 +RuboCop::Cop::Naming::ConstantName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +# Makes sure that Ruby source files have snake_case +# names. Ruby scripts (i.e. source files with a shebang in the +# first line) are ignored. +# +# The cop also ignores `.gemspec` files, because Bundler +# recommends using dashes to separate namespaces in nested gems +# (i.e. `bundler-console` becomes `Bundler::Console`). As such, the +# gemspec is supposed to be named `bundler-console.gemspec`. +# +# When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires +# each file to have a class, module or `Struct` defined in it that matches +# the filename. This can be further configured using +# `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the +# path should match the namespace of the above definition. +# +# When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start +# with a shebang line are not considered by the cop. +# +# When `Regex` is set, the cop will flag any filename that does not match +# the regular expression. +# +# @example +# # bad +# lib/layoutManager.rb +# +# anything/usingCamelCase +# +# # good +# lib/layout_manager.rb +# +# anything/using_snake_case.rake +# +# source://rubocop//lib/rubocop/cop/naming/file_name.rb#39 +class RuboCop::Cop::Naming::FileName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#56 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#49 + def struct_definition(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#134 + def allowed_acronyms; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#96 + def bad_filename_allowed?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#122 + def check_definition_path_hierarchy?; end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#169 + def defined_struct(node); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#126 + def definition_path_hierarchy_roots; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#118 + def expect_matching_definition?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#138 + def filename_good?(basename); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#147 + def find_class_or_module(node, namespace); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#165 + def find_definition(node); end + + # @yield [source_range(processed_source.buffer, 1, 0), msg] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#65 + def for_bad_filename(file_path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#114 + def ignore_executable_scripts?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#202 + def match?(expected); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#206 + def match_acronym?(expected, name); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#174 + def match_namespace(node, namespace, expected); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#92 + def matching_class?(file_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#88 + def matching_definition?(file_path); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#100 + def no_definition_message(basename, file_path); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#106 + def other_message(basename); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#188 + def partial_matcher!(expected); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#77 + def perform_class_and_module_naming_checks(file_path, basename); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#130 + def regex; end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#240 + def to_module_name(basename); end + + # source://rubocop//lib/rubocop/cop/naming/file_name.rb#213 + def to_namespace(path); end +end + +# source://rubocop//lib/rubocop/cop/naming/file_name.rb#43 +RuboCop::Cop::Naming::FileName::MSG_NO_DEFINITION = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/file_name.rb#44 +RuboCop::Cop::Naming::FileName::MSG_REGEX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/file_name.rb#42 +RuboCop::Cop::Naming::FileName::MSG_SNAKE_CASE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/file_name.rb#46 +RuboCop::Cop::Naming::FileName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +# Checks that your heredocs are using the configured case. +# By default it is configured to enforce uppercase heredocs. +# +# @example EnforcedStyle: uppercase (default) +# # bad +# <<-sql +# SELECT * FROM foo +# sql +# +# # good +# <<-SQL +# SELECT * FROM foo +# SQL +# @example EnforcedStyle: lowercase +# # bad +# <<-SQL +# SELECT * FROM foo +# SQL +# +# # good +# <<-sql +# SELECT * FROM foo +# sql +# +# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#30 +class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#37 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#54 + def correct_case_delimiters?(node); end + + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#58 + def correct_delimiters(source); end + + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#50 + def message(_node); end +end + +# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#35 +RuboCop::Cop::Naming::HeredocDelimiterCase::MSG = T.let(T.unsafe(nil), String) + +# Checks that your heredocs are using meaningful delimiters. +# By default it disallows `END` and `EO*`, and can be configured through +# forbidden listing additional delimiters. +# +# @example +# +# # good +# <<-SQL +# SELECT * FROM foo +# SQL +# +# # bad +# <<-END +# SELECT * FROM foo +# END +# +# # bad +# <<-EOS +# SELECT * FROM foo +# EOS +# +# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#26 +class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#31 + def on_heredoc(node); end + + private + + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#51 + def forbidden_delimiters; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#41 + def meaningful_delimiters?(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#29 +RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) + +# Recommends the use of inclusive language instead of problematic terms. +# The cop can check the following locations for offenses: +# +# - identifiers +# - constants +# - variables +# - strings +# - symbols +# - comments +# - file paths +# +# Each of these locations can be individually enabled/disabled via configuration, +# for example CheckIdentifiers = true/false. +# +# Flagged terms are configurable for the cop. For each flagged term an optional +# Regex can be specified to identify offenses. Suggestions for replacing a flagged term can +# be configured and will be displayed as part of the offense message. +# An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term. +# `WholeWord: true` can be set on a flagged term to indicate the cop should only match when +# a term matches the whole word (partial matches will not be offenses). +# +# The cop supports autocorrection when there is only one suggestion. When there are multiple +# suggestions, the best suggestion cannot be identified and will not be autocorrected. +# +# @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } } +# # Suggest replacing identifier whitelist with allowlist +# +# # bad +# whitelist_users = %w(user1 user1) +# +# # good +# allowlist_users = %w(user1 user2) +# @example FlaggedTerms: { master: { Suggestions: ['main', 'primary', 'leader'] } } +# # Suggest replacing master in an instance variable name with main, primary, or leader +# +# # bad +# @master_node = 'node1.example.com' +# +# # good +# @primary_node = 'node1.example.com' +# @example FlaggedTerms: { whitelist: { Regex: !ruby/regexp '/white[-_\s]?list' } } +# # Identify problematic terms using a Regexp +# +# # bad +# white_list = %w(user1 user2) +# +# # good +# allow_list = %w(user1 user2) +# @example FlaggedTerms: { master: { AllowedRegex: 'master\'?s degree' } } +# # Specify allowed uses of the flagged term as a string or regexp. +# +# # bad +# # They had a masters +# +# # good +# # They had a master's degree +# @example FlaggedTerms: { slave: { WholeWord: true } } +# # Specify that only terms that are full matches will be flagged. +# +# # bad +# Slave +# +# # good (won't be flagged despite containing `slave`) +# TeslaVehicle +# +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#74 +class RuboCop::Cop::Naming::InclusiveLanguage < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [InclusiveLanguage] a new instance of InclusiveLanguage + # + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#84 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#93 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#111 + def add_offenses_for_token(token, word_locations); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#167 + def add_to_flagged_term_hash(regex_string, term, term_definition); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#193 + def array_to_ignorecase_regex(strings); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#126 + def check_token?(type); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#244 + def create_message(word, message = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#218 + def create_multiple_word_message_for_file(words); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#214 + def create_single_word_message_for_file(word); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#189 + def ensure_regex_string(regex); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#160 + def extract_regexp(term, term_definition); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#252 + def find_flagged_term(word); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#266 + def format_suggestions(suggestions); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#197 + def investigate_filepath; end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#100 + def investigate_tokens; end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#232 + def mask_input(str); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#281 + def offense_range(token, word); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#130 + def preprocess_check_config; end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#144 + def preprocess_flagged_terms; end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#259 + def preprocess_suggestions(suggestions); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#179 + def process_allowed_regex(allowed); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#222 + def scan_for_words(input); end + + # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#174 + def set_regexes(flagged_term_strings, allowed_strings); end +end + +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#78 +RuboCop::Cop::Naming::InclusiveLanguage::EMPTY_ARRAY = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#79 +RuboCop::Cop::Naming::InclusiveLanguage::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#80 +RuboCop::Cop::Naming::InclusiveLanguage::MSG_FOR_FILE_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#82 +class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < ::Struct + # Returns the value of attribute position + # + # @return [Object] the current value of position + def position; end + + # Sets the attribute position + # + # @param value [Object] the value to set the attribute position to. + # @return [Object] the newly set value + def position=(_); end + + # Returns the value of attribute word + # + # @return [Object] the current value of word + def word; end + + # Sets the attribute word + # + # @param value [Object] the value to set the attribute word to. + # @return [Object] the newly set value + def word=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# Checks for memoized methods whose instance variable name +# does not match the method name. Applies to both regular methods +# (defined with `def`) and dynamic methods (defined with +# `define_method` or `define_singleton_method`). +# +# This cop can be configured with the EnforcedStyleForLeadingUnderscores +# directive. It can be configured to allow for memoized instance variables +# prefixed with an underscore. Prefixing ivars with an underscore is a +# convention that is used to implicitly indicate that an ivar should not +# be set or referenced outside of the memoization method. +# +# @example EnforcedStyleForLeadingUnderscores: disallowed (default) +# # bad +# # Method foo is memoized using an instance variable that is +# # not `@foo`. This can cause confusion and bugs. +# def foo +# @something ||= calculate_expensive_thing +# end +# +# def foo +# return @something if defined?(@something) +# @something = calculate_expensive_thing +# end +# +# # good +# def _foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= begin +# calculate_expensive_thing +# end +# end +# +# # good +# def foo +# helper_variable = something_we_need_to_calculate_foo +# @foo ||= calculate_expensive_thing(helper_variable) +# end +# +# # good +# define_method(:foo) do +# @foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# return @foo if defined?(@foo) +# @foo = calculate_expensive_thing +# end +# @example EnforcedStyleForLeadingUnderscores: required +# # bad +# def foo +# @something ||= calculate_expensive_thing +# end +# +# # bad +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# def foo +# return @foo if defined?(@foo) +# @foo = calculate_expensive_thing +# end +# +# # good +# def foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def _foo +# @_foo ||= calculate_expensive_thing +# end +# +# def foo +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# @example EnforcedStyleForLeadingUnderscores :optional +# # bad +# def foo +# @something ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def _foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @_foo ||= calculate_expensive_thing +# end +# +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#148 +class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#197 + def defined_memoized?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#160 + def method_definition?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#205 + def on_defined?(node); end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#170 + def on_or_asgn(node); end + + private + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#242 + def find_definition(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#253 + def matches?(method_name, ivar_assign); end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#263 + def message(variable); end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#238 + def style_parameter_name; end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#271 + def suggested_var(method_name); end + + # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#277 + def variable_name_candidates(method_name); end +end + +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#157 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#153 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#155 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String) + +# Makes sure that all methods use the configured style, +# snake_case or camelCase, for their names. +# +# This cop has `AllowedPatterns` configuration option. +# +# Naming/MethodName: +# AllowedPatterns: +# - '\AonSelectionBulkChange\z' +# - '\AonSelectionCleared\z' +# +# Method names matching patterns are always allowed. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# def fooBar; end +# +# # good +# def foo_bar; end +# @example EnforcedStyle: camelCase +# # bad +# def foo_bar; end +# +# # good +# def fooBar; end +# +# source://rubocop//lib/rubocop/cop/naming/method_name.rb#31 +class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#55 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#55 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#44 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#42 + def str_name(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#39 + def sym_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#64 + def attr_name(name_item); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#75 + def message(style); end + + # source://rubocop//lib/rubocop/cop/naming/method_name.rb#68 + def range_position(node); end +end + +# source://rubocop//lib/rubocop/cop/naming/method_name.rb#36 +RuboCop::Cop::Naming::MethodName::MSG = T.let(T.unsafe(nil), String) + +# Checks method parameter names for how descriptive they +# are. It is highly configurable. +# +# The `MinNameLength` config option takes an integer. It represents +# the minimum amount of characters the name must be. Its default is 3. +# The `AllowNamesEndingInNumbers` config option takes a boolean. When +# set to false, this cop will register offenses for names ending with +# numbers. Its default is false. The `AllowedNames` config option +# takes an array of permitted names that will never register an +# offense. The `ForbiddenNames` config option takes an array of +# restricted names that will always register an offense. +# +# @example +# # bad +# def bar(varOne, varTwo) +# varOne + varTwo +# end +# +# # With `AllowNamesEndingInNumbers` set to false +# def foo(num1, num2) +# num1 * num2 +# end +# +# # With `MinNameLength` set to number greater than 1 +# def baz(a, b, c) +# do_stuff(a, b, c) +# end +# +# # good +# def bar(thud, fred) +# thud + fred +# end +# +# def foo(speed, distance) +# speed * distance +# end +# +# def baz(age_a, height_b, gender_c) +# do_stuff(age_a, height_b, gender_c) +# end +# +# source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#46 +class RuboCop::Cop::Naming::MethodParameterName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::UncommunicativeName + + # source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#49 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#49 + def on_defs(node); end +end + +# Checks that predicate methods names end with a question mark and +# do not start with a forbidden prefix. +# +# A method is determined to be a predicate method if its name starts +# with one of the prefixes defined in the `NamePrefix` configuration. +# You can change what prefixes are considered by changing this option. +# Any method name that starts with one of these prefixes is required by +# the cop to end with a `?`. Other methods can be allowed by adding to +# the `AllowedMethods` configuration. +# +# NOTE: The `is_a?` method is allowed by default. +# +# If `ForbiddenPrefixes` is set, methods that start with the configured +# prefixes will not be allowed and will be removed by autocorrection. +# +# In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo` +# will register an offense only due to the lack of question mark (and will be +# autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`, +# `is_foo` will register an offense both because the ? is missing and because of +# the `is_` prefix, and will be corrected to `foo?`. +# +# NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`; +# a prefix in the former but not the latter will not be considered by +# this cop. +# +# @example +# # bad +# def is_even(value) +# end +# +# def is_even?(value) +# end +# +# # good +# def even?(value) +# end +# +# # bad +# def has_value +# end +# +# def has_value? +# end +# +# # good +# def value? +# end +# @example AllowedMethods: ['is_a?'] (default) +# # good +# def is_a?(value) +# end +# +# source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#59 +class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#63 + def dynamic_method_define(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#82 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#82 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#69 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#98 + def allowed_method_name?(method_name, prefix); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#106 + def expected_name(method_name, prefix); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#120 + def forbidden_prefixes; end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#116 + def message(method_name, new_name); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#128 + def method_definition_macros(macro_name); end + + # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#124 + def predicate_prefixes; end +end + +# Makes sure that rescued exceptions variables are named as +# expected. +# +# The `PreferredName` config option takes a `String`. It represents +# the required name of the variable. Its default is `e`. +# +# NOTE: This cop does not consider nested rescues because it cannot +# guarantee that the variable from the outer rescue is not used within +# the inner rescue (in which case, changing the inner variable would +# shadow the outer variable). +# +# @example PreferredName: e (default) +# # bad +# begin +# # do something +# rescue MyException => exception +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => e +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => _e +# # do something +# end +# @example PreferredName: exception +# # bad +# begin +# # do something +# rescue MyException => e +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => exception +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => _exception +# # do something +# end +# +# source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#61 +class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#66 + def on_resbody(node); end + + private + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#96 + def autocorrect(corrector, node, range, offending_name, preferred_name); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#116 + def correct_node(corrector, node, offending_name, preferred_name); end + + # If the exception variable is reassigned, that assignment needs to be corrected. + # Further `lvar` nodes will not be corrected though since they now refer to a + # different variable. + # + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#134 + def correct_reassignment(corrector, node, offending_name, preferred_name); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#159 + def message(node); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#91 + def offense_range(resbody); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#143 + def preferred_name(variable_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#165 + def shadowed_variable_name?(node); end + + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#152 + def variable_name(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#106 + def variable_name_matches?(node, name); end +end + +# source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#64 +RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), String) + +# Makes sure that all variables use the configured style, +# snake_case or camelCase, for their names. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# fooBar = 1 +# +# # good +# foo_bar = 1 +# @example EnforcedStyle: camelCase +# # bad +# foo_bar = 1 +# +# # good +# fooBar = 1 +# @example AllowedIdentifiers: ['fooBar'] +# # good (with EnforcedStyle: snake_case) +# fooBar = 1 +# @example AllowedPatterns: ['_v\d+\z'] +# # good (with EnforcedStyle: camelCase) +# :release_v1 +# +# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#31 +class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedIdentifiers + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_arg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_blockarg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_kwarg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_kwoptarg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_kwrestarg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_lvar(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_optarg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42 + def on_restarg(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#38 + def valid_name?(node, name, given_style = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#62 + def message(style); end +end + +# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#36 +RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String) + +# Makes sure that all numbered variables use the +# configured style, snake_case, normalcase, or non_integer, +# for their numbering. +# +# Additionally, `CheckMethodNames` and `CheckSymbols` configuration options +# can be used to specify whether method names and symbols should be checked. +# Both are enabled by default. +# +# @example EnforcedStyle: normalcase (default) +# # bad +# :some_sym_1 +# variable_1 = 1 +# +# def some_method_1; end +# +# def some_method1(arg_1); end +# +# # good +# :some_sym1 +# variable1 = 1 +# +# def some_method1; end +# +# def some_method1(arg1); end +# @example EnforcedStyle: snake_case +# # bad +# :some_sym1 +# variable1 = 1 +# +# def some_method1; end +# +# def some_method_1(arg1); end +# +# # good +# :some_sym_1 +# variable_1 = 1 +# +# def some_method_1; end +# +# def some_method_1(arg_1); end +# @example EnforcedStyle: non_integer +# # bad +# :some_sym1 +# :some_sym_1 +# +# variable1 = 1 +# variable_1 = 1 +# +# def some_method1; end +# +# def some_method_1; end +# +# def some_methodone(arg1); end +# def some_methodone(arg_1); end +# +# # good +# :some_symone +# :some_sym_one +# +# variableone = 1 +# variable_one = 1 +# +# def some_methodone; end +# +# def some_method_one; end +# +# def some_methodone(argone); end +# def some_methodone(arg_one); end +# +# # In the following examples, we assume `EnforcedStyle: normalcase` (default). +# @example CheckMethodNames: true (default) +# # bad +# def some_method_1; end +# @example CheckMethodNames: false +# # good +# def some_method_1; end +# @example CheckSymbols: true (default) +# # bad +# :some_sym_1 +# @example CheckSymbols: false +# # good +# :some_sym_1 +# @example AllowedIdentifiers: [capture3] +# # good +# expect(Open3).to receive(:capture3) +# @example AllowedPatterns: ['_v\d+\z'] +# # good +# :some_sym_v1 +# +# source://rubocop//lib/rubocop/cop/naming/variable_number.rb#103 +class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedIdentifiers + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114 + def on_arg(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#126 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#126 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#134 + def on_sym(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#110 + def valid_name?(node, name, given_style = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#143 + def message(style); end +end + +# source://rubocop//lib/rubocop/cop/naming/variable_number.rb#108 +RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String) + +# Some common code shared between `NegatedIf` and +# `NegatedWhile` cops. +# +# source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#7 +module RuboCop::Cop::NegativeConditional + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#18 + def empty_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#15 + def single_negative?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#20 + def check_negative_conditional(node, message:, &block); end +end + +# source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#10 +RuboCop::Cop::NegativeConditional::MSG = T.let(T.unsafe(nil), String) + +# This module provides a list of methods that are: +# 1. In the NilClass by default +# 2. Added to NilClass by explicitly requiring any standard libraries +# 3. Cop's configuration parameter AllowedMethods. +# +# source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#9 +module RuboCop::Cop::NilMethods + include ::RuboCop::Cop::AllowedMethods + + private + + # source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#14 + def nil_methods; end + + # source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#18 + def other_stdlib_methods; end +end + +# An offense represents a style violation detected by RuboCop. +# +# source://rubocop//lib/rubocop/cop/offense.rb#6 +class RuboCop::Cop::Offense + include ::Comparable + + # @api private + # @return [Offense] a new instance of Offense + # + # source://rubocop//lib/rubocop/cop/offense.rb#84 + def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil)); end + + # Returns `-1`, `0`, or `+1` + # if this offense is less than, equal to, or greater than `other`. + # + # @api public + # @return [Integer] comparison result + # + # source://rubocop//lib/rubocop/cop/offense.rb#230 + def <=>(other); end + + # @api public + # @return [Boolean] returns `true` if two offenses contain same attributes + # + # source://rubocop//lib/rubocop/cop/offense.rb#211 + def ==(other); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#160 + def column; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#170 + def column_length; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#194 + def column_range; end + + # @api public + # @example + # 'LineLength' + # @return [String] a cop class name without department. + # i.e. type of the violation. + # + # source://rubocop//lib/rubocop/cop/offense.rb#51 + def cop_name; end + + # @api public + # @return [Boolean] whether this offense can be automatically corrected via + # autocorrect or a todo. + # + # source://rubocop//lib/rubocop/cop/offense.rb#102 + def correctable?; end + + # @api public + # @return [Boolean] whether this offense is automatically corrected via + # autocorrect or a todo. + # + # source://rubocop//lib/rubocop/cop/offense.rb#113 + def corrected?; end + + # @api public + # @return [Boolean] whether this offense is automatically disabled via a todo. + # + # source://rubocop//lib/rubocop/cop/offense.rb#123 + def corrected_with_todo?; end + + # @api public + # @return [Corrector | nil] the autocorrection for this offense, or `nil` when not available + # + # source://rubocop//lib/rubocop/cop/offense.rb#62 + def corrector; end + + # @api public + # @return [Boolean] whether this offense was locally disabled with a + # disable or todo where it occurred. + # + # source://rubocop//lib/rubocop/cop/offense.rb#134 + def disabled?; end + + # @api public + # @return [Boolean] returns `true` if two offenses contain same attributes + # + # source://rubocop//lib/rubocop/cop/offense.rb#211 + def eql?(other); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#179 + def first_line; end + + # source://rubocop//lib/rubocop/cop/offense.rb#219 + def hash; end + + # @api public + # @return [Parser::Source::Range] the range of the code that is highlighted + # + # source://rubocop//lib/rubocop/cop/offense.rb#142 + def highlighted_area; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#189 + def last_column; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#184 + def last_line; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#155 + def line; end + + # @api public + # @return [Parser::Source::Range] the location where the violation is detected. + # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range Parser::Source::Range + # + # source://rubocop//lib/rubocop/cop/offense.rb#28 + def location; end + + # @api public + # @example + # 'Line is too long. [90/80]' + # @return [String] human-readable message + # + # source://rubocop//lib/rubocop/cop/offense.rb#39 + def message; end + + # Internally we use column number that start at 0, but when + # outputting column numbers, we want them to start at 1. One + # reason is that editors, such as Emacs, expect this. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#203 + def real_column; end + + # @api public + # @return [RuboCop::Cop::Severity] + # + # source://rubocop//lib/rubocop/cop/offense.rb#17 + def severity; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#165 + def source_line; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#54 + def status; end + + # This is just for debugging purpose. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/offense.rb#148 + def to_s; end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/offense.rb#10 +RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/offense.rb#81 +RuboCop::Cop::Offense::NO_LOCATION = T.let(T.unsafe(nil), RuboCop::Cop::Offense::PseudoSourceRange) + +# source://rubocop//lib/rubocop/cop/offense.rb#64 +class RuboCop::Cop::Offense::PseudoSourceRange < ::Struct + # Returns the value of attribute begin_pos + # + # @return [Object] the current value of begin_pos + def begin_pos; end + + # Sets the attribute begin_pos + # + # @param value [Object] the value to set the attribute begin_pos to. + # @return [Object] the newly set value + def begin_pos=(_); end + + # Returns the value of attribute column + # + # @return [Object] the current value of column + def column; end + + # Sets the attribute column + # + # @param value [Object] the value to set the attribute column to. + # @return [Object] the newly set value + def column=(_); end + + # source://rubocop//lib/rubocop/cop/offense.rb#70 + def column_range; end + + # Returns the value of attribute end_pos + # + # @return [Object] the current value of end_pos + def end_pos; end + + # Sets the attribute end_pos + # + # @param value [Object] the value to set the attribute end_pos to. + # @return [Object] the newly set value + def end_pos=(_); end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def first_line; end + + # Returns the value of attribute column + # + # @return [Object] the current value of column + def last_column; end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def last_line; end + + # source://rubocop//lib/rubocop/cop/offense.rb#74 + def length; end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def line; end + + # Sets the attribute line + # + # @param value [Object] the value to set the attribute line to. + # @return [Object] the newly set value + def line=(_); end + + # source://rubocop//lib/rubocop/cop/offense.rb#74 + def size; end + + # Returns the value of attribute source_line + # + # @return [Object] the current value of source_line + def source_line; end + + # Sets the attribute source_line + # + # @param value [Object] the value to set the attribute source_line to. + # @return [Object] the newly set value + def source_line=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# Common functionality for cops checking if and unless expressions. +# +# source://rubocop//lib/rubocop/cop/mixin/on_normal_if_unless.rb#6 +module RuboCop::Cop::OnNormalIfUnless + # source://rubocop//lib/rubocop/cop/mixin/on_normal_if_unless.rb#7 + def on_if(node); end +end + +# This autocorrects gem dependency order +# +# source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#6 +class RuboCop::Cop::OrderedGemCorrector + extend ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::RangeHelp + + class << self + # Returns the value of attribute comments_as_separators. + # + # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#11 + def comments_as_separators; end + + # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#13 + def correct(processed_source, node, previous_declaration, comments_as_separators); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#11 + def processed_source; end + + private + + # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#26 + def declaration_with_comment(node); end + end +end + +# Common functionality for Bundler/OrderedGems and +# Gemspec/OrderedDependencies. +# +# source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#7 +module RuboCop::Cop::OrderedGemNode + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#23 + def case_insensitive_out_of_order?(string_a, string_b); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#27 + def consecutive_lines(previous, current); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#55 + def find_gem_name(gem_node); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#18 + def gem_canonical_name(name); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#49 + def gem_name(declaration_node); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#10 + def get_source_range(node, comments_as_separators); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#32 + def register_offense(previous, current); end + + # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#61 + def treat_comments_as_separators; end +end + +# Common functionality for handling parentheses. +# +# source://rubocop//lib/rubocop/cop/mixin/parentheses.rb#6 +module RuboCop::Cop::Parentheses + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/parentheses.rb#9 + def parens_required?(node); end +end + +# This autocorrects parentheses +# +# source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#6 +class RuboCop::Cop::ParenthesesCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#12 + def correct(corrector, node); end + + private + + # Add a comma back after the heredoc identifier + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#74 + def add_heredoc_comma(corrector, node); end + + # If the node contains a heredoc, remove the comma too + # It'll be added back in the right place later + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#64 + def extend_range_for_heredoc(node, range); end + + # If removing parentheses leaves a comma on its own line, remove all the whitespace + # preceding it to prevent a syntax error. + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#41 + def handle_orphaned_comma(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#80 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#28 + def next_char_is_question_mark?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#32 + def only_closing_paren_before_comma?(node); end + + # Get a range for the closing parenthesis and all whitespace to the left of it + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#51 + def parens_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#24 + def ternary_condition?(node); end + end +end + +# Common functionality for handling percent arrays. +# +# source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#6 +module RuboCop::Cop::PercentArray + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#26 + def allowed_bracket_array?(node); end + + # @param node [RuboCop::AST::ArrayNode] + # @param elements [Array] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#83 + def build_bracketed_array_with_appropriate_whitespace(elements:, node:); end + + # @param preferred_array_code [String] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#56 + def build_message_for_bracketed_array(preferred_array_code); end + + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#67 + def check_bracketed_array(node, literal_prefix); end + + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#36 + def check_percent_array(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#31 + def comments_in_array?(node); end + + # Override to determine values that are invalid in a percent array + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#22 + def invalid_percent_array_contents?(_node); end + + # Ruby does not allow percent arrays in an ambiguous block context. + # + # @example + # + # foo %i[bar baz] { qux } + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#14 + def invalid_percent_array_context?(node); end + + # Provides whitespace between elements for building a bracketed array. + # %w[ a b c ] + # ^^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#98 + def whitespace_between(node); end + + # Provides leading whitespace for building a bracketed array. + # %w[ a b c ] + # ^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#111 + def whitespace_leading(node); end + + # Provides trailing whitespace for building a bracketed array. + # %w[ a b c ] + # ^^^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#120 + def whitespace_trailing(node); end +end + +# Common functionality for handling percent literals. +# +# source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#6 +module RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + + private + + # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#23 + def begin_source(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#11 + def percent_literal?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#17 + def process(node, *types); end + + # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#27 + def type(node); end +end + +# This autocorrects percent literals +# +# source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#6 +class RuboCop::Cop::PercentLiteralCorrector + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + + # @return [PercentLiteralCorrector] a new instance of PercentLiteralCorrector + # + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#11 + def initialize(config, preferred_delimiters); end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#9 + def config; end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#16 + def correct(corrector, node, char); end + + # Returns the value of attribute preferred_delimiters. + # + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#9 + def preferred_delimiters; end + + private + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#46 + def autocorrect_multiline_words(node, escape, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#52 + def autocorrect_words(node, escape, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#34 + def delimiters_for(type); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#100 + def end_content(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#30 + def escape_words?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#78 + def first_line?(node, previous_line_num); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#89 + def fix_escaped_content(word_node, escape, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#69 + def line_breaks(node, source, previous_line_num, base_line_num, node_index); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#38 + def new_contents(node, escape, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#82 + def process_lines(node, previous_line_num, base_line_num, source_in_lines); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#58 + def process_multiline_words(node, escape, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#96 + def substitute_escaped_delimiters(content, delimiters); end + + # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#26 + def wrap_contents(corrector, node, contents, char, delimiters); end +end + +# Common functionality for checking whether an AST node/token is aligned +# with something on a preceding or following line +# +# source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#7 +module RuboCop::Cop::PrecedingFollowingAlignment + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#93 + def aligned_assignment?(range, line); end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#70 + def aligned_comment_lines; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#105 + def aligned_identical?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#81 + def aligned_operator?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#77 + def aligned_token?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#34 + def aligned_with_adjacent_line?(range, predicate); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#52 + def aligned_with_any_line?(line_ranges, range, indent = T.unsafe(nil), &predicate); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#42 + def aligned_with_any_line_range?(line_ranges, range, &predicate); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#98 + def aligned_with_append_operator?(range, line); end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#109 + def aligned_with_assignment(token, line_range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#56 + def aligned_with_line?(line_nos, range, indent = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#18 + def aligned_with_operator?(range); end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#22 + def aligned_with_preceding_assignment(token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#14 + def aligned_with_something?(range); end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#28 + def aligned_with_subsequent_assignment(token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#85 + def aligned_words?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#10 + def allow_for_alignment?; end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#127 + def assignment_lines; end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#131 + def assignment_tokens; end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#147 + def relevant_assignment_lines(line_range); end + + # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#174 + def remove_optarg_equals(asgn_tokens, processed_source); end +end + +# Common functionality for handling percent literal delimiters. +# +# source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#6 +class RuboCop::Cop::PreferredDelimiters + # @return [PreferredDelimiters] a new instance of PreferredDelimiters + # + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#11 + def initialize(type, config, preferred_delimiters); end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#7 + def config; end + + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#17 + def delimiters; end + + # Returns the value of attribute type. + # + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#7 + def type; end + + private + + # @raise [ArgumentError] + # + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#23 + def ensure_valid_preferred_delimiters; end + + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#30 + def preferred_delimiters; end + + # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#45 + def preferred_delimiters_config; end +end + +# source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#9 +RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +# This autocorrects punctuation +# +# source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#6 +class RuboCop::Cop::PunctuationCorrector + class << self + # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#12 + def add_space(corrector, token); end + + # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#8 + def remove_space(corrector, space_before); end + + # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#16 + def swap_comma(corrector, range); end + end +end + +# Methods that calculate and return Parser::Source::Ranges +# +# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#6 +module RuboCop::Cop::RangeHelp + private + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#141 + def add_range(range1, range2); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#82 + def column_offset_between(base_range, range); end + + # A range containing only the contents of a literal with delimiters (e.g. in + # `%i{1 2 3}` this will be the range covering `1 2 3` only). + # + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#32 + def contents_range(node); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#100 + def directions(side); end + + # Returns the column attribute of the range, except if the range is on + # the first line and there's a byte order mark at the beginning of that + # line, in which case 1 is subtracted from the column value. This gives + # the column as it appears when viewing the file in an editor. + # + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#92 + def effective_column(range); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#109 + def final_pos(src, pos, increment, continuations, newlines, whitespace); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#117 + def move_pos(src, pos, step, condition, regexp); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#123 + def move_pos_str(src, pos, step, condition, needle); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#36 + def range_between(start_pos, end_pos); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#73 + def range_by_whole_lines(range, include_final_newline: T.unsafe(nil), buffer: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#134 + def range_with_comments(node); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#130 + def range_with_comments_and_lines(node); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#40 + def range_with_surrounding_comma(range, side = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#55 + def range_with_surrounding_space(range_positional = T.unsafe(nil), range: T.unsafe(nil), side: T.unsafe(nil), newlines: T.unsafe(nil), whitespace: T.unsafe(nil), continuations: T.unsafe(nil), buffer: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#11 + def source_range(source_buffer, line_number, column, length = T.unsafe(nil)); end +end + +# The Unicode codepoint +# +# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#9 +RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#54 +module RuboCop::Cop::RangeHelp::NOT_GIVEN; end + +# Common functionality for handling Rational literals. +# +# source://rubocop//lib/rubocop/cop/mixin/rational_literal.rb#6 +module RuboCop::Cop::RationalLiteral + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/rational_literal.rb#12 + def rational_literal?(param0 = T.unsafe(nil)); end +end + +# Registry that tracks all cops by their badge and department. +# +# source://rubocop//lib/rubocop/cop/registry.rb#19 +class RuboCop::Cop::Registry + include ::Enumerable + + # @return [Registry] a new instance of Registry + # + # source://rubocop//lib/rubocop/cop/registry.rb#51 + def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/registry.rb#232 + def ==(other); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#97 + def contains_cop_matching?(names); end + + # source://rubocop//lib/rubocop/cop/registry.rb#179 + def cops; end + + # source://rubocop//lib/rubocop/cop/registry.rb#224 + def cops_for_department(department); end + + # @return [Boolean] Checks if given name is department + # + # source://rubocop//lib/rubocop/cop/registry.rb#93 + def department?(name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#147 + def department_missing?(badge, name); end + + # @return [Array] list of departments for current cops. + # + # source://rubocop//lib/rubocop/cop/registry.rb#72 + def departments; end + + # source://rubocop//lib/rubocop/cop/registry.rb#193 + def disabled(config); end + + # source://rubocop//lib/rubocop/cop/registry.rb#67 + def dismiss(cop); end + + # source://rubocop//lib/rubocop/cop/registry.rb#247 + def each(&block); end + + # source://rubocop//lib/rubocop/cop/registry.rb#189 + def enabled(config); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#197 + def enabled?(cop, config); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#213 + def enabled_pending_cop?(cop_cfg, config); end + + # source://rubocop//lib/rubocop/cop/registry.rb#63 + def enlist(cop); end + + # @param cop_name [String] + # @return [Class, nil] + # + # source://rubocop//lib/rubocop/cop/registry.rb#253 + def find_by_cop_name(cop_name); end + + # When a cop name is given returns a single-element array with the cop class. + # When a department name is given returns an array with all the cop classes + # for that department. + # + # source://rubocop//lib/rubocop/cop/registry.rb#260 + def find_cops_by_directive(directive); end + + # source://rubocop//lib/rubocop/cop/registry.rb#265 + def freeze; end + + # source://rubocop//lib/rubocop/cop/registry.rb#184 + def length; end + + # source://rubocop//lib/rubocop/cop/registry.rb#220 + def names; end + + # source://rubocop//lib/rubocop/cop/registry.rb#228 + def names_for_department(department); end + + # Returns the value of attribute options. + # + # source://rubocop//lib/rubocop/cop/registry.rb#49 + def options; end + + # source://rubocop//lib/rubocop/cop/registry.rb#151 + def print_warning(name, path); end + + # Convert a user provided cop name into a properly namespaced name + # + # @example gives back a correctly qualified cop name + # + # registry = RuboCop::Cop::Registry + # registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine' + # @example fixes incorrect namespaces + # + # registry = RuboCop::Cop::Registry + # registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine' + # @example namespaces bare cop identifiers + # + # registry = RuboCop::Cop::Registry + # registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine' + # @example passes back unrecognized cop names + # + # registry = RuboCop::Cop::Registry + # registry.qualified_cop_name('NotACop', '') # => 'NotACop' + # @note Emits a warning if the provided name has an incorrect namespace + # @param name [String] Cop name extracted from config + # @param path [String, nil] Path of file that `name` was extracted from + # @param warn [Boolean] Print a warning if no department given for `name` + # @raise [AmbiguousCopName] if a bare identifier with two possible namespaces is provided + # @return [String] Qualified cop name + # + # source://rubocop//lib/rubocop/cop/registry.rb#133 + def qualified_cop_name(name, path, warn: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/registry.rb#166 + def qualify_badge(badge); end + + # source://rubocop//lib/rubocop/cop/registry.rb#243 + def select(&block); end + + # source://rubocop//lib/rubocop/cop/registry.rb#236 + def sort!; end + + # @return [Hash{String => Array}] + # + # source://rubocop//lib/rubocop/cop/registry.rb#174 + def to_h; end + + # source://rubocop//lib/rubocop/cop/registry.rb#159 + def unqualified_cop_names; end + + # @return [Registry] Cops for that specific department. + # + # source://rubocop//lib/rubocop/cop/registry.rb#78 + def with_department(department); end + + # @return [Registry] Cops not for a specific department. + # + # source://rubocop//lib/rubocop/cop/registry.rb#84 + def without_department(department); end + + private + + # source://rubocop//lib/rubocop/cop/registry.rb#283 + def clear_enrollment_queue; end + + # source://rubocop//lib/rubocop/cop/registry.rb#279 + def initialize_copy(reg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#309 + def registered?(badge); end + + # source://rubocop//lib/rubocop/cop/registry.rb#299 + def resolve_badge(given_badge, real_badge, source_path); end + + # source://rubocop//lib/rubocop/cop/registry.rb#295 + def with(cops); end + + class << self + # source://rubocop//lib/rubocop/cop/registry.rb#22 + def all; end + + # Returns the value of attribute global. + # + # source://rubocop//lib/rubocop/cop/registry.rb#274 + def global; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/registry.rb#44 + def qualified_cop?(name); end + + # source://rubocop//lib/rubocop/cop/registry.rb#26 + def qualified_cop_name(name, origin); end + + # source://rubocop//lib/rubocop/cop/registry.rb#40 + def reset!; end + + # Changes momentarily the global registry + # Intended for testing purposes + # + # source://rubocop//lib/rubocop/cop/registry.rb#32 + def with_temporary_global(temp_global = T.unsafe(nil)); end + end +end + +# Ensure a require statement is present for a standard library determined +# by variable library_name +# +# source://rubocop//lib/rubocop/cop/mixin/require_library.rb#7 +module RuboCop::Cop::RequireLibrary + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#12 + def ensure_required(corrector, node, library_name); end + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#33 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#24 + def remove_subsequent_requires(corrector, node, library_name); end + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#51 + def require_any_library?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#56 + def require_library_name?(param0 = T.unsafe(nil), param1); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#44 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/mixin/require_library.rb#10 +RuboCop::Cop::RequireLibrary::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# This class ensures a require statement is present for a standard library +# determined by the variable library_name +# +# source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#7 +class RuboCop::Cop::RequireLibraryCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#11 + def correct(corrector, node, library_name); end + + # source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#17 + def require_statement(library_name); end + end +end + +# Common functionality for checking `rescue` nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#6 +module RuboCop::Cop::RescueNode + # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#7 + def modifier_locations; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#13 + def rescue_modifier?(node); end + + # @deprecated Use ResbodyNode#exceptions instead + # + # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#20 + def rescued_exceptions(resbody); end +end + +# Common functionality for safe assignment. By safe assignment we mean +# putting parentheses around an assignment to indicate "I know I'm using an +# assignment as a condition. It's not a mistake." +# +# source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#8 +module RuboCop::Cop::SafeAssignment + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#14 + def empty_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#20 + def safe_assignment?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#17 + def setter_method?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#22 + def safe_assignment_allowed?; end +end + +# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#5 +module RuboCop::Cop::Security; end + +# Checks for implementations of the `hash` method which combine +# values using custom logic instead of delegating to `Array#hash`. +# +# Manually combining hashes is error prone and hard to follow, especially +# when there are many values. Poor implementations may also introduce +# performance or security concerns if they are prone to collisions. +# Delegating to `Array#hash` is clearer and safer, although it might be slower +# depending on the use case. +# +# @example +# +# # bad +# def hash +# @foo ^ @bar +# end +# +# # good +# def hash +# [@foo, @bar].hash +# end +# +# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#30 +class RuboCop::Cop::Security::CompoundHash < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#58 + def bad_hash_combinator?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#75 + def contained_in_hash_method?(node, &block); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#42 + def dynamic_hash_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#37 + def hash_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#63 + def monuple_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#87 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#87 + def on_send(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#81 + def outer_bad_hash_combinator?(node); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#68 + def redundant_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#51 + def static_hash_method_definition?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#31 +RuboCop::Cop::Security::CompoundHash::COMBINATOR_IN_HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#32 +RuboCop::Cop::Security::CompoundHash::MONUPLE_HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#34 +RuboCop::Cop::Security::CompoundHash::REDUNDANT_HASH_MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of `Kernel#eval` and `Binding#eval`. +# +# @example +# +# # bad +# +# eval(something) +# binding.eval(something) +# +# source://rubocop//lib/rubocop/cop/security/eval.rb#14 +class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/security/eval.rb#19 + def eval?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/eval.rb#23 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/security/eval.rb#15 +RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/eval.rb#16 +RuboCop::Cop::Security::Eval::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`, +# `IO.foreach`, and `IO.readlines`. +# +# If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class, +# a subprocess is created in the same way as `Kernel#open`, and its output is returned. +# `Kernel#open` may allow unintentional command injection, which is the reason these +# `IO` methods are a security risk. +# Consider to use `File.read` to disable the behavior of subprocess invocation. +# +# @example +# +# # bad +# IO.read(path) +# IO.read('path') +# +# # good +# File.read(path) +# File.read('path') +# IO.read('| command') # Allow intentional command invocation. +# +# source://rubocop//lib/rubocop/cop/security/io_methods.rb#30 +class RuboCop::Cop::Security::IoMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/security/io_methods.rb#36 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/security/io_methods.rb#33 +RuboCop::Cop::Security::IoMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/io_methods.rb#34 +RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of JSON class methods which have potential +# security issues. +# +# @example +# # bad +# JSON.load("{}") +# JSON.restore("{}") +# +# # good +# JSON.parse("{}") +# +# source://rubocop//lib/rubocop/cop/security/json_load.rb#26 +class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/security/json_load.rb#33 + def json_load(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/json_load.rb#37 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/security/json_load.rb#29 +RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/json_load.rb#30 +RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of Marshal class methods which have +# potential security issues leading to remote code execution when +# loading from an untrusted source. +# +# @example +# # bad +# Marshal.load("{}") +# Marshal.restore("{}") +# +# # good +# Marshal.dump("{}") +# +# # okish - deep copy hack +# Marshal.load(Marshal.dump({})) +# +# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#21 +class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/security/marshal_load.rb#26 + def marshal_load(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/security/marshal_load.rb#31 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#22 +RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#23 +RuboCop::Cop::Security::MarshalLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of `Kernel#open` and `URI.open` with dynamic +# data. +# +# `Kernel#open` and `URI.open` enable not only file access but also process +# invocation by prefixing a pipe symbol (e.g., `open("| ls")`). +# So, it may lead to a serious security risk by using variable input to +# the argument of `Kernel#open` and `URI.open`. It would be better to use +# `File.open`, `IO.popen` or `URI.parse#open` explicitly. +# +# NOTE: `open` and `URI.open` with literal strings are not flagged by this +# cop. +# +# @example +# # bad +# open(something) +# open("| #{something}") +# URI.open(something) +# +# # good +# File.open(something) +# IO.popen(something) +# URI.parse(something).open +# +# # good (literal strings) +# open("foo.text") +# open("| foo") +# URI.open("http://example.com") +# +# source://rubocop//lib/rubocop/cop/security/open.rb#37 +class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/security/open.rb#46 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/security/open.rb#42 + def open?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#75 + def composite_string?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#83 + def concatenated_string?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#79 + def interpolated_string?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#57 + def safe?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#67 + def safe_argument?(argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/security/open.rb#71 + def simple_string?(node); end +end + +# source://rubocop//lib/rubocop/cop/security/open.rb#38 +RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/open.rb#39 +RuboCop::Cop::Security::Open::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of YAML class methods which have +# potential security issues leading to remote code execution when +# loading from an untrusted source. +# +# NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default. +# +# @example +# # bad +# YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default +# +# # good +# YAML.safe_load("--- !ruby/object:Foo {}", [Foo]) # Ruby 2.5 (Psych 3) +# YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3) +# YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.1+ (Psych 4) +# YAML.dump(foo) +# +# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#26 +class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/security/yaml_load.rb#37 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/security/yaml_load.rb#33 + def yaml_load(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#29 +RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#30 +RuboCop::Cop::Security::YAMLLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Severity class is simple value object about severity +# +# source://rubocop//lib/rubocop/cop/severity.rb#6 +class RuboCop::Cop::Severity + include ::Comparable + + # @api private + # @raise [ArgumentError] + # @return [Severity] a new instance of Severity + # + # source://rubocop//lib/rubocop/cop/severity.rb#30 + def initialize(name_or_code); end + + # source://rubocop//lib/rubocop/cop/severity.rb#62 + def <=>(other); end + + # source://rubocop//lib/rubocop/cop/severity.rb#50 + def ==(other); end + + # source://rubocop//lib/rubocop/cop/severity.rb#42 + def code; end + + # source://rubocop//lib/rubocop/cop/severity.rb#58 + def hash; end + + # source://rubocop//lib/rubocop/cop/severity.rb#46 + def level; end + + # @api public + # @return [Symbol] severity. + # any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`. + # + # source://rubocop//lib/rubocop/cop/severity.rb#22 + def name; end + + # source://rubocop//lib/rubocop/cop/severity.rb#38 + def to_s; end + + class << self + # source://rubocop//lib/rubocop/cop/severity.rb#24 + def name_from_code(code); end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/severity.rb#12 +RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/severity.rb#9 +RuboCop::Cop::Severity::NAMES = T.let(T.unsafe(nil), Array) + +# Common functionality for cops checking for missing space after +# punctuation. +# +# source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#7 +module RuboCop::Cop::SpaceAfterPunctuation + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#10 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#38 + def allowed_type?(token); end + + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#20 + def each_missing_space(tokens); end + + # The normal offset, i.e., the distance from the punctuation + # token where a space should be, is 1. + # + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#49 + def offset; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#42 + def space_forbidden_before_rcurly?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#30 + def space_missing?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#34 + def space_required_before?(token); end +end + +# source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#8 +RuboCop::Cop::SpaceAfterPunctuation::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for cops checking for space before +# punctuation. +# +# source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#7 +module RuboCop::Cop::SpaceBeforePunctuation + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#12 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#22 + def each_missing_space(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#34 + def space_missing?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#38 + def space_required_after?(token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#42 + def space_required_after_lcurly?; end +end + +# source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#10 +RuboCop::Cop::SpaceBeforePunctuation::MSG = T.let(T.unsafe(nil), String) + +# This autocorrects whitespace +# +# source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#6 +class RuboCop::Cop::SpaceCorrector + extend ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::SurroundingSpace + + class << self + # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#36 + def add_space(processed_source, corrector, left_token, right_token); end + + # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#12 + def empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#10 + def processed_source; end + + # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#24 + def remove_space(processed_source, corrector, left_token, right_token); end + end +end + +# Common functionality for modifier cops. +# +# source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#6 +module RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + + private + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#79 + def code_after(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#103 + def comment_disables_cop?(comment); end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#71 + def first_line_comment(node); end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#58 + def if_body_source(if_body); end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#44 + def length_in_modifier_form(node); end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#97 + def max_line_length; end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#67 + def method_source(if_body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#38 + def modifier_fits_on_single_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#27 + def non_eligible_body?(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#34 + def non_eligible_condition?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#20 + def non_eligible_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#85 + def parenthesize?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#12 + def single_line_as_modifier?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#51 + def to_modifier_form(node); end +end + +# Classes that include this module just implement functions to determine +# what is an offense and how to do autocorrection. They get help with +# adding offenses for the faulty string nodes, and with filtering out +# nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/string_help.rb#9 +module RuboCop::Cop::StringHelp + # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#26 + def on_regexp(node); end + + # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#10 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#32 + def inside_interpolation?(node); end +end + +# This autocorrects string literals +# +# source://rubocop//lib/rubocop/cop/correctors/string_literal_corrector.rb#6 +class RuboCop::Cop::StringLiteralCorrector + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + class << self + # source://rubocop//lib/rubocop/cop/correctors/string_literal_corrector.rb#10 + def correct(corrector, node, style); end + end +end + +# Common functionality for cops checking single/double quotes. +# +# source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#6 +module RuboCop::Cop::StringLiteralsHelp + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#9 + def wrong_quotes?(src_or_node); end +end + +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#5 +module RuboCop::Cop::Style; end + +# Access modifiers should be declared to apply to a group of methods +# or inline before each method, depending on configuration. +# EnforcedStyle config covers only method definitions. +# Applications of visibility methods to symbols can be controlled +# using AllowModifiersOnSymbols config. +# +# @example EnforcedStyle: group (default) +# # bad +# class Foo +# +# private def bar; end +# private def baz; end +# +# end +# +# # good +# class Foo +# +# private +# +# def bar; end +# def baz; end +# +# end +# @example EnforcedStyle: inline +# # bad +# class Foo +# +# private +# +# def bar; end +# def baz; end +# +# end +# +# # good +# class Foo +# +# private def bar; end +# private def baz; end +# +# end +# @example AllowModifiersOnSymbols: true (default) +# # good +# class Foo +# +# private :bar, :baz +# +# end +# @example AllowModifiersOnSymbols: false +# # bad +# class Foo +# +# private :bar, :baz +# +# end +# +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#70 +class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#91 + def access_modifier_with_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#95 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#145 + def access_modifier_is_inlined?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#149 + def access_modifier_is_not_inlined?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#127 + def allow_modifiers_on_symbols?(node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#112 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#219 + def def_source(node, def_node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#180 + def find_argument_less_modifier_node(node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#169 + def find_corresponding_def_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#137 + def group_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#141 + def inline_style?; end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#211 + def insert_inline_modifier(corrector, node, modifier_name); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#159 + def message(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#131 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#215 + def remove_node(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#194 + def replace_def(corrector, node, def_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#153 + def right_siblings_same_inline_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#188 + def select_grouped_def_nodes(node); end +end + +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#88 +RuboCop::Cop::Style::AccessModifierDeclarations::ALLOWED_NODE_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#76 +RuboCop::Cop::Style::AccessModifierDeclarations::GROUP_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#81 +RuboCop::Cop::Style::AccessModifierDeclarations::INLINE_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#86 +RuboCop::Cop::Style::AccessModifierDeclarations::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for grouping of accessors in `class` and `module` bodies. +# By default it enforces accessors to be placed in grouped declarations, +# but it can be configured to enforce separating them in multiple declarations. +# +# NOTE: If there is a method call before the accessor method it is always allowed +# as it might be intended like Sorbet. +# +# @example EnforcedStyle: grouped (default) +# # bad +# class Foo +# attr_reader :bar +# attr_reader :bax +# attr_reader :baz +# end +# +# # good +# class Foo +# attr_reader :bar, :bax, :baz +# end +# +# # good +# class Foo +# # may be intended comment for bar. +# attr_reader :bar +# +# sig { returns(String) } +# attr_reader :bax +# +# may_be_intended_annotation :baz +# attr_reader :baz +# end +# @example EnforcedStyle: separated +# # bad +# class Foo +# attr_reader :bar, :baz +# end +# +# # good +# class Foo +# attr_reader :bar +# attr_reader :baz +# end +# +# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#50 +class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#59 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#59 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#59 + def on_sclass(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#82 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#71 + def check(send_node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#114 + def class_send_elements(class_node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#157 + def group_accessors(node, accessors); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#96 + def groupable_accessor?(node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#134 + def groupable_sibling_accessors(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#126 + def grouped_style?; end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#143 + def message(send_node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#148 + def preferred_accessors(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#91 + def previous_line_comment?(node); end + + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#163 + def separate_accessors(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#130 + def separated_style?; end +end + +# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#56 +RuboCop::Cop::Style::AccessorGrouping::GROUPED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#57 +RuboCop::Cop::Style::AccessorGrouping::SEPARATED_MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of either `#alias` or `#alias_method` +# depending on configuration. +# It also flags uses of `alias :symbol` rather than `alias bareword`. +# +# However, it will always enforce `method_alias` when used `alias` +# in an instance method definition and in a singleton method definition. +# If used in a block, always enforce `alias_method` +# unless it is an `instance_eval` block. +# +# @example EnforcedStyle: prefer_alias (default) +# # bad +# alias_method :bar, :foo +# alias :bar :foo +# +# # good +# alias bar foo +# @example EnforcedStyle: prefer_alias_method +# # bad +# alias :bar :foo +# alias bar foo +# +# # good +# alias_method :bar, :foo +# +# source://rubocop//lib/rubocop/cop/style/alias.rb#31 +class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/alias.rb#51 + def on_alias(node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#41 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/alias.rb#85 + def add_offense_for_args(node, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/alias.rb#75 + def alias_keyword_possible?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/alias.rb#79 + def alias_method_possible?(node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#65 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/alias.rb#124 + def bareword?(sym_node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#128 + def correct_alias_method_to_alias(corrector, send_node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#135 + def correct_alias_to_alias_method(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#142 + def correct_alias_with_symbol_args(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#147 + def identifier(node); end + + # source://rubocop//lib/rubocop/cop/style/alias.rb#113 + def lexical_scope_type(node); end + + # In this expression, will `self` be the same as the innermost enclosing + # class or module block (:lexical)? Or will it be something else + # (:dynamic)? If we're in an instance_eval block, return that. + # + # source://rubocop//lib/rubocop/cop/style/alias.rb#96 + def scope_type(node); end +end + +# source://rubocop//lib/rubocop/cop/style/alias.rb#35 +RuboCop::Cop::Style::Alias::MSG_ALIAS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/alias.rb#36 +RuboCop::Cop::Style::Alias::MSG_ALIAS_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/alias.rb#37 +RuboCop::Cop::Style::Alias::MSG_SYMBOL_ARGS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/alias.rb#39 +RuboCop::Cop::Style::Alias::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `and` and `or`, and suggests using `&&` and +# `||` instead. It can be configured to check only in conditions or in +# all contexts. +# +# @example EnforcedStyle: conditionals (default) +# # bad +# if foo and bar +# end +# +# # good +# foo.save && return +# +# # good +# foo.save and return +# +# # good +# if foo && bar +# end +# @example EnforcedStyle: always +# # bad +# foo.save and return +# +# # bad +# if foo and bar +# end +# +# # good +# foo.save && return +# +# # good +# if foo && bar +# end +# +# source://rubocop//lib/rubocop/cop/style/and_or.rb#44 +class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#51 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#56 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#51 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#56 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#56 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#56 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#56 + def on_while_post(node); end + + private + + # ! is a special case: + # 'x and !obj.method arg' can be autocorrected if we + # recurse down a level and add parens to 'obj.method arg' + # however, 'not x' also parses as (send x :!) + # + # source://rubocop//lib/rubocop/cop/style/and_or.rb#117 + def correct_not(node, receiver, corrector); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#129 + def correct_other(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#95 + def correct_send(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#108 + def correct_setter(node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/and_or.rb#143 + def correctable_send?(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#135 + def keep_operator_precedence(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#91 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#85 + def on_conditionals(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#66 + def process_logical_operator(node); end + + # source://rubocop//lib/rubocop/cop/style/and_or.rb#147 + def whitespace_before_arg(node); end +end + +# source://rubocop//lib/rubocop/cop/style/and_or.rb#49 +RuboCop::Cop::Style::AndOr::MSG = T.let(T.unsafe(nil), String) + +# In Ruby 2.7, arguments forwarding has been added. +# +# This cop identifies places where `do_something(*args, &block)` +# can be replaced by `do_something(...)`. +# +# In Ruby 3.2, anonymous args/kwargs forwarding has been added. +# +# This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be +# replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled +# by setting `UseAnonymousForwarding: false`. +# +# And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`, +# and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names +# that are sufficient for anonymizing meaningless naming. +# +# Meaningless names that are commonly used can be anonymized by default: +# e.g., `*args`, `**options`, `&block`, and so on. +# +# Names not on this list are likely to be meaningful and are allowed by default. +# +# @example +# # bad +# def foo(*args, &block) +# bar(*args, &block) +# end +# +# # bad +# def foo(*args, **kwargs, &block) +# bar(*args, **kwargs, &block) +# end +# +# # good +# def foo(...) +# bar(...) +# end +# @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2) +# # bad +# def foo(*args, **kwargs) +# args_only(*args) +# kwargs_only(**kwargs) +# end +# +# # good +# def foo(*, **) +# args_only(*) +# kwargs_only(**) +# end +# @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2) +# # good +# def foo(*args, **kwargs) +# args_only(*args) +# kwargs_only(**kwargs) +# end +# @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2) +# # good +# def foo(*args) +# bar(*args) +# end +# +# def foo(**kwargs) +# bar(**kwargs) +# end +# @example AllowOnlyRestArgument: false (only relevant for Ruby < 3.2) +# # bad +# # The following code can replace the arguments with `...`, +# # but it will change the behavior. Because `...` forwards block also. +# def foo(*args) +# bar(*args) +# end +# +# def foo(**kwargs) +# bar(**kwargs) +# end +# @example RedundantRestArgumentNames: ['args', 'arguments'] (default) +# # bad +# def foo(*args) +# bar(*args) +# end +# +# # good +# def foo(*) +# bar(*) +# end +# @example RedundantKeywordRestArgumentNames: ['kwargs', 'options', 'opts'] (default) +# # bad +# def foo(**kwargs) +# bar(**kwargs) +# end +# +# # good +# def foo(**) +# bar(**) +# end +# @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default) +# # bad +# def foo(&block) +# bar(&block) +# end +# +# # good +# def foo(&) +# bar(&) +# end +# +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#116 +class RuboCop::Cop::Style::ArgumentsForwarding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#134 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#134 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#174 + def add_forward_all_offenses(node, send_classifications, forwardable_args); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#295 + def add_parens_if_missing(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#183 + def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#287 + def allow_only_rest_arguments?; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#279 + def arguments_range(node, first_node); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#226 + def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#211 + def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#158 + def extract_forwardable_args(args); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#201 + def non_splat_or_block_pass_lvar_references(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#170 + def only_forwards_all?(send_classifications); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#162 + def redundant_forwardable_named_args(restarg, kwrestarg, blockarg); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#243 + def redundant_named_arg(arg, config_name, keyword); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#269 + def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#253 + def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#261 + def register_forward_kwargs_offense(add_parens, def_arguments_or_send, kwrest_arg_or_splat); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#291 + def use_anonymous_forwarding?; end + + class << self + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#130 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#124 +RuboCop::Cop::Style::ArgumentsForwarding::ADDITIONAL_ARG_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#127 +RuboCop::Cop::Style::ArgumentsForwarding::ARGS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#123 +RuboCop::Cop::Style::ArgumentsForwarding::FORWARDING_LVAR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#126 +RuboCop::Cop::Style::ArgumentsForwarding::FORWARDING_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#128 +RuboCop::Cop::Style::ArgumentsForwarding::KWARGS_MSG = T.let(T.unsafe(nil), String) + +# Classifies send nodes for possible rest/kwrest/all (including block) forwarding. +# +# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#302 +class RuboCop::Cop::Style::ArgumentsForwarding::SendNodeClassifier + extend ::RuboCop::AST::NodePattern::Macros + + # @return [SendNodeClassifier] a new instance of SendNodeClassifier + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#314 + def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#342 + def classification; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#309 + def extract_forwarded_kwrest_arg(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#336 + def forwarded_block_arg; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#312 + def forwarded_block_arg?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#330 + def forwarded_kwrest_arg; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#324 + def forwarded_rest_arg; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#306 + def forwarded_rest_arg?(param0 = T.unsafe(nil), param1); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#410 + def additional_kwargs?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#406 + def additional_kwargs_or_forwarded_kwargs?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#420 + def allow_offense_for_no_block?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#391 + def any_arg_referenced?; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#375 + def arguments; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#354 + def can_forward_all?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#414 + def forward_additional_kwargs?; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#371 + def forwarded_rest_and_kwrest_args; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#424 + def no_additional_args?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#399 + def no_post_splat_args?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#367 + def offensive_block_forwarding?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#387 + def referenced_block_arg?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#383 + def referenced_kwrest_arg?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#379 + def referenced_rest_arg?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#363 + def ruby_32_missing_rest_or_kwest?; end + + # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#395 + def target_ruby_version; end +end + +# Enforces the use of `Array()` instead of explicit `Array` check or `[*var]`. +# +# The cop is disabled by default due to safety concerns. +# +# @example +# # bad +# paths = [paths] unless paths.is_a?(Array) +# paths.each { |path| do_something(path) } +# +# # bad (always creates a new Array instance) +# [*paths].each { |path| do_something(path) } +# +# # good (and a bit more readable) +# Array(paths).each { |path| do_something(path) } +# +# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#41 +class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#48 + def array_splat?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#63 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#74 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#53 + def unless_array?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#45 +RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#44 +RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String) + +# Identifies usages of `arr[0]` and `arr[-1]` and suggests to change +# them to use `arr.first` and `arr.instead`. +# +# The cop is disabled by default due to safety concerns. +# +# @example +# # bad +# arr[0] +# arr[-1] +# +# # good +# arr.first +# arr.last +# arr[0] = 2 +# arr[0][-2] +# +# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#28 +class RuboCop::Cop::Style::ArrayFirstLast < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#58 + def brace_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#53 + def innermost_braces_node(node); end +end + +# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#31 +RuboCop::Cop::Style::ArrayFirstLast::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#32 +RuboCop::Cop::Style::ArrayFirstLast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 3.1, `Array#intersect?` has been added. +# +# This cop identifies places where `(array1 & array2).any?` +# can be replaced by `array1.intersect?(array2)`. +# +# The `array1.intersect?(array2)` method is faster than +# `(array1 & array2).any?` and is more readable. +# +# In cases like the following, compatibility is not ensured, +# so it will not be detected when using block argument. +# +# [source,ruby] +# ---- +# ([1] & [1,2]).any? { |x| false } # => false +# [1].intersect?([1,2]) { |x| false } # => true +# ---- +# +# @example +# # bad +# (array1 & array2).any? +# (array1 & array2).empty? +# +# # good +# array1.intersect?(array2) +# !array1.intersect?(array2) +# @example AllCops:ActiveSupportExtensionsEnabled: false (default) +# # good +# (array1 & array2).present? +# (array1 & array2).blank? +# @example AllCops:ActiveSupportExtensionsEnabled: true +# # bad +# (array1 & array2).present? +# (array1 & array2).blank? +# +# # good +# array1.intersect?(array2) +# !array1.intersect?(array2) +# +# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#49 +class RuboCop::Cop::Style::ArrayIntersect < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#65 + def active_support_bad_intersection_check?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#79 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#56 + def regular_bad_intersection_check?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#94 + def bad_intersection_check?(node); end + + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#106 + def message(receiver, argument, method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#102 + def straight?(method_name); end +end + +# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#73 +RuboCop::Cop::Style::ArrayIntersect::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#76 +RuboCop::Cop::Style::ArrayIntersect::NEGATED_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#77 +RuboCop::Cop::Style::ArrayIntersect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#75 +RuboCop::Cop::Style::ArrayIntersect::STRAIGHT_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for uses of "*" as a substitute for _join_. +# +# Not all cases can reliably checked, due to Ruby's dynamic +# types, so we consider only cases when the first argument is an +# array literal or the second is a string literal. +# +# @example +# +# # bad +# %w(foo bar baz) * "," +# +# # good +# %w(foo bar baz).join(",") +# +# source://rubocop//lib/rubocop/cop/style/array_join.rb#20 +class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/array_join.rb#27 + def join_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/array_join.rb#29 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/array_join.rb#23 +RuboCop::Cop::Style::ArrayJoin::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/array_join.rb#24 +RuboCop::Cop::Style::ArrayJoin::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#16 +class RuboCop::Cop::Style::AsciiComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#21 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#51 + def allowed_non_ascii_chars; end + + # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#42 + def first_non_ascii_chars(string); end + + # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#32 + def first_offense_range(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#46 + def only_allowed_non_ascii_chars?(string); end +end + +# source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#19 +RuboCop::Cop::Style::AsciiComments::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of Module#attr. +# +# @example +# # bad - creates a single attribute accessor (deprecated in Ruby 1.9) +# attr :something, true +# attr :one, :two, :three # behaves as attr_reader +# +# # good +# attr_accessor :something +# attr_reader :one, :two, :three +# +# source://rubocop//lib/rubocop/cop/style/attr.rb#17 +class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/attr.rb#74 + def class_eval?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/attr.rb#37 + def allowed_context?(node); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#47 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/attr.rb#43 + def define_attr_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#59 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/attr.rb#63 + def replacement_method(node); end +end + +# source://rubocop//lib/rubocop/cop/style/attr.rb#21 +RuboCop::Cop::Style::Attr::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/attr.rb#22 +RuboCop::Cop::Style::Attr::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for cases when you could use a block +# accepting version of a method that does automatic +# resource cleanup. +# +# @example +# +# # bad +# f = File.open('file') +# +# # good +# File.open('file') do |f| +# # ... +# end +# +# # bad +# f = Tempfile.open('temp') +# +# # good +# Tempfile.open('temp') do |f| +# # ... +# end +# +# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#27 +class RuboCop::Cop::Style::AutoResourceCleanup < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#32 + def file_open_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#36 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#46 + def cleanup?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#28 +RuboCop::Cop::Style::AutoResourceCleanup::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#29 +RuboCop::Cop::Style::AutoResourceCleanup::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks if usage of %() or %Q() matches configuration. +# +# @example EnforcedStyle: bare_percent (default) +# # bad +# %Q(He said: "#{greeting}") +# %q{She said: 'Hi'} +# +# # good +# %(He said: "#{greeting}") +# %{She said: 'Hi'} +# @example EnforcedStyle: percent_q +# # bad +# %|He said: "#{greeting}"| +# %/She said: 'Hi'/ +# +# # good +# %Q|He said: "#{greeting}"| +# %q/She said: 'Hi'/ +# +# source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#26 +class RuboCop::Cop::Style::BarePercentLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#32 + def on_dstr(node); end + + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#36 + def on_str(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#63 + def add_offense_for_wrong_style(node, good, bad); end + + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#42 + def check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#59 + def requires_bare_percent?(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#55 + def requires_percent_q?(source); end +end + +# source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#30 +RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String) + +# Checks for BEGIN blocks. +# +# @example +# # bad +# BEGIN { test } +# +# source://rubocop//lib/rubocop/cop/style/begin_block.rb#12 +class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/begin_block.rb#15 + def on_preexe(node); end +end + +# source://rubocop//lib/rubocop/cop/style/begin_block.rb#13 +RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where `attr_reader` and `attr_writer` +# for the same method can be combined into single `attr_accessor`. +# +# @example +# # bad +# class Foo +# attr_reader :bar +# attr_writer :bar +# end +# +# # good +# class Foo +# attr_accessor :bar +# end +# +# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#21 +class RuboCop::Cop::Style::BisectedAttrAccessor < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55 + def after_class(class_node); end + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55 + def after_module(class_node); end + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55 + def after_sclass(class_node); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33 + def on_class(class_node); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33 + def on_module(class_node); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#29 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33 + def on_sclass(class_node); end + + private + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#102 + def correct_reader(corrector, macro, node, range); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#114 + def correct_writer(corrector, macro, node, range); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#91 + def find_bisection(macros); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#74 + def find_macros(class_def); end + + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#98 + def register_offense(attr); end +end + +# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#27 +RuboCop::Cop::Style::BisectedAttrAccessor::MSG = T.let(T.unsafe(nil), String) + +# Representation of an `attr_reader`, `attr_writer` or `attr` macro +# for use by `Style/BisectedAttrAccessor`. +# +# @api private +# +# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#10 +class RuboCop::Cop::Style::BisectedAttrAccessor::Macro + include ::RuboCop::Cop::VisibilityHelp + + # @api private + # @return [Macro] a new instance of Macro + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#19 + def initialize(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#49 + def all_bisected?; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#29 + def attr_names; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13 + def attrs; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#25 + def bisect(*names); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#33 + def bisected_names; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13 + def bisection; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13 + def node; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#41 + def reader?; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#53 + def rest; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#37 + def visibility; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#45 + def writer?; end + + class << self + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#15 + def macro?(node); end + end +end + +# Looks for uses of block comments (=begin...=end). +# +# @example +# # bad +# =begin +# Multiple lines +# of comments... +# =end +# +# # good +# # Multiple lines +# # of comments... +# +# source://rubocop//lib/rubocop/cop/style/block_comments.rb#19 +class RuboCop::Cop::Style::BlockComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/block_comments.rb#27 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/block_comments.rb#56 + def eq_end_part(comment, expr); end + + # source://rubocop//lib/rubocop/cop/style/block_comments.rb#48 + def parts(comment); end +end + +# source://rubocop//lib/rubocop/cop/style/block_comments.rb#24 +RuboCop::Cop::Style::BlockComments::BEGIN_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/style/block_comments.rb#25 +RuboCop::Cop::Style::BlockComments::END_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/style/block_comments.rb#23 +RuboCop::Cop::Style::BlockComments::MSG = T.let(T.unsafe(nil), String) + +# Check for uses of braces or do/end around single line or +# multi-line blocks. +# +# Methods that can be either procedural or functional and cannot be +# categorised from their usage alone is ignored. +# `lambda`, `proc`, and `it` are their defaults. +# Additional methods can be added to the `AllowedMethods`. +# +# @example EnforcedStyle: line_count_based (default) +# # bad - single line block +# items.each do |item| item / 5 end +# +# # good - single line block +# items.each { |item| item / 5 } +# +# # bad - multi-line block +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# +# # good - multi-line block +# things.map do |thing| +# something = thing.some_method +# process(something) +# end +# @example EnforcedStyle: semantic +# # Prefer `do...end` over `{...}` for procedural blocks. +# +# # return value is used/assigned +# # bad +# foo = map do |x| +# x +# end +# puts (map do |x| +# x +# end) +# +# # return value is not used out of scope +# # good +# map do |x| +# x +# end +# +# # Prefer `{...}` over `do...end` for functional blocks. +# +# # return value is not used out of scope +# # bad +# each { |x| +# x +# } +# +# # return value is used/assigned +# # good +# foo = map { |x| +# x +# } +# map { |x| +# x +# }.inspect +# +# # The AllowBracesOnProceduralOneLiners option is allowed unless the +# # EnforcedStyle is set to `semantic`. If so: +# +# # If the AllowBracesOnProceduralOneLiners option is unspecified, or +# # set to `false` or any other falsey value, then semantic purity is +# # maintained, so one-line procedural blocks must use do-end, not +# # braces. +# +# # bad +# collection.each { |element| puts element } +# +# # good +# collection.each do |element| puts element end +# +# # If the AllowBracesOnProceduralOneLiners option is set to `true`, or +# # any other truthy value, then one-line procedural blocks may use +# # either style. (There is no setting for requiring braces on them.) +# +# # good +# collection.each { |element| puts element } +# +# # also good +# collection.each do |element| puts element end +# @example EnforcedStyle: braces_for_chaining +# # bad +# words.each do |word| +# word.flip.flop +# end.join("-") +# +# # good +# words.each { |word| +# word.flip.flop +# }.join("-") +# @example EnforcedStyle: always_braces +# # bad +# words.each do |word| +# word.flip.flop +# end +# +# # good +# words.each { |word| +# word.flip.flop +# } +# @example BracesRequiredMethods: ['sig'] +# +# # Methods listed in the BracesRequiredMethods list, such as 'sig' +# # in this example, will require `{...}` braces. This option takes +# # precedence over all other configurations except AllowedMethods. +# +# # bad +# sig do +# params( +# foo: string, +# ).void +# end +# def bar(foo) +# puts foo +# end +# +# # good +# sig { +# params( +# foo: string, +# ).void +# } +# def bar(foo) +# puts foo +# end +# @example AllowedMethods: ['lambda', 'proc', 'it' ] (default) +# +# # good +# foo = lambda do |x| +# puts "Hello, #{x}" +# end +# +# foo = lambda do |x| +# x * 100 +# end +# @example AllowedPatterns: [] (default) +# +# # bad +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# @example AllowedPatterns: ['map'] +# +# # good +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# +# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#168 +class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#194 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#194 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#179 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#459 + def array_or_range?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#208 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#463 + def begin_required?(block_node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#236 + def braces_for_chaining_message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#400 + def braces_for_chaining_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#248 + def braces_required_message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#377 + def braces_required_method?(method_name); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#381 + def braces_required_methods; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#410 + def braces_style?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#455 + def conditional?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#414 + def correction_would_break_code?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#309 + def end_of_chain(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#424 + def functional_block?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#420 + def functional_method?(method_name); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#326 + def get_blocks(node, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#385 + def line_count_based_block_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#218 + def line_count_based_message(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#252 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#300 + def move_comment_before_block(corrector, comment, block_node, closing_brace); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#432 + def procedural_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#428 + def procedural_oneliners_may_have_braces?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#344 + def proper_block_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#316 + def remove_trailing_whitespace(corrector, range, comment); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#263 + def replace_braces_with_do_end(corrector, loc); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#279 + def replace_do_end_with_braces(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#356 + def require_braces?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#448 + def return_value_of_scope?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#436 + def return_value_used?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#389 + def semantic_block_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#226 + def semantic_message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#364 + def special_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#370 + def special_method_proper_block_style?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#296 + def whitespace_after?(range, length = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#292 + def whitespace_before?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#322 + def with_block?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#175 +RuboCop::Cop::Style::BlockDelimiters::ALWAYS_BRACES_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#177 +RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(nil), String) + +# Corrector to correct conditional assignment in `case` statements. +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#605 +class RuboCop::Cop::Style::CaseCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#610 + def correct(corrector, cop, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#620 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#640 + def extract_branches(case_node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#634 + def extract_tail_branches(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#650 + def move_branch_inside_condition(corrector, branch, condition, assignment, column); end + end +end + +# If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of +# the case equality operator is `self.class`. Note intermediate variables are not accepted. +# +# @example +# # bad +# (1..100) === 7 +# /something/ === some_string +# +# # good +# something.is_a?(Array) +# (1..100).include?(7) +# /something/.match?(some_string) +# @example AllowOnConstant: false (default) +# # bad +# Array === something +# @example AllowOnConstant: true +# # good +# Array === something +# @example AllowOnSelfClass: false (default) +# # bad +# self.class === something +# @example AllowOnSelfClass: true +# # good +# self.class === something +# +# source://rubocop//lib/rubocop/cop/style/case_equality.rb#40 +class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#47 + def case_equality?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#52 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#50 + def self_class?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#90 + def begin_replacement(lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#96 + def const_replacement(lhs, rhs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#65 + def offending_receiver?(node); end + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#72 + def replacement(lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/style/case_equality.rb#100 + def send_replacement(lhs, rhs); end +end + +# source://rubocop//lib/rubocop/cop/style/case_equality.rb#43 +RuboCop::Cop::Style::CaseEquality::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/case_equality.rb#44 +RuboCop::Cop::Style::CaseEquality::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `if-elsif` constructions +# can be replaced with `case-when`. +# +# @example MinBranchesCount: 3 (default) +# # bad +# if status == :active +# perform_action +# elsif status == :inactive || status == :hibernating +# check_timeout +# elsif status == :invalid +# report_invalid +# else +# final_action +# end +# +# # good +# case status +# when :active +# perform_action +# when :inactive, :hibernating +# check_timeout +# when :invalid +# report_invalid +# else +# final_action +# end +# @example MinBranchesCount: 4 +# # good +# if status == :active +# perform_action +# elsif status == :inactive || status == :hibernating +# check_timeout +# elsif status == :invalid +# report_invalid +# else +# final_action +# end +# +# source://rubocop//lib/rubocop/cop/style/case_like_if.rb#50 +class RuboCop::Cop::Style::CaseLikeIf < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MinBranchesCount + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#57 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#81 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#231 + def branch_conditions(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#249 + def class_reference?(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#166 + def collect_conditions(node, target, conditions); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#220 + def condition_from_binary_op(lhs, rhs, target); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#202 + def condition_from_equality_node(node, target); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#213 + def condition_from_include_or_cover_node(node, target); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#208 + def condition_from_match_node(node, target); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#185 + def condition_from_send_node(node, target); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#240 + def const_reference?(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#258 + def correction_range(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#253 + def deparenthesize(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#102 + def find_target(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#136 + def find_target_in_equality_node(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#148 + def find_target_in_include_or_cover_node(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#154 + def find_target_in_match_node(node); end + + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#121 + def find_target_in_send_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#274 + def regexp_with_named_captures?(node); end + + # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides) + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#263 + def regexp_with_working_captures?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#96 + def should_check?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/case_like_if.rb#55 +RuboCop::Cop::Style::CaseLikeIf::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the character literal ?x. +# Starting with Ruby 1.9 character literals are +# essentially one-character strings, so this syntax +# is mostly redundant at this point. +# +# ? character literal can be used to express meta and control character. +# That's a good use case of ? literal so it doesn't count it as an offense. +# +# @example +# # bad +# ?x +# +# # good +# 'x' +# +# # good - control & meta escapes +# ?\C-\M-d +# "\C-\M-d" # same as above +# +# source://rubocop//lib/rubocop/cop/style/character_literal.rb#24 +class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/character_literal.rb#35 + def autocorrect(corrector, node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop//lib/rubocop/cop/style/character_literal.rb#53 + def correct_style_detected; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/character_literal.rb#30 + def offense?(node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop//lib/rubocop/cop/style/character_literal.rb#49 + def opposite_style_detected; end +end + +# source://rubocop//lib/rubocop/cop/style/character_literal.rb#28 +RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks the style of children definitions at classes and +# modules. Basically there are two different styles: +# +# The compact style is only forced for classes/modules with one child. +# +# @example EnforcedStyle: nested (default) +# # good +# # have each child on its own line +# class Foo +# class Bar +# end +# end +# @example EnforcedStyle: compact +# # good +# # combine definitions as much as possible +# class Foo::Bar +# end +# +# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#33 +class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#42 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#48 + def on_module(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#89 + def add_trailing_end(corrector, node, padding); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#170 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#159 + def check_compact_style(node, body); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#151 + def check_nested_style(node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#141 + def check_style(node, body); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#94 + def compact_definition(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#115 + def compact_identifier_name(node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#100 + def compact_node(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#180 + def compact_node_name?(node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#105 + def compact_replacement(node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#137 + def leading_spaces(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#176 + def needs_compacting?(body); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#62 + def nest_definition(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#54 + def nest_or_compact(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#120 + def remove_end(corrector, body); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#71 + def replace_namespace_keyword(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#80 + def split_on_double_colon(corrector, node, padding); end + + # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#128 + def unindent(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#40 +RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#39 +RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String) + +# Enforces consistent use of `Object#is_a?` or `Object#kind_of?`. +# +# @example EnforcedStyle: is_a? (default) +# # bad +# var.kind_of?(Date) +# var.kind_of?(Integer) +# +# # good +# var.is_a?(Date) +# var.is_a?(Integer) +# @example EnforcedStyle: kind_of? +# # bad +# var.is_a?(Time) +# var.is_a?(String) +# +# # good +# var.kind_of?(Time) +# var.kind_of?(String) +# +# source://rubocop//lib/rubocop/cop/style/class_check.rb#26 +class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/class_check.rb#44 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/class_check.rb#33 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_check.rb#30 +RuboCop::Cop::Style::ClassCheck::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/class_check.rb#31 +RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of `Object#instance_of?` instead of class comparison +# for equality. +# `==`, `equal?`, and `eql?` custom method definitions are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# var.class == Date +# var.class.equal?(Date) +# var.class.eql?(Date) +# var.class.name == 'Date' +# +# # good +# var.instance_of?(Date) +# @example AllowedMethods: ['==', 'equal?', 'eql?'] (default) +# # good +# def ==(other) +# self.class == other.class && name == other.name +# end +# +# def equal?(other) +# self.class.equal?(other.class) && name.equal?(other.name) +# end +# +# def eql?(other) +# self.class.eql?(other.class) && name.eql?(other.name) +# end +# @example AllowedPatterns: [] (default) +# # bad +# def eq(other) +# self.class.eq(other.class) && name.eq(other.name) +# end +# @example AllowedPatterns: ['eq'] +# # good +# def eq(other) +# self.class.eq(other.class) && name.eq(other.name) +# end +# +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#52 +class RuboCop::Cop::Style::ClassEqualityComparison < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#64 + def class_comparison_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#70 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#92 + def class_name(class_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#112 + def class_name_method?(method_name); end + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#128 + def offense_range(receiver_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#116 + def require_cbase?(class_node); end + + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#124 + def trim_string_quotes(class_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#120 + def unable_to_determine_type?(class_node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#61 +RuboCop::Cop::Style::ClassEqualityComparison::CLASS_NAME_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#58 +RuboCop::Cop::Style::ClassEqualityComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#60 +RuboCop::Cop::Style::ClassEqualityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of the class/module name instead of +# self, when defining class/module methods. +# +# @example +# # bad +# class SomeClass +# def SomeClass.class_method +# # ... +# end +# end +# +# # good +# class SomeClass +# def self.class_method +# # ... +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/class_methods.rb#23 +class RuboCop::Cop::Style::ClassMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/class_methods.rb#28 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/class_methods.rb#28 + def on_module(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/class_methods.rb#41 + def check_defs(name, node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_methods.rb#26 +RuboCop::Cop::Style::ClassMethods::MSG = T.let(T.unsafe(nil), String) + +# Enforces using `def self.method_name` or `class << self` to define class methods. +# +# @example EnforcedStyle: def_self (default) +# # bad +# class SomeClass +# class << self +# attr_accessor :class_accessor +# +# def class_method +# # ... +# end +# end +# end +# +# # good +# class SomeClass +# def self.class_method +# # ... +# end +# +# class << self +# attr_accessor :class_accessor +# end +# end +# +# # good - contains private method +# class SomeClass +# class << self +# attr_accessor :class_accessor +# +# private +# +# def private_class_method +# # ... +# end +# end +# end +# @example EnforcedStyle: self_class +# # bad +# class SomeClass +# def self.class_method +# # ... +# end +# end +# +# # good +# class SomeClass +# class << self +# def class_method +# # ... +# end +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#61 +class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#81 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#71 + def on_sclass(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#95 + def all_methods_public?(sclass_node); end + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#115 + def autocorrect_sclass(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#102 + def def_nodes(sclass_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#91 + def def_self_style?; end + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#141 + def extract_def_from_sclass(def_node, sclass_node); end + + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#152 + def indentation_diff(node1, node2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#137 + def sclass_only_has_methods?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#68 +RuboCop::Cop::Style::ClassMethodsDefinitions::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#69 +RuboCop::Cop::Style::ClassMethodsDefinitions::MSG_SCLASS = T.let(T.unsafe(nil), String) + +# Checks for uses of class variables. Offenses +# are signaled only on assignment to class variables to +# reduce the number of offenses that would be reported. +# +# You have to be careful when setting a value for a class +# variable; if a class has been inherited, changing the +# value of a class variable also affects the inheriting +# classes. This means that it's almost always better to +# use a class instance variable instead. +# +# @example +# # bad +# class A +# @@test = 10 +# end +# +# class A +# def self.test(name, value) +# class_variable_set("@@#{name}", value) +# end +# end +# +# class A; end +# A.class_variable_set(:@@test, 10) +# +# # good +# class A +# @test = 10 +# end +# +# class A +# def test +# @@test # you can access class variable without offense +# end +# end +# +# class A +# def self.test(name) +# class_variable_get("@@#{name}") # you can access without offense +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/class_vars.rb#48 +class RuboCop::Cop::Style::ClassVars < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/class_vars.rb#52 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/class_vars.rb#56 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/class_vars.rb#49 +RuboCop::Cop::Style::ClassVars::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/class_vars.rb#50 +RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where custom logic on rejection nils from arrays +# and hashes can be replaced with `{Array,Hash}#{compact,compact!}`. +# +# @example +# # bad +# array.reject(&:nil?) +# array.delete_if(&:nil?) +# array.reject { |e| e.nil? } +# array.delete_if { |e| e.nil? } +# array.select { |e| !e.nil? } +# +# # good +# array.compact +# +# # bad +# hash.reject!(&:nil?) +# hash.reject! { |k, v| v.nil? } +# hash.select! { |k, v| !v.nil? } +# +# # good +# hash.compact! +# @example AllowedReceivers: ['params'] +# # good +# params.reject(&:nil?) +# +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#42 +class RuboCop::Cop::Style::CollectionCompact < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedReceivers + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#82 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#62 + def reject_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#55 + def reject_method_with_block_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#72 + def select_method?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#119 + def good_method_name(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#97 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#127 + def range(begin_pos_node, end_pos_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#113 + def to_enum_method?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#48 +RuboCop::Cop::Style::CollectionCompact::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#49 +RuboCop::Cop::Style::CollectionCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#50 +RuboCop::Cop::Style::CollectionCompact::TO_ENUM_METHODS = T.let(T.unsafe(nil), Array) + +# Enforces the use of consistent method names +# from the Enumerable module. +# +# You can customize the mapping from undesired method to desired method. +# +# e.g. to use `detect` over `find`: +# +# Style/CollectionMethods: +# PreferredMethods: +# find: detect +# +# @example +# # These examples are based on the default mapping for `PreferredMethods`. +# +# # bad +# items.collect +# items.collect! +# items.collect_concat +# items.inject +# items.detect +# items.find_all +# items.member? +# +# # good +# items.map +# items.map! +# items.flat_map +# items.reduce +# items.find +# items.select +# items.include? +# +# source://rubocop//lib/rubocop/cop/style/collection_methods.rb#43 +class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#49 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#49 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#55 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#63 + def check_method_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#72 + def implicit_block?(node); end + + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#80 + def message(node); end + + # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead + # of a block. + # + # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#86 + def methods_accepting_symbol; end +end + +# source://rubocop//lib/rubocop/cop/style/collection_methods.rb#47 +RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String) + +# Checks for methods invoked via the `::` operator instead +# of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`). +# +# @example +# # bad +# Timeout::timeout(500) { do_something } +# FileUtils::rmdir(dir) +# Marshal::dump(obj) +# +# # good +# Timeout.timeout(500) { do_something } +# FileUtils.rmdir(dir) +# Marshal.dump(obj) +# +# source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#20 +class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#26 + def java_type_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#35 + def on_send(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#23 +RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String) + +# Checks for class methods that are defined using the `::` +# operator instead of the `.` operator. +# +# @example +# # bad +# class Foo +# def self::bar +# end +# end +# +# # good +# class Foo +# def self.bar +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#22 +class RuboCop::Cop::Style::ColonMethodDefinition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#27 + def on_defs(node); end +end + +# source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#25 +RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where multiple consecutive loops over the same data +# can be combined into a single loop. It is very likely that combining them +# will make the code more efficient and more concise. +# +# @example +# # bad +# def method +# items.each do |item| +# do_something(item) +# end +# +# items.each do |item| +# do_something_else(item) +# end +# end +# +# # good +# def method +# items.each do |item| +# do_something(item) +# do_something_else(item) +# end +# end +# +# # bad +# def method +# for item in items do +# do_something(item) +# end +# +# for item in items do +# do_something_else(item) +# end +# end +# +# # good +# def method +# for item in items do +# do_something(item) +# do_something_else(item) +# end +# end +# +# # good +# def method +# each_slice(2) { |slice| do_something(slice) } +# each_slice(3) { |slice| do_something(slice) } +# end +# +# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#59 +class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#64 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#77 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#64 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#88 + def collection_looping_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#105 + def combine_with_left_sibling(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#93 + def same_collection_looping_block?(node, sibling); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#101 + def same_collection_looping_for?(node, sibling); end +end + +# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#62 +RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String) + +# Enforces using `` or %x around command literals. +# +# @example EnforcedStyle: backticks (default) +# # bad +# folders = %x(find . -type d).split +# +# # bad +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# +# # good +# folders = `find . -type d`.split +# +# # good +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# @example EnforcedStyle: mixed +# # bad +# folders = %x(find . -type d).split +# +# # bad +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# +# # good +# folders = `find . -type d`.split +# +# # good +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# @example EnforcedStyle: percent_x +# # bad +# folders = `find . -type d`.split +# +# # bad +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# +# # good +# folders = %x(find . -type d).split +# +# # good +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# @example AllowInnerBackticks: false (default) +# # If `false`, the cop will always recommend using `%x` if one or more +# # backticks are found in the command string. +# +# # bad +# `echo \`ls\`` +# +# # good +# %x(echo `ls`) +# @example AllowInnerBackticks: true +# # good +# `echo \`ls\`` +# +# source://rubocop//lib/rubocop/cop/style/command_literal.rb#78 +class RuboCop::Cop::Style::CommandLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#85 + def on_xstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#146 + def allow_inner_backticks?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#122 + def allowed_backtick_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#131 + def allowed_percent_x_literal?(node); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#109 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#159 + def backtick_literal?(node); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#97 + def check_backtick_literal(node, message); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#103 + def check_percent_x_literal(node, message); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#167 + def command_delimiter; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#150 + def contains_backtick?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#142 + def contains_disallowed_backtick?(node); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#171 + def default_delimiter; end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#154 + def node_body(node); end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#163 + def preferred_delimiter; end + + # source://rubocop//lib/rubocop/cop/style/command_literal.rb#175 + def preferred_delimiters_config; end +end + +# source://rubocop//lib/rubocop/cop/style/command_literal.rb#82 +RuboCop::Cop::Style::CommandLiteral::MSG_USE_BACKTICKS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/command_literal.rb#83 +RuboCop::Cop::Style::CommandLiteral::MSG_USE_PERCENT_X = T.let(T.unsafe(nil), String) + +# Checks that comment annotation keywords are written according +# to guidelines. +# +# Annotation keywords can be specified by overriding the cop's `Keywords` +# configuration. Keywords are allowed to be single words or phrases. +# +# NOTE: With a multiline comment block (where each line is only a +# comment), only the first line will be able to register an offense, even +# if an annotation keyword starts another line. This is done to prevent +# incorrect registering of keywords (eg. `review`) inside a paragraph as an +# annotation. +# +# @example RequireColon: true (default) +# # bad +# # TODO make better +# +# # good +# # TODO: make better +# +# # bad +# # TODO:make better +# +# # good +# # TODO: make better +# +# # bad +# # fixme: does not work +# +# # good +# # FIXME: does not work +# +# # bad +# # Optimize does not work +# +# # good +# # OPTIMIZE: does not work +# @example RequireColon: false +# # bad +# # TODO: make better +# +# # good +# # TODO make better +# +# # bad +# # fixme does not work +# +# # good +# # FIXME does not work +# +# # bad +# # Optimize does not work +# +# # good +# # OPTIMIZE does not work +# +# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#61 +class RuboCop::Cop::Style::CommentAnnotation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#73 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#110 + def annotation_range(annotation); end + + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#114 + def correct_offense(corrector, range, keyword); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#102 + def first_comment_line?(comments, index); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#106 + def inline_comment?(comment); end + + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#124 + def keywords; end + + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#87 + def register_offense(annotation); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#120 + def requires_colon?; end +end + +# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#71 +RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#65 +RuboCop::Cop::Style::CommentAnnotation::MSG_COLON_STYLE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#68 +RuboCop::Cop::Style::CommentAnnotation::MSG_SPACE_STYLE = T.let(T.unsafe(nil), String) + +# Checks for comments put on the same line as some keywords. +# These keywords are: `class`, `module`, `def`, `begin`, `end`. +# +# Note that some comments +# are allowed. +# +# Autocorrection removes comments from `end` keyword and keeps comments +# for `class`, `module`, `def` and `begin` above the keyword. +# +# @example +# # bad +# if condition +# statement +# end # end if +# +# # bad +# class X # comment +# statement +# end +# +# # bad +# def x; end # comment +# +# # good +# if condition +# statement +# end +# +# # good +# class X # :nodoc: +# y +# end +# +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#43 +class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#57 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#80 + def offensive?(comment); end + + # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#67 + def register_offense(comment, matched_keyword); end + + # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#86 + def source_line(comment); end +end + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#52 +RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#53 +RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENT_REGEXES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#49 +RuboCop::Cop::Style::CommentedKeyword::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#50 +RuboCop::Cop::Style::CommentedKeyword::KEYWORD_REGEXES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#47 +RuboCop::Cop::Style::CommentedKeyword::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#55 +RuboCop::Cop::Style::CommentedKeyword::REGEXP = T.let(T.unsafe(nil), Regexp) + +# Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum. +# +# This cop supports autocorrection for `if/elsif/else` bad style only. +# Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed. +# When these are variables, it is not possible to determine which is the minimum and maximum: +# +# [source,ruby] +# ---- +# [1, [2, 3].max].min # => 1 +# 1.clamp(3, 1) # => min argument must be smaller than max argument (ArgumentError) +# ---- +# +# @example +# +# # bad +# [[x, low].max, high].min +# +# # bad +# if x < low +# low +# elsif high < x +# high +# else +# x +# end +# +# # good +# x.clamp(low, high) +# +# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#35 +class RuboCop::Cop::Style::ComparableClamp < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#61 + def array_min_max?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#47 + def if_elsif_else_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#78 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#100 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#108 + def autocorrect(corrector, node, prefer); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#117 + def min_condition?(if_condition, else_body); end +end + +# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#42 +RuboCop::Cop::Style::ComparableClamp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#43 +RuboCop::Cop::Style::ComparableClamp::MSG_MIN_MAX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#44 +RuboCop::Cop::Style::ComparableClamp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of `Array#push(item)` instead of `Array#concat([item])` +# to avoid redundant array literals. +# +# @example +# +# # bad +# list.concat([foo]) +# list.concat([bar, baz]) +# list.concat([qux, quux], [corge]) +# +# # good +# list.push(foo) +# list.push(bar, baz) +# list.push(qux, quux, corge) +# +# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#25 +class RuboCop::Cop::Style::ConcatArrayLiterals < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#34 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#69 + def offense_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#86 + def percent_literals_includes_only_basic_literals?(node); end + + # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#73 + def preferred_method(node); end +end + +# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#28 +RuboCop::Cop::Style::ConcatArrayLiterals::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#29 +RuboCop::Cop::Style::ConcatArrayLiterals::MSG_FOR_PERCENT_LITERALS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#31 +RuboCop::Cop::Style::ConcatArrayLiterals::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for `if` and `case` statements where each branch is used for +# assignment to the same variable when using the return of the +# condition can be used instead. +# +# @example EnforcedStyle: assign_to_condition (default) +# # bad +# if foo +# bar = 1 +# else +# bar = 2 +# end +# +# case foo +# when 'a' +# bar += 1 +# else +# bar += 2 +# end +# +# if foo +# some_method +# bar = 1 +# else +# some_other_method +# bar = 2 +# end +# +# # good +# bar = if foo +# 1 +# else +# 2 +# end +# +# bar += case foo +# when 'a' +# 1 +# else +# 2 +# end +# +# bar << if foo +# some_method +# 1 +# else +# some_other_method +# 2 +# end +# @example EnforcedStyle: assign_inside_condition +# # bad +# bar = if foo +# 1 +# else +# 2 +# end +# +# bar += case foo +# when 'a' +# 1 +# else +# 2 +# end +# +# bar << if foo +# some_method +# 1 +# else +# some_other_method +# 2 +# end +# +# # good +# if foo +# bar = 1 +# else +# bar = 2 +# end +# +# case foo +# when 'a' +# bar += 1 +# else +# bar += 2 +# end +# +# if foo +# some_method +# bar = 1 +# else +# some_other_method +# bar = 2 +# end +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#210 +class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Style::ConditionalAssignmentHelper + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # The shovel operator `<<` does not have its own type. It is a `send` + # type. + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#228 + def assignment_type?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#309 + def candidate_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#264 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#274 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#250 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_op_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#244 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#315 + def allowed_single_line?(branches); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#386 + def allowed_statements?(branches); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#311 + def allowed_ternary?(assignment); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#319 + def assignment_node(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#363 + def assignment_types_match?(*nodes); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#378 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#304 + def candidate_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#286 + def check_assignment_to_condition(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#369 + def check_node(node, branches); end + + # If `Layout/LineLength` is enabled, we do not want to introduce an + # offense by autocorrecting this cop. Find the max configured line + # length. Find the longest line of condition. Remove the assignment + # from lines that contain the offending assignment because after + # correcting, this will not be on the line anymore. Check if the length + # of the longest line + the length of the corrected assignment is + # greater than the max configured line length + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#402 + def correction_exceeds_line_limit?(node, branches); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#433 + def include_ternary?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#356 + def lhs_all_match?(branches); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#421 + def line_length_cop_enabled?; end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#414 + def longest_line(node, assignment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#410 + def longest_line_exceeds_line_limit?(node, assignment); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#425 + def max_line_length; end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#340 + def move_assignment_inside_condition(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#330 + def move_assignment_outside_condition(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#429 + def single_line_conditions_only?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#352 + def ternary_condition?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#219 +RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#217 +RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#221 +RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#220 +RuboCop::Cop::Style::ConditionalAssignment::LINE_LENGTH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#222 +RuboCop::Cop::Style::ConditionalAssignment::MAX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#216 +RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#223 +RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#218 +RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# Helper module to provide common methods to classes needed for the +# ConditionalAssignment Cop. +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#8 +module RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::AST::NodePattern::Macros + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#64 + def end_with_eq?(sym); end + + # `elsif` branches show up in the `node` as an `else`. We need + # to recursively iterate over all `else` branches and consider all + # but the last `node` an `elsif` branch and consider the last `node` + # the actual `else` branch. + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#20 + def expand_elses(branch); end + + # `when` nodes contain the entire branch including the condition. + # We only need the contents of the branch, not the condition. + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#28 + def expand_when_branches(when_branches); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#55 + def indent(cop, source); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#37 + def lhs(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#32 + def tail(branch); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#109 + def assignment_rhs_exist?(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#70 + def expand_elsif(node, elsif_branches = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#96 + def lhs_for_casgn(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#83 + def lhs_for_send(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#105 + def setter_method?(method_name); end +end + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#13 +RuboCop::Cop::Style::ConditionalAssignmentHelper::ALIGN_WITH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#12 +RuboCop::Cop::Style::ConditionalAssignmentHelper::END_ALIGNMENT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#11 +RuboCop::Cop::Style::ConditionalAssignmentHelper::EQUAL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#14 +RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), String) + +# Helper module to provide common methods to ConditionalAssignment +# correctors +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#440 +module RuboCop::Cop::Style::ConditionalCorrectorHelper + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#461 + def assignment(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#491 + def correct_branches(corrector, branches); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#468 + def correct_if_branches(corrector, cop, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#441 + def remove_whitespace_in_branches(corrector, branch, condition, column); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#478 + def replace_branch_assignment(corrector, branch); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#454 + def white_space_range(node, column); end +end + +# Checks that constants defined in classes and modules have +# an explicit visibility declaration. By default, Ruby makes all class- +# and module constants public, which litters the public API of the +# class or module. Explicitly declaring a visibility makes intent more +# clear, and prevents outside actors from touching private state. +# +# @example +# +# # bad +# class Foo +# BAR = 42 +# BAZ = 43 +# end +# +# # good +# class Foo +# BAR = 42 +# private_constant :BAR +# +# BAZ = 43 +# public_constant :BAZ +# end +# @example IgnoreModules: false (default) +# # bad +# class Foo +# MyClass = Struct.new() +# end +# +# # good +# class Foo +# MyClass = Struct.new() +# public_constant :MyClass +# end +# @example IgnoreModules: true +# # good +# class Foo +# MyClass = Struct.new() +# end +# +# source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#47 +class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#51 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#96 + def visibility_declaration_for?(param0 = T.unsafe(nil), param1); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#76 + def class_or_module_scope?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#62 + def ignore_modules?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#100 + def match_name?(name, constant_name); end + + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#70 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#66 + def module?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#87 + def visibility_declaration?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#48 +RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/copyright.rb#21 +class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/copyright.rb#28 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/copyright.rb#47 + def autocorrect_notice; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/copyright.rb#78 + def encoding_token?(processed_source, token_index); end + + # source://rubocop//lib/rubocop/cop/style/copyright.rb#64 + def insert_notice_before(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/copyright.rb#43 + def notice; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/copyright.rb#85 + def notice_found?(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/copyright.rb#51 + def offense_range; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/copyright.rb#71 + def shebang_token?(processed_source, token_index); end + + # @raise [Warning] + # + # source://rubocop//lib/rubocop/cop/style/copyright.rb#55 + def verify_autocorrect_notice!; end +end + +# source://rubocop//lib/rubocop/cop/style/copyright.rb#26 +RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/copyright.rb#25 +RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String) + +# Checks for inheritance from `Data.define` to avoid creating the anonymous parent class. +# +# @example +# # bad +# class Person < Data.define(:first_name, :last_name) +# def age +# 42 +# end +# end +# +# # good +# Person = Data.define(:first_name, :last_name) do +# def age +# 42 +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#26 +class RuboCop::Cop::Style::DataInheritance < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#48 + def data_define?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#36 + def on_class(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#55 + def correct_parent(parent, corrector); end + + # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#65 + def range_for_empty_class_body(class_node, data_define); end +end + +# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#31 +RuboCop::Cop::Style::DataInheritance::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent usage of the `DateTime` class over the +# `Time` class. This cop is disabled by default since these classes, +# although highly overlapping, have particularities that make them not +# replaceable in certain situations when dealing with multiple timezones +# and/or DST. +# +# @example +# +# # bad - uses `DateTime` for current time +# DateTime.now +# +# # good - uses `Time` for current time +# Time.now +# +# # bad - uses `DateTime` for modern date +# DateTime.iso8601('2016-06-29') +# +# # good - uses `Time` for modern date +# Time.iso8601('2016-06-29') +# +# # good - uses `DateTime` with start argument for historical date +# DateTime.iso8601('1751-04-23', Date::ENGLAND) +# @example AllowCoercion: false (default) +# +# # bad - coerces to `DateTime` +# something.to_datetime +# +# # good - coerces to `Time` +# something.to_time +# @example AllowCoercion: true +# +# # good +# something.to_datetime +# +# # good +# something.to_time +# +# source://rubocop//lib/rubocop/cop/style/date_time.rb#49 +class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/date_time.rb#56 + def date_time?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/date_time.rb#61 + def historic_date?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/date_time.rb#70 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/date_time.rb#66 + def to_datetime?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/date_time.rb#85 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/date_time.rb#81 + def disallow_coercion?; end +end + +# source://rubocop//lib/rubocop/cop/style/date_time.rb#52 +RuboCop::Cop::Style::DateTime::CLASS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/date_time.rb#53 +RuboCop::Cop::Style::DateTime::COERCION_MSG = T.let(T.unsafe(nil), String) + +# Checks for parentheses in the definition of a method, +# that does not take any arguments. Both instance and +# class/singleton methods are checked. +# +# @example +# +# # bad +# def foo() +# do_something +# end +# +# # good +# def foo +# do_something +# end +# +# # bad +# def foo() = do_something +# +# # good +# def foo = do_something +# +# # good (without parentheses it's a syntax error) +# def foo() do_something end +# @example +# +# # bad +# def Baz.foo() +# do_something +# end +# +# # good +# def Baz.foo +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#42 +class RuboCop::Cop::Style::DefWithParentheses < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#47 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#47 + def on_defs(node); end +end + +# source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#45 +RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where the `#\_\_dir\_\_` method can replace more +# complex constructs to retrieve a canonicalized absolute path to the +# current file. +# +# @example +# # bad +# path = File.expand_path(File.dirname(__FILE__)) +# +# # bad +# path = File.dirname(File.realpath(__FILE__)) +# +# # good +# path = __dir__ +# +# source://rubocop//lib/rubocop/cop/style/dir.rb#19 +class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/dir.rb#29 + def dir_replacement?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/dir.rb#34 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/dir.rb#44 + def file_keyword?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/dir.rb#25 +RuboCop::Cop::Style::Dir::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/dir.rb#26 +RuboCop::Cop::Style::Dir::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty. +# +# @example +# # bad +# Dir.entries('path/to/dir').size == 2 +# Dir.children('path/to/dir').empty? +# Dir.children('path/to/dir').size == 0 +# Dir.each_child('path/to/dir').none? +# +# # good +# Dir.empty?('path/to/dir') +# +# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#18 +class RuboCop::Cop::Style::DirEmpty < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#28 + def offensive?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#37 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#48 + def bang(node); end +end + +# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#22 +RuboCop::Cop::Style::DirEmpty::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#23 +RuboCop::Cop::Style::DirEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Detects comments to enable/disable RuboCop. +# This is useful if want to make sure that every RuboCop error gets fixed +# and not quickly disabled with a comment. +# +# Specific cops can be allowed with the `AllowedCops` configuration. Note that +# +# @example +# # bad +# # rubocop:disable Metrics/AbcSize +# def foo +# end +# # rubocop:enable Metrics/AbcSize +# +# # good +# def foo +# end +# @example AllowedCops: [Metrics/AbcSize] +# # good +# # rubocop:disable Metrics/AbcSize +# def foo +# end +# # rubocop:enable Metrics/AbcSize +# +# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#33 +class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#40 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#77 + def allowed_cops; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#81 + def any_cops_allowed?; end + + # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#72 + def directive_cops(comment); end + + # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#53 + def register_offense(comment, directive_cops, disallowed_cops); end +end + +# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#37 +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#38 +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String) + +# When using `class_eval` (or other `eval`) with string interpolation, +# add a comment block showing its appearance if interpolated (a practice used in Rails code). +# +# @example +# # from activesupport/lib/active_support/core_ext/string/output_safety.rb +# +# # bad +# UNSAFE_STRING_METHODS.each do |unsafe_method| +# if 'String'.respond_to?(unsafe_method) +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}(*params, &block) +# to_str.#{unsafe_method}(*params, &block) +# end +# +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# end +# end +# +# # good, inline comments in heredoc +# UNSAFE_STRING_METHODS.each do |unsafe_method| +# if 'String'.respond_to?(unsafe_method) +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}(*params, &block) # def capitalize(*params, &block) +# to_str.#{unsafe_method}(*params, &block) # to_str.capitalize(*params, &block) +# end # end +# +# def #{unsafe_method}!(*params) # def capitalize!(*params) +# @dirty = true # @dirty = true +# super # super +# end # end +# EOT +# end +# end +# +# # good, block comments in heredoc +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# # def capitalize!(*params) +# # @dirty = true +# # super +# # end +# +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# +# # good, block comments before heredoc +# class_eval( +# # def capitalize!(*params) +# # @dirty = true +# # super +# # end +# +# <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# ) +# +# # bad - interpolated string without comment +# class_eval("def #{unsafe_method}!(*params); end") +# +# # good - with inline comment or replace it with block comment using heredoc +# class_eval("def #{unsafe_method}!(*params); end # def capitalize!(*params); end") +# +# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#77 +class RuboCop::Cop::Style::DocumentDynamicEvalDefinition < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#84 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#107 + def comment_block_docs?(arg_node); end + + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#147 + def comment_regexp(arg_node); end + + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#126 + def heredoc_comment_blocks(heredoc_body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#100 + def inline_comment_docs?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#96 + def interpolated?(arg_node); end + + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#136 + def merge_adjacent_comments(line, index, hash); end + + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#117 + def preceding_comment_blocks(node); end + + # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#156 + def source_to_regexp(source); end +end + +# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#78 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::BLOCK_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#79 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#80 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#82 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for missing top-level documentation of classes and +# modules. Classes with no body are exempt from the check and so are +# namespace modules - modules that have nothing in their bodies except +# classes, other modules, constant definitions or constant visibility +# declarations. +# +# The documentation requirement is annulled if the class or module has +# same for all its children. +# +# @example +# # bad +# class Person +# # ... +# end +# +# module Math +# end +# +# # good +# # Description/Explanation of Person class +# class Person +# # ... +# end +# +# # allowed +# # Class without body +# class Person +# end +# +# # Namespace - A namespace can be a class or a module +# # Containing a class +# module Namespace +# # Description/Explanation of Person class +# class Person +# # ... +# end +# end +# +# # Containing constant visibility declaration +# module Namespace +# class Private +# end +# +# private_constant :Private +# end +# +# # Containing constant definition +# module Namespace +# Public = Class.new +# end +# +# # Macro calls +# module Namespace +# extend Foo +# end +# @example AllowedConstants: ['ClassMethods'] +# +# # good +# module A +# module ClassMethods +# # ... +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/documentation.rb#72 +class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#79 + def constant_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#85 + def constant_visibility_declaration?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#90 + def include_statement?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#94 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#100 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#82 + def outer_module(param0); end + + private + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#174 + def allowed_constants; end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#106 + def check(node, body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#147 + def compact_namespace?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#143 + def constant_allowed?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#139 + def constant_declaration?(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#178 + def identifier(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#123 + def include_statement_only?(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#129 + def namespace?(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#170 + def nodoc(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#166 + def nodoc?(comment, require_all: T.unsafe(nil)); end + + # Note: How end-of-line comments are associated with code changed in + # parser-2.2.0.4. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#156 + def nodoc_comment?(node, require_all: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation.rb#118 + def nodoc_self_or_outer_module?(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation.rb#186 + def qualify_const(node); end +end + +# source://rubocop//lib/rubocop/cop/style/documentation.rb#76 +RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for missing documentation comment for public methods. +# It can optionally be configured to also require documentation for +# non-public methods. +# +# NOTE: This cop allows `initialize` method because `initialize` is +# a special method called from `new`. In some programming languages +# they are called constructor to distinguish it from method. +# +# @example +# +# # bad +# +# class Foo +# def bar +# puts baz +# end +# end +# +# module Foo +# def bar +# puts baz +# end +# end +# +# def foo.bar +# puts baz +# end +# +# # good +# +# class Foo +# # Documentation +# def bar +# puts baz +# end +# end +# +# module Foo +# # Documentation +# def bar +# puts baz +# end +# end +# +# # Documentation +# def foo.bar +# puts baz +# end +# @example RequireForNonPublicMethods: false (default) +# # good +# class Foo +# protected +# def do_something +# end +# end +# +# class Foo +# private +# def do_something +# end +# end +# @example RequireForNonPublicMethods: true +# # bad +# class Foo +# protected +# def do_something +# end +# end +# +# class Foo +# private +# def do_something +# end +# end +# +# # good +# class Foo +# protected +# # Documentation +# def do_something +# end +# end +# +# class Foo +# private +# # Documentation +# def do_something +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/documentation_method.rb#98 +class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::DefNode + + # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#105 + def modifier_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#109 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#109 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#119 + def check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#126 + def require_for_non_public_methods?; end +end + +# source://rubocop//lib/rubocop/cop/style/documentation_method.rb#102 +RuboCop::Cop::Style::DocumentationMethod::MSG = T.let(T.unsafe(nil), String) + +# Detects double disable comments on one line. This is mostly to catch +# automatically generated comments that need to be regenerated. +# +# @example +# # bad +# def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize +# end +# +# # good +# # rubocop:disable Metrics/AbcSize +# def f # rubocop:disable Style/For +# end +# # rubocop:enable Metrics/AbcSize +# +# # if both fit on one line +# def f # rubocop:disable Style/For, Metrics/AbcSize +# end +# +# source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#27 +class RuboCop::Cop::Style::DoubleCopDisableDirective < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#34 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#32 +RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of double negation (`!!`) to convert something to a boolean value. +# +# When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts +# that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation +# should be forbidden always. +# +# NOTE: when `something` is a boolean value +# `!!something` and `!something.nil?` are not the same thing. +# As you're unlikely to write code that can accept values of any type +# this is rarely a problem in practice. +# +# @example +# # bad +# !!something +# +# # good +# !something.nil? +# @example EnforcedStyle: allowed_in_returns (default) +# # good +# def foo? +# !!return_value +# end +# +# define_method :foo? do +# !!return_value +# end +# +# define_singleton_method :foo? do +# !!return_value +# end +# @example EnforcedStyle: forbidden +# # bad +# def foo? +# !!return_value +# end +# +# define_method :foo? do +# !!return_value +# end +# +# define_singleton_method :foo? do +# !!return_value +# end +# +# source://rubocop//lib/rubocop/cop/style/double_negation.rb#61 +class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#69 + def double_negative?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#84 + def allowed_in_returns?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#111 + def define_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#138 + def double_negative_condition_return_value?(node, last_child, conditional_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#88 + def end_of_method_definition?(node); end + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#120 + def find_conditional_node_from_ascendant(node); end + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#103 + def find_def_node_from_ascendant(node); end + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#127 + def find_last_child(node); end + + # source://rubocop//lib/rubocop/cop/style/double_negation.rb#147 + def find_parent_not_enumerable(node); end +end + +# source://rubocop//lib/rubocop/cop/style/double_negation.rb#65 +RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/double_negation.rb#66 +RuboCop::Cop::Style::DoubleNegation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for loops which iterate a constant number of times, +# using a Range literal and `#each`. This can be done more readably using +# `Integer#times`. +# +# This check only applies if the block takes no parameters. +# +# @example +# # bad +# (1..5).each { } +# +# # good +# 5.times { } +# @example +# # bad +# (0...10).each {} +# +# # good +# 10.times {} +# +# source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#25 +class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#53 + def each_range(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#65 + def each_range_with_zero_origin?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#77 + def each_range_without_block_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#30 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#48 + def offending?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#28 +RuboCop::Cop::Style::EachForSimpleLoop::MSG = T.let(T.unsafe(nil), String) + +# Looks for inject / reduce calls where the passed in object is +# returned at the end and so could be replaced by each_with_object without +# the need to return the object at the end. +# +# However, we can't replace with each_with_object if the accumulator +# parameter is assigned to within the block. +# +# @example +# # bad +# [1, 2].inject({}) { |a, e| a[e] = e; a } +# +# # good +# [1, 2].each_with_object({}) { |e, a| a[e] = e } +# +# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#19 +class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#60 + def each_with_object_block_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#65 + def each_with_object_numblock_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#26 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#43 + def on_numblock(node); end + + private + + # if the accumulator parameter is assigned to in the block, + # then we can't convert to each_with_object + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#102 + def accumulator_param_assigned_to?(body, args); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#69 + def autocorrect_block(corrector, node, return_value); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#84 + def autocorrect_numblock(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#121 + def first_argument_returned?(args, return_value); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#114 + def return_value(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#129 + def return_value_occupies_whole_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#96 + def simple_method_arg?(method_arg); end + + # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#133 + def whole_line_expression(node); end +end + +# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#24 +RuboCop::Cop::Style::EachWithObject::METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#23 +RuboCop::Cop::Style::EachWithObject::MSG = T.let(T.unsafe(nil), String) + +# Checks for pipes for empty block parameters. Pipes for empty +# block parameters do not cause syntax errors, but they are redundant. +# +# @example +# # bad +# a do || +# do_something +# end +# +# # bad +# a { || do_something } +# +# # good +# a do +# end +# +# # good +# a { do_something } +# +# source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#24 +class RuboCop::Cop::Style::EmptyBlockParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#31 + def on_block(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#38 + def autocorrect(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#29 +RuboCop::Cop::Style::EmptyBlockParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for case statements with an empty condition. +# +# @example +# +# # bad: +# case +# when x == 0 +# puts 'x is 0' +# when y == 0 +# puts 'y is 0' +# else +# puts 'neither is 0' +# end +# +# # good: +# if x == 0 +# puts 'x is 0' +# elsif y == 0 +# puts 'y is 0' +# else +# puts 'neither is 0' +# end +# +# # good: (the case condition node is not empty) +# case n +# when 0 +# puts 'zero' +# when 1 +# puts 'one' +# else +# puts 'more' +# end +# +# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#38 +class RuboCop::Cop::Style::EmptyCaseCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#46 + def on_case(case_node); end + + private + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#63 + def autocorrect(corrector, case_node); end + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#70 + def correct_case_when(corrector, case_node, when_nodes); end + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#82 + def correct_when_conditions(corrector, when_nodes); end + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#97 + def keep_first_when_comment(case_range, corrector); end + + # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#107 + def replace_then_with_line_break(corrector, conditions, when_node); end +end + +# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#42 +RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#43 +RuboCop::Cop::Style::EmptyCaseCondition::NOT_SUPPORTED_PARENT_TYPES = T.let(T.unsafe(nil), Array) + +# Checks for empty else-clauses, possibly including comments and/or an +# explicit `nil` depending on the EnforcedStyle. +# +# @example EnforcedStyle: both (default) +# # warn on empty else and else with nil in it +# +# # bad +# if condition +# statement +# else +# nil +# end +# +# # bad +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example EnforcedStyle: empty +# # warn only on empty else +# +# # bad +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# nil +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example EnforcedStyle: nil +# # warn on else with nil in it +# +# # bad +# if condition +# statement +# else +# nil +# end +# +# # good +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example AllowComments: false (default) +# +# # bad +# if condition +# statement +# else +# # something comment +# nil +# end +# +# # bad +# if condition +# statement +# else +# # something comment +# end +# @example AllowComments: true +# +# # good +# if condition +# statement +# else +# # something comment +# nil +# end +# +# # good +# if condition +# statement +# else +# # something comment +# end +# +# source://rubocop//lib/rubocop/cop/style/empty_else.rb#127 +class RuboCop::Cop::Style::EmptyElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#139 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#135 + def on_normal_if_unless(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#172 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#193 + def autocorrect_forbidden?(type); end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#186 + def base_node(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#145 + def check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#180 + def comment_in_else?(loc); end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#160 + def empty_check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#156 + def empty_style?; end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#197 + def missing_else_style; end + + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#166 + def nil_check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_else.rb#152 + def nil_style?; end +end + +# source://rubocop//lib/rubocop/cop/style/empty_else.rb#133 +RuboCop::Cop::Style::EmptyElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for using empty heredoc to reduce redundancy. +# +# @example +# +# # bad +# <<~EOS +# EOS +# +# <<-EOS +# EOS +# +# < () { do_something } +# +# # good +# -> { do_something } +# +# # good +# -> (arg) { do_something(arg) } +# +# source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#19 +class RuboCop::Cop::Style::EmptyLambdaParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#26 + def on_block(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#35 + def autocorrect(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#24 +RuboCop::Cop::Style::EmptyLambdaParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of a method, the result of which +# would be a literal, like an empty array, hash, or string. +# +# @example +# # bad +# a = Array.new +# h = Hash.new +# s = String.new +# +# # good +# a = [] +# h = {} +# s = '' +# +# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#19 +class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#31 + def array_node(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#40 + def array_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#34 + def hash_node(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#43 + def hash_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#50 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#37 + def str_node(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#111 + def correction(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#74 + def enforce_double_quotes?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#82 + def first_argument_unparenthesized?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#129 + def frozen_strings?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#102 + def offense_array_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#106 + def offense_hash_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#60 + def offense_message(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#70 + def preferred_string_literal; end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#89 + def replacement_range(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#78 + def string_literals_config; end +end + +# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#24 +RuboCop::Cop::Style::EmptyLiteral::ARR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#25 +RuboCop::Cop::Style::EmptyLiteral::HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#28 +RuboCop::Cop::Style::EmptyLiteral::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#26 +RuboCop::Cop::Style::EmptyLiteral::STR_MSG = T.let(T.unsafe(nil), String) + +# Checks for the formatting of empty method definitions. +# By default it enforces empty method definitions to go on a single +# line (compact style), but it can be configured to enforce the `end` +# to go on its own line (expanded style). +# +# NOTE: A method definition is not considered empty if it contains +# comments. +# +# NOTE: Autocorrection will not be applied for the `compact` style +# if the resulting code is longer than the `Max` configuration for +# `Layout/LineLength`, but an offense will still be registered. +# +# @example EnforcedStyle: compact (default) +# # bad +# def foo(bar) +# end +# +# def self.foo(bar) +# end +# +# # good +# def foo(bar); end +# +# def foo(bar) +# # baz +# end +# +# def self.foo(bar); end +# @example EnforcedStyle: expanded +# # bad +# def foo(bar); end +# +# def self.foo(bar); end +# +# # good +# def foo(bar) +# end +# +# def self.foo(bar) +# end +# +# source://rubocop//lib/rubocop/cop/style/empty_method.rb#47 +class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#54 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#54 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#95 + def compact?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#103 + def compact_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#73 + def correct_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#77 + def corrected(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#99 + def expanded?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#107 + def expanded_style?; end + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#89 + def joint(node); end + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#111 + def max_line_length; end + + # source://rubocop//lib/rubocop/cop/style/empty_method.rb#69 + def message(_range); end +end + +# source://rubocop//lib/rubocop/cop/style/empty_method.rb#51 +RuboCop::Cop::Style::EmptyMethod::MSG_COMPACT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/empty_method.rb#52 +RuboCop::Cop::Style::EmptyMethod::MSG_EXPANDED = T.let(T.unsafe(nil), String) + +# Checks ensures source files have no utf-8 encoding comments. +# +# @example +# # bad +# # encoding: UTF-8 +# # coding: UTF-8 +# # -*- coding: UTF-8 -*- +# +# source://rubocop//lib/rubocop/cop/style/encoding.rb#12 +class RuboCop::Cop::Style::Encoding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/encoding.rb#20 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/encoding.rb#32 + def comments; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/encoding.rb#43 + def offense?(comment); end + + # source://rubocop//lib/rubocop/cop/style/encoding.rb#47 + def register_offense(line_number, comment); end +end + +# source://rubocop//lib/rubocop/cop/style/encoding.rb#17 +RuboCop::Cop::Style::Encoding::ENCODING_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/encoding.rb#16 +RuboCop::Cop::Style::Encoding::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/encoding.rb#18 +RuboCop::Cop::Style::Encoding::SHEBANG = T.let(T.unsafe(nil), String) + +# Checks for END blocks. +# +# @example +# # bad +# END { puts 'Goodbye!' } +# +# # good +# at_exit { puts 'Goodbye!' } +# +# source://rubocop//lib/rubocop/cop/style/end_block.rb#15 +class RuboCop::Cop::Style::EndBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/end_block.rb#20 + def on_postexe(node); end +end + +# source://rubocop//lib/rubocop/cop/style/end_block.rb#18 +RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for endless methods. +# +# It can enforce either the use of endless methods definitions +# for single-lined method bodies, or disallow endless methods. +# +# Other method definition types are not considered by this cop. +# +# The supported styles are: +# +# * allow_single_line (default) - only single line endless method definitions are allowed. +# * allow_always - all endless method definitions are allowed. +# * disallow - all endless method definitions are disallowed. +# +# NOTE: Incorrect endless method definitions will always be +# corrected to a multi-line definition. +# +# @example EnforcedStyle: allow_single_line (default) +# # good +# def my_method() = x +# +# # bad, multi-line endless method +# def my_method() = x.foo +# .bar +# .baz +# @example EnforcedStyle: allow_always +# # good +# def my_method() = x +# +# # good +# def my_method() = x.foo +# .bar +# .baz +# @example EnforcedStyle: disallow +# # bad +# def my_method() = x +# +# # bad +# def my_method() = x.foo +# .bar +# .baz +# +# source://rubocop//lib/rubocop/cop/style/endless_method.rb#49 +class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::TargetRubyVersion + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/endless_method.rb#60 + def on_def(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/endless_method.rb#95 + def arguments(node, missing = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/endless_method.rb#85 + def correct_to_multiline(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/endless_method.rb#70 + def handle_allow_style(node); end + + # source://rubocop//lib/rubocop/cop/style/endless_method.rb#79 + def handle_disallow_style(node); end +end + +# source://rubocop//lib/rubocop/cop/style/endless_method.rb#56 +RuboCop::Cop::Style::EndlessMethod::CORRECTION_STYLES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/endless_method.rb#57 +RuboCop::Cop::Style::EndlessMethod::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/endless_method.rb#58 +RuboCop::Cop::Style::EndlessMethod::MSG_MULTI_LINE = T.let(T.unsafe(nil), String) + +# Checks for consistent usage of `ENV['HOME']`. If `nil` is used as +# the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`. +# +# @example +# +# # bad +# ENV['HOME'] +# ENV.fetch('HOME', nil) +# +# # good +# Dir.home +# +# # good +# ENV.fetch('HOME', default) +# +# source://rubocop//lib/rubocop/cop/style/env_home.rb#31 +class RuboCop::Cop::Style::EnvHome < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/env_home.rb#38 + def env_home?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/env_home.rb#45 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/env_home.rb#34 +RuboCop::Cop::Style::EnvHome::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/env_home.rb#35 +RuboCop::Cop::Style::EnvHome::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Ensures that eval methods (`eval`, `instance_eval`, `class_eval` +# and `module_eval`) are given filename and line number values (`\_\_FILE\_\_` +# and `\_\_LINE\_\_`). This data is used to ensure that any errors raised +# within the evaluated code will be given the correct identification +# in a backtrace. +# +# The cop also checks that the line number given relative to `\_\_LINE\_\_` is +# correct. +# +# This cop will autocorrect incorrect or missing filename and line number +# values. However, if `eval` is called without a binding argument, the cop +# will not attempt to automatically add a binding, or add filename and +# line values. +# +# This cop works only when a string literal is given as a code string. +# No offense is reported if a string variable is given as below: +# +# @example +# # bad +# eval <<-RUBY +# def do_something +# end +# RUBY +# +# # bad +# C.class_eval <<-RUBY +# def do_something +# end +# RUBY +# +# # good +# eval <<-RUBY, binding, __FILE__, __LINE__ + 1 +# def do_something +# end +# RUBY +# +# # good +# C.class_eval <<-RUBY, __FILE__, __LINE__ + 1 +# def do_something +# end +# RUBY +# @example +# # not checked +# code = <<-RUBY +# def do_something +# end +# RUBY +# eval code +# +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#56 +class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#74 + def line_with_offset?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#81 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#69 + def valid_eval_receiver?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#195 + def add_offense_for_different_line(node, line_node, line_diff); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#142 + def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#210 + def add_offense_for_missing_line(node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#217 + def add_offense_for_missing_location(node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#189 + def add_offense_for_same_line(node, line_node); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#154 + def check_file(node, file_node); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#167 + def check_line(node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#95 + def check_location(node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#202 + def expected_line(sign, line_diff); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#122 + def file_and_line(node); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#177 + def line_difference(line_node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#229 + def missing_line(node, code); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#109 + def register_offense(node, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#114 + def special_file_keyword?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#118 + def special_line_keyword?(node); end + + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#181 + def string_first_line(str_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#127 + def with_binding?(node); end + + # FIXME: It's a Style/ConditionalAssignment's false positive. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#133 + def with_lineno?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#59 +RuboCop::Cop::Style::EvalWithLocation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#60 +RuboCop::Cop::Style::EvalWithLocation::MSG_EVAL = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#61 +RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_FILE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#63 +RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#66 +RuboCop::Cop::Style::EvalWithLocation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where `Integer#even?` or `Integer#odd?` +# can be used. +# +# @example +# +# # bad +# if x % 2 == 0 +# end +# +# # good +# if x.even? +# end +# +# source://rubocop//lib/rubocop/cop/style/even_odd.rb#18 +class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/even_odd.rb#25 + def even_odd_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/even_odd.rb#33 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/even_odd.rb#45 + def replacement_method(arg, method); end +end + +# source://rubocop//lib/rubocop/cop/style/even_odd.rb#21 +RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/even_odd.rb#22 +RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for exact regexp match inside Regexp literals. +# +# @example +# +# # bad +# string =~ /\Astring\z/ +# string === /\Astring\z/ +# string.match(/\Astring\z/) +# string.match?(/\Astring\z/) +# +# # good +# string == 'string' +# +# # bad +# string !~ /\Astring\z/ +# +# # good +# string != 'string' +# +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#25 +class RuboCop::Cop::Style::ExactRegexpMatch < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#32 + def exact_regexp_match(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#40 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#55 + def exact_match_pattern?(parsed_regexp); end + + # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#62 + def new_method(node); end +end + +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#28 +RuboCop::Cop::Style::ExactRegexpMatch::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#29 +RuboCop::Cop::Style::ExactRegexpMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for use of the `File.expand_path` arguments. +# Likewise, it also checks for the `Pathname.new` argument. +# +# Contrastive bad case and good case are alternately shown in +# the following examples. +# +# @example +# # bad +# File.expand_path('..', __FILE__) +# +# # good +# File.expand_path(__dir__) +# +# # bad +# File.expand_path('../..', __FILE__) +# +# # good +# File.expand_path('..', __dir__) +# +# # bad +# File.expand_path('.', __FILE__) +# +# # good +# File.expand_path(__FILE__) +# +# # bad +# Pathname(__FILE__).parent.expand_path +# +# # good +# Pathname(__dir__).expand_path +# +# # bad +# Pathname.new(__FILE__).parent.expand_path +# +# # good +# Pathname.new(__dir__).expand_path +# +# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#43 +class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#58 + def file_expand_path(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#82 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#74 + def pathname_new_parent_expand_path(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#66 + def pathname_parent_expand_path(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#189 + def arguments_range(node); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#100 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#135 + def autocorrect_expand_path(corrector, current_path, default_dir); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#162 + def depth(current_path); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#113 + def inspect_offense_for_expand_path(node, current_path, default_dir); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#168 + def parent_path(current_path); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#182 + def remove_parent_method(corrector, default_dir); end + + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#155 + def strip_surrounded_quotes!(path_string); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#109 + def unrecommended_argument?(default_dir); end +end + +# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#47 +RuboCop::Cop::Style::ExpandPathArguments::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#49 +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#51 +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_NEW_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#55 +RuboCop::Cop::Style::ExpandPathArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of explicit block argument to avoid writing +# block literal that just passes its arguments to another block. +# +# NOTE: This cop only registers an offense if the block args match the +# yield args exactly. +# +# @example +# # bad +# def with_tmp_dir +# Dir.mktmpdir do |tmp_dir| +# Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments +# end +# end +# +# # bad +# def nine_times +# 9.times { yield } +# end +# +# # good +# def with_tmp_dir(&block) +# Dir.mktmpdir do |tmp_dir| +# Dir.chdir(tmp_dir, &block) +# end +# end +# +# with_tmp_dir do |dir| +# puts "dir is accessible as a parameter and pwd is set: #{dir}" +# end +# +# # good +# def nine_times(&block) +# 9.times(&block) +# end +# +# source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#41 +class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [ExplicitBlockArgument] a new instance of ExplicitBlockArgument + # + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#57 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#62 + def on_yield(node); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#49 + def yielding_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#108 + def add_block_argument(node, corrector, block_name); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#147 + def block_body_range(block_node, send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#125 + def call_like?(node); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#137 + def correct_call_node(node, corrector, block_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#120 + def empty_arguments?(node); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#87 + def extract_block_name(def_node); end + + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#129 + def insert_argument(node, corrector, block_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#95 + def yielding_arguments?(block_args, yield_args); end + + class << self + # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#53 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#45 +RuboCop::Cop::Style::ExplicitBlockArgument::MSG = T.let(T.unsafe(nil), String) + +# Enforces consistency when using exponential notation +# for numbers in the code (eg 1.2e4). Different styles are supported: +# +# * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive). +# * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa +# to be between 0.1 (inclusive) and 10 (exclusive). +# * `integral` which enforces the mantissa to always be a whole number without +# trailing zeroes. +# +# @example EnforcedStyle: scientific (default) +# # Enforces a mantissa between 1 (inclusive) and 10 (exclusive). +# +# # bad +# 10e6 +# 0.3e4 +# 11.7e5 +# 3.14e0 +# +# # good +# 1e7 +# 3e3 +# 1.17e6 +# 3.14 +# @example EnforcedStyle: engineering +# # Enforces using multiple of 3 exponents, +# # mantissa should be between 0.1 (inclusive) and 1000 (exclusive) +# +# # bad +# 3.2e7 +# 0.1e5 +# 12e5 +# 1232e6 +# +# # good +# 32e6 +# 10e3 +# 1.2e6 +# 1.232e9 +# @example EnforcedStyle: integral +# # Enforces the mantissa to have no decimal part and no +# # trailing zeroes. +# +# # bad +# 3.2e7 +# 0.1e5 +# 120e4 +# +# # good +# 32e6 +# 1e4 +# 12e5 +# +# source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#60 +class RuboCop::Cop::Style::ExponentialNotation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#68 + def on_float(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#79 + def engineering?(node); end + + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#90 + def integral(node); end + + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#110 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#95 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#74 + def scientific?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#62 +RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash) + +# Suggests `ENV.fetch` for the replacement of `ENV[]`. +# `ENV[]` silently fails and returns `nil` when the environment variable is unset, +# which may cause unexpected behaviors when the developer forgets to set it. +# On the other hand, `ENV.fetch` raises KeyError or returns the explicitly +# specified default value. +# +# @example +# # bad +# ENV['X'] +# x = ENV['X'] +# +# # good +# ENV.fetch('X') +# x = ENV.fetch('X') +# +# # also good +# !ENV['X'] +# ENV['X'].some_method # (e.g. `.nil?`) +# +# source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#25 +class RuboCop::Cop::Style::FetchEnvVar < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#31 + def env_with_bracket?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#35 + def on_send(node); end + + private + + # The following are allowed cases: + # + # - Used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because + # it simply checks whether the variable is set. + # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`. + # - `ENV['key']` assigned by logical AND/OR assignment. + # - `ENV['key']` is the LHS of a `||`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#105 + def allowable_use?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#48 + def allowed_var?(node); end + + # The following are allowed cases: + # + # - `ENV['key']` is a receiver of `||=`, e.g. `ENV['X'] ||= y`. + # - `ENV['key']` is a receiver of `&&=`, e.g. `ENV['X'] &&= y`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#113 + def assigned?(node); end + + # Check if the node is a receiver and receives a message with dot syntax. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#89 + def message_chained_with_dot?(node); end + + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#126 + def new_code(name_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#84 + def offensive?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#120 + def or_lhs?(node); end + + # Avoid offending in the following cases: + # `ENV['key'] if ENV['key'] = x` + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#80 + def partial_matched?(node, condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#53 + def used_as_flag?(node); end + + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#60 + def used_if_condition_in_body(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#69 + def used_in_condition?(node, condition); end +end + +# source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#28 +RuboCop::Cop::Style::FetchEnvVar::MSG = T.let(T.unsafe(nil), String) + +# Prefer to use `File.empty?('path/to/file')` when checking if a file is empty. +# +# @example +# # bad +# File.zero?('path/to/file') +# File.size('path/to/file') == 0 +# File.size('path/to/file') >= 0 +# File.size('path/to/file').zero? +# File.read('path/to/file').empty? +# File.binread('path/to/file') == '' +# FileTest.zero?('path/to/file') +# +# # good +# File.empty?('path/to/file') +# FileTest.empty?('path/to/file') +# +# source://rubocop//lib/rubocop/cop/style/file_empty.rb#27 +class RuboCop::Cop::Style::FileEmpty < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/file_empty.rb#37 + def offensive?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/file_empty.rb#49 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/file_empty.rb#62 + def bang(node); end +end + +# source://rubocop//lib/rubocop/cop/style/file_empty.rb#31 +RuboCop::Cop::Style::FileEmpty::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/file_empty.rb#32 +RuboCop::Cop::Style::FileEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Favor `File.(bin)read` convenience methods. +# +# @example +# ## text mode +# # bad +# File.open(filename).read +# File.open(filename, &:read) +# File.open(filename) { |f| f.read } +# File.open(filename) do |f| +# f.read +# end +# File.open(filename, 'r').read +# File.open(filename, 'r', &:read) +# File.open(filename, 'r') do |f| +# f.read +# end +# +# # good +# File.read(filename) +# @example +# ## binary mode +# # bad +# File.open(filename, 'rb').read +# File.open(filename, 'rb', &:read) +# File.open(filename, 'rb') do |f| +# f.read +# end +# +# # good +# File.binread(filename) +# +# source://rubocop//lib/rubocop/cop/style/file_read.rb#38 +class RuboCop::Cop::Style::FileRead < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#65 + def block_read?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#49 + def file_open?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#69 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#60 + def send_read?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#84 + def evidence(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/file_read.rb#100 + def file_open_read?(node); end + + # source://rubocop//lib/rubocop/cop/style/file_read.rb#106 + def read_method(mode); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/file_read.rb#92 + def read_node?(node, block_pass); end +end + +# source://rubocop//lib/rubocop/cop/style/file_read.rb#42 +RuboCop::Cop::Style::FileRead::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/file_read.rb#46 +RuboCop::Cop::Style::FileRead::READ_FILE_START_TO_FINISH_MODES = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/file_read.rb#44 +RuboCop::Cop::Style::FileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Favor `File.(bin)write` convenience methods. +# +# NOTE: There are different method signatures between `File.write` (class method) +# and `File#write` (instance method). The following case will be allowed because +# static analysis does not know the contents of the splat argument: +# +# [source,ruby] +# ---- +# File.open(filename, 'w') do |f| +# f.write(*objects) +# end +# ---- +# +# @example +# ## text mode +# # bad +# File.open(filename, 'w').write(content) +# File.open(filename, 'w') do |f| +# f.write(content) +# end +# +# # good +# File.write(filename, content) +# @example +# ## binary mode +# # bad +# File.open(filename, 'wb').write(content) +# File.open(filename, 'wb') do |f| +# f.write(content) +# end +# +# # good +# File.binwrite(filename, content) +# +# source://rubocop//lib/rubocop/cop/style/file_write.rb#41 +class RuboCop::Cop::Style::FileWrite < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#68 + def block_write?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#85 + def evidence(node); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#52 + def file_open?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#72 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#63 + def send_write?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # @yield [content] + # + # source://rubocop//lib/rubocop/cop/style/file_write.rb#95 + def file_open_write?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/file_write.rb#123 + def heredoc?(write_node); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#128 + def heredoc_range(first_argument); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#108 + def replacement(mode, filename, content, write_node); end + + # source://rubocop//lib/rubocop/cop/style/file_write.rb#104 + def write_method(mode); end +end + +# source://rubocop//lib/rubocop/cop/style/file_write.rb#45 +RuboCop::Cop::Style::FileWrite::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/file_write.rb#47 +RuboCop::Cop::Style::FileWrite::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/file_write.rb#49 +RuboCop::Cop::Style::FileWrite::TRUNCATING_WRITE_MODES = T.let(T.unsafe(nil), Set) + +# Checks for division with integers coerced to floats. +# It is recommended to either always use `fdiv` or coerce one side only. +# This cop also provides other options for code consistency. +# +# @example EnforcedStyle: single_coerce (default) +# # bad +# a.to_f / b.to_f +# +# # good +# a.to_f / b +# a / b.to_f +# @example EnforcedStyle: left_coerce +# # bad +# a / b.to_f +# a.to_f / b.to_f +# +# # good +# a.to_f / b +# @example EnforcedStyle: right_coerce +# # bad +# a.to_f / b +# a.to_f / b.to_f +# +# # good +# a / b.to_f +# @example EnforcedStyle: fdiv +# # bad +# a / b.to_f +# a.to_f / b +# a.to_f / b.to_f +# +# # good +# a.fdiv(b) +# +# source://rubocop//lib/rubocop/cop/style/float_division.rb#53 +class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#79 + def any_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#75 + def both_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#71 + def left_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#83 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#67 + def right_coerce?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#121 + def add_to_f_method(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#130 + def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#141 + def extract_receiver_source(node); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#117 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/float_division.rb#102 + def offense_condition?(node); end + + # source://rubocop//lib/rubocop/cop/style/float_division.rb#125 + def remove_to_f_method(corrector, send_node); end +end + +# source://rubocop//lib/rubocop/cop/style/float_division.rb#57 +RuboCop::Cop::Style::FloatDivision::MESSAGES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/float_division.rb#64 +RuboCop::Cop::Style::FloatDivision::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for uses of the `for` keyword or `each` method. The +# preferred alternative is set in the EnforcedStyle configuration +# parameter. An `each` call with a block on a single line is always +# allowed. +# +# @example EnforcedStyle: each (default) +# # bad +# def foo +# for n in [1, 2, 3] do +# puts n +# end +# end +# +# # good +# def foo +# [1, 2, 3].each do |n| +# puts n +# end +# end +# @example EnforcedStyle: for +# # bad +# def foo +# [1, 2, 3].each do |n| +# puts n +# end +# end +# +# # good +# def foo +# for n in [1, 2, 3] do +# puts n +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/for.rb#45 +class RuboCop::Cop::Style::For < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/for.rb#65 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/for.rb#54 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/style/for.rb#65 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/for.rb#82 + def suspect_enumerable?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/for.rb#50 +RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/style/for.rb#51 +RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/for.rb#52 +RuboCop::Cop::Style::For::PREFER_FOR = T.let(T.unsafe(nil), String) + +# Enforces the use of a single string formatting utility. +# Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`. +# +# The detection of `String#%` cannot be implemented in a reliable +# manner for all cases, so only two scenarios are considered - +# if the first argument is a string literal and if the second +# argument is an array literal. +# +# Autocorrection will be applied when using argument is a literal or known built-in conversion +# methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables, +# provided that their return value is not an array. For example, when using `to_s`, +# `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility: +# +# [source,ruby] +# ---- +# '%s' % [1, 2, 3] #=> '1' +# format('%s', [1, 2, 3]) #=> '[1, 2, 3]' +# '%s' % [1, 2, 3].to_s #=> '[1, 2, 3]' +# ---- +# +# @example EnforcedStyle: format (default) +# # bad +# puts sprintf('%10s', 'hoge') +# puts '%10s' % 'hoge' +# +# # good +# puts format('%10s', 'hoge') +# @example EnforcedStyle: sprintf +# # bad +# puts format('%10s', 'hoge') +# puts '%10s' % 'hoge' +# +# # good +# puts sprintf('%10s', 'hoge') +# @example EnforcedStyle: percent +# # bad +# puts format('%10s', 'hoge') +# puts sprintf('%10s', 'hoge') +# +# # good +# puts '%10s' % 'hoge' +# +# source://rubocop//lib/rubocop/cop/style/format_string.rb#50 +class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#61 + def formatter(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#74 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#70 + def variable_argument?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#102 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#118 + def autocorrect_from_percent(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#132 + def autocorrect_to_percent(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string.rb#88 + def autocorrectable?(node); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#145 + def format_single_parameter(arg); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#94 + def message(detected_style); end + + # source://rubocop//lib/rubocop/cop/style/format_string.rb#98 + def method_name(style_name); end +end + +# Known conversion methods whose return value is not an array. +# +# source://rubocop//lib/rubocop/cop/style/format_string.rb#58 +RuboCop::Cop::Style::FormatString::AUTOCORRECTABLE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/format_string.rb#54 +RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/format_string.rb#55 +RuboCop::Cop::Style::FormatString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Use a consistent style for named format string tokens. +# +# NOTE: `unannotated` style cop only works for strings +# which are passed as arguments to those methods: +# `printf`, `sprintf`, `format`, `%`. +# The reason is that _unannotated_ format is very similar +# to encoded URLs or Date/Time formatting strings. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# It is allowed to contain unannotated token +# if the number of them is less than or equals to +# `MaxUnannotatedPlaceholdersAllowed`. +# +# @example EnforcedStyle: annotated (default) +# +# # bad +# format('%{greeting}', greeting: 'Hello') +# format('%s', 'Hello') +# +# # good +# format('%s', greeting: 'Hello') +# @example EnforcedStyle: template +# +# # bad +# format('%s', greeting: 'Hello') +# format('%s', 'Hello') +# +# # good +# format('%{greeting}', greeting: 'Hello') +# @example EnforcedStyle: unannotated +# +# # bad +# format('%s', greeting: 'Hello') +# format('%{greeting}', greeting: 'Hello') +# +# # good +# format('%s', 'Hello') +# @example MaxUnannotatedPlaceholdersAllowed: 0 +# +# # bad +# format('%06d', 10) +# format('%s %s.', 'Hello', 'world') +# +# # good +# format('%06d', number: 10) +# @example MaxUnannotatedPlaceholdersAllowed: 1 (default) +# +# # bad +# format('%s %s.', 'Hello', 'world') +# +# # good +# format('%06d', 10) +# @example AllowedMethods: [] (default) +# +# # bad +# redirect('foo/%{bar_id}') +# @example AllowedMethods: [redirect] +# +# # good +# redirect('foo/%{bar_id}') +# @example AllowedPatterns: [] (default) +# +# # bad +# redirect('foo/%{bar_id}') +# @example AllowedPatterns: ['redirect'] +# +# # good +# redirect('foo/%{bar_id}') +# +# source://rubocop//lib/rubocop/cop/style/format_string_token.rb#85 +class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#106 + def format_string_in_typical_context?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#91 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#213 + def allowed_unannotated?(detections); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#139 + def autocorrect_sequence(corrector, detected_sequence, token_range); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#124 + def check_sequence(detected_sequence, token_range); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#203 + def collect_detections(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#135 + def correctable_sequence?(detected_type); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#113 + def format_string_token?(node); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#222 + def max_unannotated_placeholders_allowed; end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#160 + def message(detected_style); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#165 + def message_text(style); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#180 + def str_contents(source_map); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#190 + def token_ranges(contents); end + + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#174 + def tokens(str_node, &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#156 + def unannotated_format?(node, detected_style); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#117 + def use_allowed_method?(node); end +end + +# Helps you transition from mutable string literals +# to frozen string literals. +# of files to enable frozen string literals. Frozen string literals may be +# default in future Ruby. The comment will be added below a shebang and +# encoding comment. The frozen string literal comment is only valid in Ruby 2.3+. +# +# Note that the cop will accept files where the comment exists but is set +# to `false` instead of `true`. +# +# To require a blank line after this comment, please see +# `Layout/EmptyLineAfterMagicComment` cop. +# +# @example EnforcedStyle: always (default) +# # The `always` style will always add the frozen string literal comment +# # to a file, regardless of the Ruby version or if `freeze` or `<<` are +# # called on a string literal. +# # bad +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: true +# +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: false +# +# module Bar +# # ... +# end +# @example EnforcedStyle: never +# # The `never` will enforce that the frozen string literal comment does +# # not exist in a file. +# # bad +# # frozen_string_literal: true +# +# module Baz +# # ... +# end +# +# # good +# module Baz +# # ... +# end +# @example EnforcedStyle: always_true +# # The `always_true` style enforces that the frozen string literal +# # comment is set to `true`. This is a stricter option than `always` +# # and forces projects to use frozen string literals. +# # bad +# # frozen_string_literal: false +# +# module Baz +# # ... +# end +# +# # bad +# module Baz +# # ... +# end +# +# # good +# # frozen_string_literal: true +# +# module Bar +# # ... +# end +# +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#84 +class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#99 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#178 + def disabled_offense(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#190 + def enable_comment(corrector); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#120 + def ensure_comment(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#126 + def ensure_enabled_comment(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#114 + def ensure_no_comment(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#214 + def following_comment; end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#152 + def frozen_string_literal_comment(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#196 + def insert_comment(corrector); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#137 + def last_special_comment(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#206 + def line_range(line); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#158 + def missing_offense(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#164 + def missing_true_offense(processed_source); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#210 + def preceding_comment; end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#186 + def remove_comment(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#170 + def unnecessary_comment_offense(processed_source); end +end + +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#96 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_DISABLED = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#94 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#93 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING_TRUE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#95 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#97 +RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil), String) + +# Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`. +# `STDOUT/STDERR/STDIN` are constants, and while you can actually +# reassign (possibly to redirect some stream) constants in Ruby, you'll get +# an interpreter warning if you do so. +# +# @example +# # bad +# STDOUT.puts('hello') +# +# hash = { out: STDOUT, key: value } +# +# def m(out = STDOUT) +# out.puts('hello') +# end +# +# # good +# $stdout.puts('hello') +# +# hash = { out: $stdout, key: value } +# +# def m(out = $stdout) +# out.puts('hello') +# end +# +# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#34 +class RuboCop::Cop::Style::GlobalStdStream < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#42 + def const_to_gvar_assignment?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#46 + def on_const(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#64 + def gvar_name(const_name); end + + # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#60 + def message(const_name); end +end + +# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#37 +RuboCop::Cop::Style::GlobalStdStream::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#39 +RuboCop::Cop::Style::GlobalStdStream::STD_STREAMS = T.let(T.unsafe(nil), Set) + +# Looks for uses of global variables. +# It does not report offenses for built-in global variables. +# Built-in global variables are allowed by default. Additionally +# users can allow additional variables via the AllowedVariables option. +# +# Note that backreferences like $1, $2, etc are not global variables. +# +# @example +# # bad +# $foo = 2 +# bar = $foo + 5 +# +# # good +# FOO = 2 +# foo = 2 +# $stdin.read +# +# source://rubocop//lib/rubocop/cop/style/global_vars.rb#22 +class RuboCop::Cop::Style::GlobalVars < ::RuboCop::Cop::Base + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/global_vars.rb#60 + def allowed_var?(global_var); end + + # source://rubocop//lib/rubocop/cop/style/global_vars.rb#72 + def check(node); end + + # source://rubocop//lib/rubocop/cop/style/global_vars.rb#64 + def on_gvar(node); end + + # source://rubocop//lib/rubocop/cop/style/global_vars.rb#68 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/global_vars.rb#56 + def user_vars; end +end + +# built-in global variables and their English aliases +# https://www.zenspider.com/ruby/quickref.html +# +# source://rubocop//lib/rubocop/cop/style/global_vars.rb#27 +RuboCop::Cop::Style::GlobalVars::BUILT_IN_VARS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/global_vars.rb#23 +RuboCop::Cop::Style::GlobalVars::MSG = T.let(T.unsafe(nil), String) + +# Use a guard clause instead of wrapping the code inside a conditional +# expression +# +# A condition with an `elsif` or `else` branch is allowed unless +# one of `return`, `break`, `next`, `raise`, or `fail` is used +# in the body of the conditional expression. +# +# NOTE: Autocorrect works in most cases except with if-else statements +# that contain logical operators such as `foo || raise('exception')` +# +# @example +# # bad +# def test +# if something +# work +# end +# end +# +# # good +# def test +# return unless something +# +# work +# end +# +# # also good +# def test +# work if something +# end +# +# # bad +# if something +# raise 'exception' +# else +# ok +# end +# +# # good +# raise 'exception' if something +# ok +# +# # bad +# if something +# foo || raise('exception') +# else +# ok +# end +# +# # good +# foo || raise('exception') if something +# ok +# +# # bad +# define_method(:test) do +# if something +# work +# end +# end +# +# # good +# define_method(:test) do +# return unless something +# +# work +# end +# +# # also good +# define_method(:test) do +# work if something +# end +# @example AllowConsecutiveConditionals: false (default) +# # bad +# def test +# if foo? +# work +# end +# +# if bar? # <- reports an offense +# work +# end +# end +# @example AllowConsecutiveConditionals: true +# # good +# def test +# if foo? +# work +# end +# +# if bar? +# work +# end +# end +# +# # bad +# def test +# if foo? +# work +# end +# +# do_something +# +# if bar? # <- reports an offense +# work +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/guard_clause.rb#114 +class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#132 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#123 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#123 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#139 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#132 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#275 + def accepted_form?(node, ending: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#283 + def accepted_if?(node, ending); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#297 + def allowed_consecutive_conditionals?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#265 + def and_or_guard_clause?(guard_clause); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#210 + def autocorrect(corrector, node, condition, replacement, guard); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#236 + def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#159 + def check_ending_body(body); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#170 + def check_ending_if(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#180 + def consecutive_conditionals?(parent, node); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#257 + def guard_clause_source(guard_clause); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#232 + def heredoc?(argument); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#248 + def range_of_branch_to_remove(node, guard); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#188 + def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#293 + def remove_whole_lines(corrector, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#270 + def too_long_for_single_line?(node, example); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#279 + def trivial?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/guard_clause.rb#120 +RuboCop::Cop::Style::GuardClause::MSG = T.let(T.unsafe(nil), String) + +# Checks for presence or absence of braces around hash literal as a last +# array item depending on configuration. +# +# NOTE: This cop will ignore arrays where all items are hashes, regardless of +# EnforcedStyle. +# +# @example EnforcedStyle: braces (default) +# # bad +# [1, 2, one: 1, two: 2] +# +# # good +# [1, 2, { one: 1, two: 2 }] +# +# # good +# [{ one: 1 }, { two: 2 }] +# @example EnforcedStyle: no_braces +# # bad +# [1, 2, { one: 1, two: 2 }] +# +# # good +# [1, 2, one: 1, two: 2] +# +# # good +# [{ one: 1 }, { two: 2 }] +# +# source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#31 +class RuboCop::Cop::Style::HashAsLastArrayItem < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#36 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#85 + def braces_style?; end + + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#66 + def check_braces(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#74 + def check_no_braces(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#50 + def containing_array(hash_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#61 + def explicit_array?(array); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#55 + def last_array_item?(array, node); end + + # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#89 + def remove_last_element_trailing_comma(corrector, node); end +end + +# Checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and +# sequences of values to hashes. +# +# Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example, +# `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated. +# So, `AllowSplatArgument` option is true by default to allow splat argument for simple code. +# +# @example +# # bad +# Hash[ary] +# +# # good +# ary.to_h +# +# # bad +# Hash[key1, value1, key2, value2] +# +# # good +# {key1 => value1, key2 => value2} +# @example AllowSplatArgument: true (default) +# # good +# Hash[*ary] +# @example AllowSplatArgument: false +# # bad +# Hash[*ary] +# +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#44 +class RuboCop::Cop::Style::HashConversion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#54 + def hash_from_array?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#56 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#138 + def allowed_splat_argument?; end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#131 + def args_to_hash(args); end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#118 + def multi_argument(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#94 + def register_offense_for_hash(node, hash_argument); end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#103 + def register_offense_for_zip_method(node, zip_method); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#113 + def requires_parens?(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#71 + def single_argument(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#88 + def use_zip_method_without_argument?(first_argument); end +end + +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#49 +RuboCop::Cop::Style::HashConversion::MSG_LITERAL_HASH_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#48 +RuboCop::Cop::Style::HashConversion::MSG_LITERAL_MULTI_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#50 +RuboCop::Cop::Style::HashConversion::MSG_SPLAT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#47 +RuboCop::Cop::Style::HashConversion::MSG_TO_H = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#51 +RuboCop::Cop::Style::HashConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `each_key` and `each_value` Hash methods. +# +# NOTE: If you have an array of two-element arrays, you can put +# parentheses around the block arguments to indicate that you're not +# working with a hash, and suppress RuboCop offenses. +# +# @example +# # bad +# hash.keys.each { |k| p k } +# hash.each { |k, unused_value| p k } +# +# # good +# hash.each_key { |k| p k } +# +# # bad +# hash.values.each { |v| p v } +# hash.each { |unused_key, v| p v } +# +# # good +# hash.each_value { |v| p v } +# @example AllowedReceivers: ['execute'] +# # good +# execute(sql).keys.each { |v| p v } +# execute(sql).values.each { |v| p v } +# +# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#36 +class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedReceivers + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#50 + def each_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#45 + def kv_each(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#55 + def kv_each_with_block_pass(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#60 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#83 + def on_block_pass(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#60 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#134 + def check_argument(variable); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#158 + def correct_args(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#144 + def correct_implicit(node, corrector, method_name); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#149 + def correct_key_value_each(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#130 + def format_message(method_name, current); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#165 + def kv_range(outer_node); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#106 + def message(prefer, method_name, unused_code); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#112 + def register_each_args_offense(node, message, prefer, unused_range); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#91 + def register_kv_offense(target, method); end + + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#119 + def register_kv_with_block_pass_offense(node, target, method); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#102 + def unused_block_arg_exist?(node, block_arg_source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#140 + def used?(arg); end +end + +# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#41 +RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#42 +RuboCop::Cop::Style::HashEachMethods::UNUSED_BLOCK_ARG_MSG = T.let(T.unsafe(nil), String) + +# Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods +# that can be replaced with `Hash#except` method. +# +# This cop should only be enabled on Ruby version 3.0 or higher. +# (`Hash#except` was added in Ruby 3.0.) +# +# For safe detection, it is limited to commonly used string and symbol comparisons +# when used `==`. +# And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object. +# +# @example +# +# # bad +# {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar } +# {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar } +# {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar } +# {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) } +# {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) } +# {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) } +# +# # good +# {foo: 1, bar: 2, baz: 3}.except(:bar) +# +# source://rubocop//lib/rubocop/cop/style/hash_except.rb#33 +class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::TargetRubyVersion + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#60 + def bad_method_with_active_support?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#44 + def bad_method_with_poro?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#75 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#93 + def bad_method?(block); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#165 + def decorate_source(value); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#173 + def except_key(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#152 + def except_key_source(key); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#146 + def extract_body_if_negated(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#127 + def included?(negated, body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#131 + def not_included?(negated, body); end + + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#182 + def offense_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#135 + def safe_to_register_offense?(block, except_key); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_except.rb#111 + def semantically_except_method?(send, block); end +end + +# source://rubocop//lib/rubocop/cop/style/hash_except.rb#40 +RuboCop::Cop::Style::HashExcept::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_except.rb#41 +RuboCop::Cop::Style::HashExcept::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where `case-when` represents a simple 1:1 +# mapping and can be replaced with a hash lookup. +# +# @example MinBranchesCount: 3 (default) +# # bad +# case country +# when 'europe' +# 'http://eu.example.com' +# when 'america' +# 'http://us.example.com' +# when 'australia' +# 'http://au.example.com' +# end +# +# # good +# SITES = { +# 'europe' => 'http://eu.example.com', +# 'america' => 'http://us.example.com', +# 'australia' => 'http://au.example.com' +# } +# SITES[country] +# @example MinBranchesCount: 4 +# # good +# case country +# when 'europe' +# 'http://eu.example.com' +# when 'america' +# 'http://us.example.com' +# when 'australia' +# 'http://au.example.com' +# end +# +# source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#39 +class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MinBranchesCount + + # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#45 + def hash_like_case?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#53 + def on_case(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#65 + def nodes_of_same_type?(nodes); end +end + +# source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#42 +RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) + +# Checks hash literal syntax. +# +# It can enforce either the use of the class hash rocket syntax or +# the use of the newer Ruby 1.9 syntax (when applicable). +# +# A separate offense is registered for each problematic pair. +# +# The supported styles are: +# +# * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have +# all symbols for keys +# * hash_rockets - forces use of hash rockets for all hashes +# * no_mixed_keys - simply checks for hashes with mixed syntaxes +# * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed +# syntax hashes +# +# This cop has `EnforcedShorthandSyntax` option. +# It can enforce either the use of the explicit hash value syntax or +# the use of Ruby 3.1's hash value shorthand syntax. +# +# The supported styles are: +# +# * always - forces use of the 3.1 syntax (e.g. {foo:}) +# * never - forces use of explicit hash literal value +# * either - accepts both shorthand and explicit use of hash literal value +# * consistent - forces use of the 3.1 syntax only if all values can be omitted in the hash +# +# @example EnforcedStyle: ruby19 (default) +# # bad +# {:a => 2} +# {b: 1, :c => 2} +# +# # good +# {a: 2, b: 1} +# {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol +# {d: 1, 'e' => 2} # technically not forbidden +# @example EnforcedStyle: hash_rockets +# # bad +# {a: 1, b: 2} +# {c: 1, 'd' => 5} +# +# # good +# {:a => 1, :b => 2} +# @example EnforcedStyle: no_mixed_keys +# # bad +# {:a => 1, b: 2} +# {c: 1, 'd' => 2} +# +# # good +# {:a => 1, :b => 2} +# {c: 1, d: 2} +# @example EnforcedStyle: ruby19_no_mixed_keys +# # bad +# {:a => 1, :b => 2} +# {c: 2, 'd' => 3} # should just use hash rockets +# +# # good +# {a: 1, b: 2} +# {:c => 3, 'd' => 4} +# @example EnforcedShorthandSyntax: always (default) +# +# # bad +# {foo: foo, bar: bar} +# +# # good +# {foo:, bar:} +# @example EnforcedShorthandSyntax: never +# +# # bad +# {foo:, bar:} +# +# # good +# {foo: foo, bar: bar} +# @example EnforcedShorthandSyntax: either +# +# # good +# {foo: foo, bar: bar} +# +# # good +# {foo: foo, bar:} +# +# # good +# {foo:, bar:} +# @example EnforcedShorthandSyntax: consistent +# +# # bad - `foo` and `bar` values can be omitted +# {foo: foo, bar: bar} +# +# # bad - `bar` value can be omitted +# {foo:, bar: bar} +# +# # bad - mixed syntaxes +# {foo:, bar: baz} +# +# # good +# {foo:, bar:} +# +# # good - can't omit `baz` +# {foo: foo, bar: baz} +# +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#113 +class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::HashShorthandSyntax + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#167 + def alternative_style; end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#145 + def hash_rockets_check(pairs); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#159 + def no_mixed_keys_check(pairs); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#123 + def on_hash(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#141 + def ruby19_check(pairs); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#149 + def ruby19_no_mixed_keys_check(pairs); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#198 + def acceptable_19_syntax_symbol?(sym_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#252 + def argument_without_space?(node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#178 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#256 + def autocorrect_hash_rockets(corrector, pair_node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#265 + def autocorrect_no_mixed_keys(corrector, pair_node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#231 + def autocorrect_ruby19(corrector, pair_node); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#216 + def check(pairs, delim, msg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#273 + def force_hash_rockets?(pairs); end + + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#244 + def range_for_autocorrect_ruby19(pair_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#188 + def sym_indices?(pairs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#192 + def word_symbol_pair?(pair); end +end + +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#119 +RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#121 +RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#120 +RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String) + +# Looks for uses of `\_.each_with_object({}) {...}`, +# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just +# transforming the keys of a hash, and tries to use a simpler & faster +# call to `transform_keys` instead. +# It should only be enabled on Ruby version 2.5 or newer. +# (`transform_keys` was added in Ruby 2.5.) +# +# @example +# # bad +# {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v } +# Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }] +# {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h +# {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] } +# +# # good +# {a: 1, b: 2}.transform_keys { |k| foo(k) } +# {a: 1, b: 2}.transform_keys { |k| k.to_s } +# +# source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#28 +class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashTransformMethod + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#36 + def on_bad_each_with_object(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#48 + def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#61 + def on_bad_map_to_h(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#73 + def on_bad_to_h(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#84 + def extract_captures(match); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#89 + def new_method_name; end +end + +# Looks for uses of `\_.each_with_object({}) {...}`, +# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just +# transforming the values of a hash, and tries to use a simpler & faster +# call to `transform_values` instead. +# +# @example +# # bad +# {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) } +# Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }] +# {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h +# {a: 1, b: 2}.to_h { |k, v| [k, v * v] } +# +# # good +# {a: 1, b: 2}.transform_values { |v| foo(v) } +# {a: 1, b: 2}.transform_values { |v| v * v } +# +# source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#26 +class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashTransformMethod + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#34 + def on_bad_each_with_object(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#46 + def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#59 + def on_bad_map_to_h(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#71 + def on_bad_to_h(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#82 + def extract_captures(match); end + + # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#87 + def new_method_name; end +end + +# Checks for identical expressions at the beginning or end of +# each branch of a conditional expression. Such expressions should normally +# be placed outside the conditional expression - before or after it. +# +# NOTE: The cop is poorly named and some people might think that it actually +# checks for duplicated conditional branches. The name will probably be changed +# in a future major RuboCop release. +# +# @example +# # bad +# if condition +# do_x +# do_z +# else +# do_y +# do_z +# end +# +# # good +# if condition +# do_x +# else +# do_y +# end +# do_z +# +# # bad +# if condition +# do_z +# do_x +# else +# do_z +# do_y +# end +# +# # good +# do_z +# if condition +# do_x +# else +# do_y +# end +# +# # bad +# case foo +# when 1 +# do_x +# when 2 +# do_x +# else +# do_x +# end +# +# # good +# case foo +# when 1 +# do_x +# do_y +# when 2 +# # nothing +# else +# do_x +# do_z +# end +# +# # bad +# case foo +# in 1 +# do_x +# in 2 +# do_x +# else +# do_x +# end +# +# # good +# case foo +# in 1 +# do_x +# do_y +# in 2 +# # nothing +# else +# do_x +# do_z +# end +# +# source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#110 +class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#123 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#130 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#116 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#181 + def assignable_condition_value(node); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#140 + def check_branches(node, branches); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#190 + def check_expressions(node, expressions, insert_position); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#170 + def duplicated_expressions?(node, expressions); end + + # `elsif` branches show up in the if node as nested `else` branches. We + # need to recursively iterate over all `else` branches. + # + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#230 + def expand_elses(branch); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#245 + def head(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#214 + def last_child_of_parent?(node); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#224 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#220 + def single_child_branch?(branch_node); end + + # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#241 + def tail(node); end +end + +# source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#114 +RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), String) + +# Corrector to correct conditional assignment in `if` statements. +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#560 +class RuboCop::Cop::Style::IfCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#565 + def correct(corrector, cop, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#569 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#583 + def extract_tail_branches(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#590 + def move_branch_inside_condition(corrector, branch, condition, assignment, column); end + end +end + +# If the `else` branch of a conditional consists solely of an `if` node, +# it can be combined with the `else` to become an `elsif`. +# This helps to keep the nesting level from getting too deep. +# +# @example +# # bad +# if condition_a +# action_a +# else +# if condition_b +# action_b +# else +# action_c +# end +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# else +# action_c +# end +# @example AllowIfModifier: false (default) +# # bad +# if condition_a +# action_a +# else +# action_b if condition_b +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# end +# @example AllowIfModifier: true +# # good +# if condition_a +# action_a +# else +# action_b if condition_b +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# end +# +# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#61 +class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#69 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#150 + def allow_if_modifier?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#146 + def allow_if_modifier_in_else_branch?(else_branch); end + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#88 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#117 + def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#109 + def correct_to_elsif_from_modifier_form(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#135 + def find_end_range(node); end + + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#142 + def if_condition_range(node, condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#131 + def then?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#66 +RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for `if` and `unless` statements that would fit on one line if +# written as modifier `if`/`unless`. The cop also checks for modifier +# `if`/`unless` lines that exceed the maximum line length. +# +# The maximum line length is configured in the `Layout/LineLength` +# cop. The tab size is configured in the `IndentationWidth` of the +# `Layout/IndentationStyle` cop. +# +# One-line pattern matching is always allowed. To ensure that there are few cases +# where the match variable is not used, and to prevent oversights. The variable `x` +# becomes undefined and raises `NameError` when the following example is changed to +# the modifier form: +# +# [source,ruby] +# ---- +# if [42] in [x] +# x # `x` is undefined when using modifier form. +# end +# ---- +# +# NOTE: It is allowed when `defined?` argument has an undefined value, +# because using the modifier form causes the following incompatibility: +# +# [source,ruby] +# ---- +# unless defined?(undefined_foo) +# undefined_foo = 'default_value' +# end +# undefined_foo # => 'default_value' +# +# undefined_bar = 'default_value' unless defined?(undefined_bar) +# undefined_bar # => nil +# ---- +# +# @example +# # bad +# if condition +# do_stuff(bar) +# end +# +# unless qux.empty? +# Foo.do_something +# end +# +# do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line +# +# # good +# do_stuff(bar) if condition +# Foo.do_something unless qux.empty? +# +# if long_condition_that_prevents_code_fit_on_single_line +# do_something_with_a_long_name(arg) +# end +# +# if short_condition # a long comment that makes it too long if it were just a single line +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#63 +class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::CommentsHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#80 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#171 + def allowed_patterns; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#231 + def another_statement_on_same_line?(node); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#132 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#285 + def comment_on_node_line(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#104 + def defined_argument_is_undefined?(if_node, defined_node); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#96 + def defined_nodes(condition); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#272 + def extract_heredoc_from(last_argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#215 + def line_length_enabled_at_line?(line); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#124 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#219 + def named_capture_in_condition?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#223 + def non_eligible_node?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#227 + def non_simple_if_unless?(node); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#114 + def pattern_matching_nodes(condition); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#289 + def remove_comment(corrector, _node, comment); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#279 + def remove_heredoc(corrector, heredoc); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#141 + def replacement_for_modifier_form(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#265 + def to_modifier_form_with_move_comment(node, indentation, comment); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#245 + def to_normal_form(node, indentation); end + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#253 + def to_normal_form_with_heredoc(node, indentation, heredoc); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#165 + def too_long_due_to_comment_after_modifier?(node, comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#160 + def too_long_due_to_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#206 + def too_long_line_based_on_allow_uri?(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#189 + def too_long_line_based_on_config?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#198 + def too_long_line_based_on_ignore_cop_directives?(range, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#176 + def too_long_single_line?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#76 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#71 +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#74 +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) + +# Checks for if and unless statements used as modifiers of other if or +# unless statements. +# +# @example +# +# # bad +# tired? ? 'stop' : 'go faster' if running? +# +# # bad +# if tired? +# "please stop" +# else +# "keep going" +# end if running? +# +# # good +# if running? +# tired? ? 'stop' : 'go faster' +# end +# +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#25 +class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#31 + def on_if(node); end +end + +# source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#29 +RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant `if` with boolean literal branches. +# It checks only conditions to return boolean value (`true` or `false`) for safe detection. +# The conditions to be checked are comparison methods, predicate methods, and +# double negation (!!). +# `nonzero?` method is allowed by default. +# These are customizable with `AllowedMethods` option. +# +# This cop targets only `if`s with a single `elsif` or `else` branch. The following +# code will be allowed, because it has two `elsif` branches: +# +# [source,ruby] +# ---- +# if foo +# true +# elsif bar > baz +# true +# elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not. +# true +# else +# false +# end +# ---- +# +# @example +# # bad +# if foo == bar +# true +# else +# false +# end +# +# # bad +# foo == bar ? true : false +# +# # good +# foo == bar +# @example +# # bad +# if foo.do_something? +# true +# else +# false +# end +# +# # good (but potentially an unsafe correction) +# foo.do_something? +# @example AllowedMethods: ['nonzero?'] (default) +# # good +# num.nonzero? ? true : false +# +# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#62 +class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#74 + def double_negative?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#70 + def if_with_boolean_literal_branches?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#76 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#134 + def assume_boolean_value?(condition); end + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#114 + def message(node, keyword); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#96 + def multiple_elsif?(node); end + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#102 + def offense_range_with_keyword(node, condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#151 + def opposite_condition?(node); end + + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#141 + def replacement_condition(node, condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#156 + def require_parentheses?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#120 + def return_boolean_value?(condition); end +end + +# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#66 +RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#67 +RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG_FOR_ELSIF = T.let(T.unsafe(nil), String) + +# Checks for uses of semicolon in if statements. +# +# @example +# +# # bad +# result = if some_condition; something else another_thing end +# +# # good +# result = some_condition ? something : another_thing +# +# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#16 +class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#23 + def on_normal_if_unless(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#38 + def autocorrect(node); end + + # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#56 + def build_else_branch(second_condition); end + + # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#47 + def correct_elsif(node); end +end + +# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#20 +RuboCop::Cop::Style::IfWithSemicolon::MSG_IF_ELSE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#21 +RuboCop::Cop::Style::IfWithSemicolon::MSG_TERNARY = T.let(T.unsafe(nil), String) + +# Checks for `raise` or `fail` statements which do not specify an +# explicit exception class. (This raises a `RuntimeError`. Some projects +# might prefer to use exception classes which more precisely identify the +# nature of the error.) +# +# @example +# # bad +# raise 'Error message here' +# +# # good +# raise ArgumentError, 'Error message here' +# +# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#17 +class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#23 + def implicit_runtime_error_raise_or_fail(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#26 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#18 +RuboCop::Cop::Style::ImplicitRuntimeError::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#20 +RuboCop::Cop::Style::ImplicitRuntimeError::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `in;` uses in `case` expressions. +# +# @example +# # bad +# case expression +# in pattern_a; foo +# in pattern_b; bar +# end +# +# # good +# case expression +# in pattern_a then foo +# in pattern_b then bar +# end +# +# source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#21 +class RuboCop::Cop::Style::InPatternThen < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#29 + def on_in_pattern(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#46 + def alternative_pattern_source(pattern); end +end + +# source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#27 +RuboCop::Cop::Style::InPatternThen::MSG = T.let(T.unsafe(nil), String) + +# Use `Kernel#loop` for infinite loops. +# +# @example +# # bad +# while true +# work +# end +# +# # good +# loop do +# work +# end +# +# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#23 +class RuboCop::Cop::Style::InfiniteLoop < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#35 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#44 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#44 + def on_until_post(node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#40 + def on_while(node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#40 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#84 + def assigned_before_loop?(var, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#80 + def assigned_inside_loop?(var, range); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#70 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#103 + def modifier_replacement(node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#114 + def non_modifier_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#89 + def referenced_after_loop?(var, range); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#94 + def replace_begin_end_with_modifier(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#99 + def replace_source(corrector, range, replacement); end + + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#53 + def while_or_until(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#31 + def joining_forces; end + end +end + +# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#27 +RuboCop::Cop::Style::InfiniteLoop::LEADING_SPACE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#29 +RuboCop::Cop::Style::InfiniteLoop::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing inline comments. +# +# @example +# +# # good +# foo.each do |f| +# # Standalone comment +# f.bar +# end +# +# # bad +# foo.each do |f| +# f.bar # Trailing inline comment +# end +# +# source://rubocop//lib/rubocop/cop/style/inline_comment.rb#20 +class RuboCop::Cop::Style::InlineComment < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/inline_comment.rb#23 + def on_new_investigation; end +end + +# source://rubocop//lib/rubocop/cop/style/inline_comment.rb#21 +RuboCop::Cop::Style::InlineComment::MSG = T.let(T.unsafe(nil), String) + +# Check for usages of not (`not` or `!`) called on a method +# when an inverse of that method can be used instead. +# +# Methods that can be inverted by a not (`not` or `!`) should be defined +# in `InverseMethods`. +# +# Methods that are inverted by inverting the return +# of the block that is passed to the method should be defined in +# `InverseBlocks`. +# +# @example +# # bad +# !foo.none? +# !foo.any? { |f| f.even? } +# !foo.blank? +# !(foo == bar) +# foo.select { |f| !f.even? } +# foo.reject { |f| f != 7 } +# +# # good +# foo.none? +# foo.blank? +# foo.any? { |f| f.even? } +# foo != bar +# foo == bar +# !!('foo' =~ /^\w+$/) +# !(foo.class < Numeric) # Checking class hierarchy is allowed +# # Blocks with guard clauses are ignored: +# foo.select do |f| +# next if f.zero? +# f != 1 +# end +# +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#43 +class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#70 + def inverse_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#61 + def inverse_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#92 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#78 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#92 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#78 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#177 + def camel_case_constant?(node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#121 + def correct_inverse_block(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#112 + def correct_inverse_method(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#128 + def correct_inverse_selector(block, corrector); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#181 + def dot_range(loc); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#164 + def end_parentheses(node, method_call); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#150 + def inverse_blocks; end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#145 + def inverse_methods; end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#191 + def message(method, inverse); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#154 + def negated?(node); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#158 + def not_to_receiver(node, method_call); end + + # When comparing classes, `!(Integer < Numeric)` is not the same as + # `Integer > Numeric`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#172 + def possible_class_hierarchy_check?(lhs, rhs, method); end + + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#185 + def remove_end_parenthesis(corrector, node, method, method_call); end + + class << self + # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#56 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#52 +RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#49 +RuboCop::Cop::Style::InverseMethods::CLASS_COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#50 +RuboCop::Cop::Style::InverseMethods::EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#48 +RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#51 +RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#54 +RuboCop::Cop::Style::InverseMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for usages of `unless` which can be replaced by `if` with inverted condition. +# Code without `unless` is easier to read, but that is subjective, so this cop +# is disabled by default. +# +# Methods that can be inverted should be defined in `InverseMethods`. Note that +# the relationship of inverse methods needs to be defined in both directions. +# For example, +# +# [source,yaml] +# ---- +# InverseMethods: +# :!=: :== +# :even?: :odd? +# :odd?: :even? +# ---- +# +# will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`). +# +# @example +# # bad (simple condition) +# foo unless !bar +# foo unless x != y +# foo unless x >= 10 +# foo unless x.even? +# +# # good +# foo if bar +# foo if x == y +# foo if x < 10 +# foo if x.odd? +# +# # bad (complex condition) +# foo unless x != y || x.even? +# +# # good +# foo if x == y && x.odd? +# +# # good (if) +# foo if !condition +# +# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#51 +class RuboCop::Cop::Style::InvertibleUnlessCondition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#56 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#91 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#104 + def autocorrect_send_node(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#85 + def inheritance_check?(node); end + + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#112 + def inverse_methods; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#70 + def invertible?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#54 +RuboCop::Cop::Style::InvertibleUnlessCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for hardcoded IP addresses, which can make code +# brittle. IP addresses are likely to need to be changed when code +# is deployed to a different server or environment, which may break +# a deployment if forgotten. Prefer setting IP addresses in ENV or +# other configuration. +# +# @example +# +# # bad +# ip_address = '127.59.241.29' +# +# # good +# ip_address = ENV['DEPLOYMENT_IP_ADDRESS'] +# +# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#21 +class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::StringHelp + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#46 + def correct_style_detected; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#27 + def offense?(node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#42 + def opposite_style_detected; end + + private + + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#50 + def allowed_addresses; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#55 + def could_be_ip?(str); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#68 + def starts_with_hex_or_colon?(str); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#64 + def too_long?(str); end +end + +# IPv4-mapped IPv6 is the longest +# +# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#24 +RuboCop::Cop::Style::IpAddresses::IPV6_MAX_SIZE = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#25 +RuboCop::Cop::Style::IpAddresses::MSG = T.let(T.unsafe(nil), String) + +# Enforces that optional keyword parameters are placed at the +# end of the parameters list. +# +# This improves readability, because when looking through the source, +# it is expected to find required parameters at the beginning of parameters list +# and optional parameters at the end. +# +# @example +# # bad +# def some_method(first: false, second:, third: 10) +# # body omitted +# end +# +# # good +# def some_method(second:, first: false, third: 10) +# # body omitted +# end +# +# # bad +# do_something do |first: false, second:, third: 10| +# # body omitted +# end +# +# # good +# do_something do |second:, first: false, third: 10| +# # body omitted +# end +# +# source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#34 +class RuboCop::Cop::Style::KeywordParametersOrder < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#40 + def on_kwoptarg(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#58 + def append_newline_to_last_kwoptarg(arguments, corrector); end + + # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#66 + def remove_kwargs(kwarg_nodes, corrector); end +end + +# source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#38 +RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String) + +# (by default) checks for uses of the lambda literal syntax for +# single line lambdas, and the method call syntax for multiline lambdas. +# It is configurable to enforce one of the styles for both single line +# and multiline lambdas as well. +# +# @example EnforcedStyle: line_count_dependent (default) +# # bad +# f = lambda { |x| x } +# f = ->(x) do +# x +# end +# +# # good +# f = ->(x) { x } +# f = lambda do |x| +# x +# end +# @example EnforcedStyle: lambda +# # bad +# f = ->(x) { x } +# f = ->(x) do +# x +# end +# +# # good +# f = lambda { |x| x } +# f = lambda do |x| +# x +# end +# @example EnforcedStyle: literal +# # bad +# f = lambda { |x| x } +# f = lambda do |x| +# x +# end +# +# # good +# f = ->(x) { x } +# f = ->(x) do +# x +# end +# +# source://rubocop//lib/rubocop/cop/style/lambda.rb#49 +class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#64 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#64 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#115 + def arguments_with_whitespace(node); end + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#104 + def autocorrect_method_to_literal(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#119 + def lambda_arg_string(args); end + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#89 + def message(node, selector); end + + # source://rubocop//lib/rubocop/cop/style/lambda.rb#95 + def message_line_modifier(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/lambda.rb#83 + def offending_selector?(node, selector); end +end + +# source://rubocop//lib/rubocop/cop/style/lambda.rb#53 +RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/lambda.rb#54 +RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/lambda.rb#56 +RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +# Checks for use of the lambda.(args) syntax. +# +# @example EnforcedStyle: call (default) +# # bad +# lambda.(x, y) +# +# # good +# lambda.call(x, y) +# @example EnforcedStyle: braces +# # bad +# lambda.call(x, y) +# +# # good +# lambda.(x, y) +# +# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#21 +class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#29 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#67 + def explicit_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#63 + def implicit_style?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#51 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#55 + def prefer(node); end +end + +# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#26 +RuboCop::Cop::Style::LambdaCall::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#27 +RuboCop::Cop::Style::LambdaCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for string literal concatenation at +# the end of a line. +# +# @example +# +# # bad +# some_str = 'ala' + +# 'bala' +# +# some_str = 'ala' << +# 'bala' +# +# # good +# some_str = 'ala' \ +# 'bala' +# +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#35 +class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#51 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#74 + def autocorrect(corrector, operator_range); end + + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#57 + def check_token_set(index); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#101 + def eligible_next_successor?(next_successor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#97 + def eligible_operator?(operator); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#105 + def eligible_predecessor?(predecessor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#93 + def eligible_successor?(successor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#87 + def eligible_token_set?(predecessor, operator, successor); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#124 + def standard_string_literal?(token); end + + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#109 + def token_after_last_string(successor, base_index); end + + class << self + # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#47 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#42 +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#43 +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_END_TOKEN = T.let(T.unsafe(nil), Symbol) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#40 +RuboCop::Cop::Style::LineEndConcatenation::CONCAT_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#44 +RuboCop::Cop::Style::LineEndConcatenation::HIGH_PRECEDENCE_OP_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#39 +RuboCop::Cop::Style::LineEndConcatenation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#45 +RuboCop::Cop::Style::LineEndConcatenation::QUOTE_DELIMITERS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#41 +RuboCop::Cop::Style::LineEndConcatenation::SIMPLE_STRING_TOKEN_TYPE = T.let(T.unsafe(nil), Symbol) + +# Ensures magic comments are written consistently throughout your code base. +# Looks for discrepancies in separators (`-` vs `_`) and capitalization for +# both magic comment directives and values. +# +# Required capitalization can be set with the `DirectiveCapitalization` and +# `ValueCapitalization` configuration keys. +# +# NOTE: If one of these configuration is set to nil, any capitalization is allowed. +# +# @example EnforcedStyle: snake_case (default) +# # The `snake_case` style will enforce that the frozen string literal +# # comment is written in snake case. (Words separated by underscores) +# # bad +# # frozen-string-literal: true +# +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: false +# +# module Bar +# # ... +# end +# @example EnforcedStyle: kebab_case +# # The `kebab_case` style will enforce that the frozen string literal +# # comment is written in kebab case. (Words separated by hyphens) +# # bad +# # frozen_string_literal: true +# +# module Baz +# # ... +# end +# +# # good +# # frozen-string-literal: true +# +# module Baz +# # ... +# end +# @example DirectiveCapitalization: lowercase (default) +# # bad +# # FROZEN-STRING-LITERAL: true +# +# # good +# # frozen-string-literal: true +# @example DirectiveCapitalization: uppercase +# # bad +# # frozen-string-literal: true +# +# # good +# # FROZEN-STRING-LITERAL: true +# @example DirectiveCapitalization: nil +# # any capitalization is accepted +# +# # good +# # frozen-string-literal: true +# +# # good +# # FROZEN-STRING-LITERAL: true +# @example ValueCapitalization: nil (default) +# # any capitalization is accepted +# +# # good +# # frozen-string-literal: true +# +# # good +# # frozen-string-literal: TRUE +# @example ValueCapitalization: lowercase +# # when a value is not given, any capitalization is accepted +# +# # bad +# # frozen-string-literal: TRUE +# +# # good +# # frozen-string-literal: TRUE +# @example ValueCapitalization: uppercase +# # bad +# # frozen-string-literal: true +# +# # good +# # frozen-string-literal: TRUE +# +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#97 +class RuboCop::Cop::Style::MagicCommentFormat < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#156 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#241 + def correct_separator; end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#279 + def directive_capitalization; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#197 + def directive_offends?(directive); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#233 + def expected_style; end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#183 + def find_issues(comment); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#207 + def fix_directives(issues); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#221 + def fix_values(issues); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#245 + def incorrect_separator?(text); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#173 + def leading_comment_lines; end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#275 + def line_range(line); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#167 + def magic_comments; end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#202 + def register_offenses(issues); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#264 + def replace_capitalization(text, style); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#260 + def replace_separator(text); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#301 + def supported_capitalizations; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#295 + def valid_capitalization?(style); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#287 + def value_capitalization; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#249 + def wrong_capitalization?(text, expected_case); end + + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#237 + def wrong_separator; end +end + +# Value object to extract source ranges for the different parts of a magic comment +# +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#107 +class RuboCop::Cop::Style::MagicCommentFormat::CommentRange + extend ::Forwardable + + # @return [CommentRange] a new instance of CommentRange + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#119 + def initialize(comment); end + + # Returns the value of attribute comment. + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#117 + def comment; end + + # A magic comment can contain one directive (normal style) or + # multiple directives (emacs style) + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#125 + def directives; end + + # source://forwardable/1.3.2/forwardable.rb#229 + def loc(*args, **_arg1, &block); end + + # source://forwardable/1.3.2/forwardable.rb#229 + def text(*args, **_arg1, &block); end + + # A magic comment can contain one value (normal style) or + # multiple directives (emacs style) + # + # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#141 + def values; end +end + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#110 +RuboCop::Cop::Style::MagicCommentFormat::CommentRange::DIRECTIVE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#114 +RuboCop::Cop::Style::MagicCommentFormat::CommentRange::VALUE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#102 +RuboCop::Cop::Style::MagicCommentFormat::KEBAB_SEPARATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#103 +RuboCop::Cop::Style::MagicCommentFormat::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#104 +RuboCop::Cop::Style::MagicCommentFormat::MSG_VALUE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#101 +RuboCop::Cop::Style::MagicCommentFormat::SNAKE_SEPARATOR = T.let(T.unsafe(nil), String) + +# Prefer `select` or `reject` over `map { ... }.compact`. +# +# @example +# +# # bad +# array.map { |e| some_condition? ? e : next }.compact +# +# # bad +# array.map do |e| +# if some_condition? +# e +# else +# next +# end +# end.compact +# +# # bad +# array.map do |e| +# next if some_condition? +# +# e +# end.compact +# +# # bad +# array.map do |e| +# e if some_condition? +# end.compact +# +# # good +# array.select { |e| some_condition? } +# +# # good +# array.reject { |e| some_condition? } +# +# source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#40 +class RuboCop::Cop::Style::MapCompactWithConditionalBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#46 + def map_and_compact?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#72 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#125 + def range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#91 + def returns_block_argument?(block_argument_node, return_value_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#95 + def truthy_branch?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#115 + def truthy_branch_for_guard?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#105 + def truthy_branch_for_if?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#43 +RuboCop::Cop::Style::MapCompactWithConditionalBlock::MSG = T.let(T.unsafe(nil), String) + +# Looks for uses of `map.to_h` or `collect.to_h` that could be +# written with just `to_h` in Ruby >= 2.6. +# +# NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will +# also change this pattern if only hash keys or hash values are being +# transformed. +# +# @example +# # bad +# something.map { |v| [v, v * 2] }.to_h +# +# # good +# something.to_h { |v| [v, v * 2] } +# +# # bad +# {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h +# +# # good +# {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] } +# +# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#30 +class RuboCop::Cop::Style::MapToHash < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#41 + def map_to_h?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#52 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#52 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#67 + def autocorrect(corrector, to_h, map); end + + class << self + # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#48 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#37 +RuboCop::Cop::Style::MapToHash::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#38 +RuboCop::Cop::Style::MapToHash::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for uses of `map.to_set` or `collect.to_set` that could be +# written with just `to_set`. +# +# @example +# # bad +# something.map { |i| i * 2 }.to_set +# +# # good +# something.to_set { |i| i * 2 } +# +# # bad +# [1, 2, 3].collect { |i| i.to_s }.to_set +# +# # good +# [1, 2, 3].to_set { |i| i.to_s } +# +# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#26 +class RuboCop::Cop::Style::MapToSet < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#34 + def map_to_set?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#41 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#55 + def autocorrect(corrector, to_set, map); end +end + +# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#30 +RuboCop::Cop::Style::MapToSet::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#31 +RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the presence (default) or absence of parentheses in +# method calls containing parameters. +# +# In the default style (require_parentheses), macro methods are allowed. +# Additional methods can be added to the `AllowedMethods` or +# `AllowedPatterns` list. These options are valid only in the default +# style. Macros can be included by either setting `IgnoreMacros` to false +# or adding specific macros to the `IncludedMacros` list. +# +# Precedence of options is as follows: +# +# 1. `AllowedMethods` +# 2. `AllowedPatterns` +# 3. `IncludedMacros` +# +# If a method is listed in both `IncludedMacros` and `AllowedMethods`, +# then the latter takes precedence (that is, the method is allowed). +# +# In the alternative style (omit_parentheses), there are three additional +# options. +# +# 1. `AllowParenthesesInChaining` is `false` by default. Setting it to +# `true` allows the presence of parentheses in the last call during +# method chaining. +# +# 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it +# to `true` allows the presence of parentheses in multi-line method +# calls. +# +# 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This +# allows the presence of parentheses when calling a method whose name +# begins with a capital letter and which has no arguments. Setting it +# to `true` allows the presence of parentheses in such a method call +# even with arguments. +# +# NOTE: The style of `omit_parentheses` allows parentheses in cases where +# omitting them results in ambiguous or syntactically incorrect code. +# +# Non-exhaustive list of examples: +# +# - Parentheses are required allowed in method calls with arguments inside +# literals, logical operators, setting default values in position and +# keyword arguments, chaining and more. +# - Parentheses are allowed in method calls with arguments inside +# operators to avoid ambiguity. +# triple-dot syntax introduced in Ruby 2.7 as omitting them starts an +# endless range. +# - Parentheses are allowed when forwarding arguments with the +# triple-dot syntax introduced in Ruby 2.7 as omitting them starts an +# endless range. +# - Parentheses are required in calls with arguments when inside an +# endless method definition introduced in Ruby 3.0. +# - Ruby 3.1's hash omission syntax allows parentheses if the method call +# is in conditionals and requires parentheses if the call +# is not the value-returning expression. See +# https://bugs.ruby-lang.org/issues/18396. +# - Parentheses are required in anonymous arguments, keyword arguments +# and block passing in Ruby 3.2. +# +# @example EnforcedStyle: require_parentheses (default) +# +# # bad +# array.delete e +# +# # good +# array.delete(e) +# +# # good +# # Operators don't need parens +# foo == bar +# +# # good +# # Setter methods don't need parens +# foo.bar = baz +# +# # okay with `puts` listed in `AllowedMethods` +# puts 'test' +# +# # okay with `^assert` listed in `AllowedPatterns` +# assert_equal 'test', x +# @example EnforcedStyle: omit_parentheses +# +# # bad +# array.delete(e) +# +# # good +# array.delete e +# +# # bad +# action.enforce(strict: true) +# +# # good +# action.enforce strict: true +# +# # good +# # Parentheses are allowed for code that can be ambiguous without +# # them. +# action.enforce(condition) || other_condition +# +# # good +# # Parentheses are allowed for calls that won't produce valid Ruby +# # without them. +# yield path, File.basename(path) +# +# # good +# # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead +# # to ambiguous code. We allow them in conditionals and non-last +# # expressions. See https://bugs.ruby-lang.org/issues/18396 +# if meets(criteria:, action:) +# safe_action(action) || dangerous_action(action) +# end +# @example IgnoreMacros: true (default) +# +# # good +# class Foo +# bar :baz +# end +# @example IgnoreMacros: false +# +# # bad +# class Foo +# bar :baz +# end +# @example AllowParenthesesInMultilineCall: false (default) +# +# # bad +# foo.enforce( +# strict: true +# ) +# +# # good +# foo.enforce \ +# strict: true +# @example AllowParenthesesInMultilineCall: true +# +# # good +# foo.enforce( +# strict: true +# ) +# +# # good +# foo.enforce \ +# strict: true +# @example AllowParenthesesInChaining: false (default) +# +# # bad +# foo().bar(1) +# +# # good +# foo().bar 1 +# @example AllowParenthesesInChaining: true +# +# # good +# foo().bar(1) +# +# # good +# foo().bar 1 +# @example AllowParenthesesInCamelCaseMethod: false (default) +# +# # bad +# Array(1) +# +# # good +# Array 1 +# @example AllowParenthesesInCamelCaseMethod: true +# +# # good +# Array(1) +# +# # good +# Array 1 +# @example AllowParenthesesInStringInterpolation: false (default) +# +# # bad +# "#{t('this.is.bad')}" +# +# # good +# "#{t 'this.is.better'}" +# @example AllowParenthesesInStringInterpolation: true +# +# # good +# "#{t('this.is.good')}" +# +# # good +# "#{t 'this.is.also.good'}" +# +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#202 +class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 + def on_super(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217 + def on_yield(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#226 + def args_begin(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#235 + def args_end(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#239 + def args_parenthesized?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#213 + def autocorrect_incompatible_with; end + end +end + +# Style omit_parentheses +# +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#9 +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#70 + def allowed_camel_case_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#165 + def allowed_chained_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#161 + def allowed_multiline_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#75 + def allowed_string_interpolation_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#174 + def ambiguous_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#203 + def assigned_before?(node, target); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#211 + def assignment_in_condition?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#31 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#142 + def call_as_argument_or_chain?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#99 + def call_in_literals?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#110 + def call_in_logical_operators?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#148 + def call_in_match_pattern?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#119 + def call_in_optional_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#123 + def call_in_single_line_inheritance?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#127 + def call_with_ambiguous_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#138 + def call_with_braced_block?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#221 + def forwards_anonymous_rest_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#190 + def hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#154 + def hash_literal_in_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#44 + def inside_endless_method_def?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#207 + def inside_string_interpolation?(node); end + + # Require hash value omission be enclosed in parentheses to prevent the following issue: + # https://bugs.ruby-lang.org/issues/18396. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#58 + def last_expression?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#87 + def legitimate_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#186 + def logical_operator?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#40 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#16 + def omit_parentheses(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#80 + def parentheses_at_the_end_of_multiline_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#194 + def regexp_slash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#49 + def require_parentheses_for_hash_value_omission?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#178 + def splat?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#66 + def super_call_without_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#62 + def syntax_like_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#182 + def ternary_if?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#198 + def unary_literal?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#11 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::OMIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#10 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp) + +# Style require_parentheses +# +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#8 +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#27 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#31 + def eligible_for_parentheses_omission?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#39 + def ignored_macro?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#35 + def included_macros_list; end + + # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#14 + def require_parentheses(node); end +end + +# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#9 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses::REQUIRE_MSG = T.let(T.unsafe(nil), String) + +# Checks for unwanted parentheses in parameterless method calls. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# @example +# # bad +# object.some_method() +# +# # good +# object.some_method +# @example AllowedMethods: [] (default) +# # bad +# object.foo() +# @example AllowedMethods: [foo] +# # good +# object.foo() +# +# source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#26 +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#33 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#60 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#74 + def any_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#56 + def default_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#52 + def ineligible_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#97 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#45 + def register_offense(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#64 + def same_name_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#90 + def variable_in_mass_assignment?(variable_name, node); end +end + +# source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#31 +RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for methods called on a do...end block. The point of +# this check is that it's easy to miss the call tacked on to the block +# when reading code. +# +# @example +# # bad +# a do +# b +# end.c +# +# # good +# a { b }.c +# +# # good +# foo = a do +# b +# end +# foo.c +# +# source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#24 +class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#29 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#40 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#29 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#40 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#27 +RuboCop::Cop::Style::MethodCalledOnDoEndBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for parentheses around the arguments in method +# definitions. Both instance and class/singleton methods are checked. +# +# Regardless of style, parentheses are necessary for: +# +# 1. Endless methods +# 2. Argument lists containing a `forward-arg` (`...`) +# 3. Argument lists containing an anonymous rest arguments forwarding (`*`) +# 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`) +# 5. Argument lists containing an anonymous block forwarding (`&`) +# +# Removing the parens would be a syntax error here. +# +# @example EnforcedStyle: require_parentheses (default) +# # The `require_parentheses` style requires method definitions +# # to always use parentheses +# +# # bad +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# +# # good +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# @example EnforcedStyle: require_no_parentheses +# # The `require_no_parentheses` style requires method definitions +# # to never use parentheses +# +# # bad +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# +# # good +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# @example EnforcedStyle: require_no_parentheses_except_multiline +# # The `require_no_parentheses_except_multiline` style prefers no +# # parentheses when method definition arguments fit on single line, +# # but prefers parentheses when arguments span multiple lines. +# +# # bad +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# +# # good +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# +# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#97 +class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#105 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#105 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#169 + def anonymous_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#147 + def arguments_without_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#126 + def correct_arguments(arg_node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#131 + def forced_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#151 + def missing_parentheses(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#142 + def require_parentheses?(args); end + + # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#161 + def unwanted_parentheses(args); end +end + +# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#103 +RuboCop::Cop::Style::MethodDefParentheses::MSG_MISSING = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#102 +RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), String) + +# Checks for potential uses of `Enumerable#minmax`. +# +# @example +# +# # bad +# bar = [foo.min, foo.max] +# return foo.min, foo.max +# +# # good +# bar = foo.minmax +# return foo.minmax +# +# source://rubocop//lib/rubocop/cop/style/min_max.rb#17 +class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#38 + def min_max_candidate(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#22 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#22 + def on_return(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#55 + def argument_range(node); end + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#42 + def message(offender, receiver); end + + # source://rubocop//lib/rubocop/cop/style/min_max.rb#46 + def offending_range(node); end +end + +# source://rubocop//lib/rubocop/cop/style/min_max.rb#20 +RuboCop::Cop::Style::MinMax::MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of `max` or `min` instead of comparison for greater or less. +# +# NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+. +# That it is slow though. So autocorrection will apply generic `max` or `min`: +# +# [source,ruby] +# ---- +# a.clamp(b..) # Same as `[a, b].max` +# a.clamp(..b) # Same as `[a, b].min` +# ---- +# +# @example +# +# # bad +# a > b ? a : b +# a >= b ? a : b +# +# # good +# [a, b].max +# +# # bad +# a < b ? a : b +# a <= b ? a : b +# +# # good +# [a, b].min +# +# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#37 +class RuboCop::Cop::Style::MinMaxComparison < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#46 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#72 + def autocorrect(corrector, node, replacement); end + + # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#64 + def preferred_method(operator, lhs, rhs, if_branch, else_branch); end +end + +# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#44 +RuboCop::Cop::Style::MinMaxComparison::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#42 +RuboCop::Cop::Style::MinMaxComparison::GRATER_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#43 +RuboCop::Cop::Style::MinMaxComparison::LESS_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#41 +RuboCop::Cop::Style::MinMaxComparison::MSG = T.let(T.unsafe(nil), String) + +# Checks for `if` expressions that do not have an `else` branch. +# +# NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`, +# it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`. +# +# Supported styles are: if, case, both. +# +# @example EnforcedStyle: both (default) +# # warn when an `if` or `case` expression is missing an `else` branch. +# +# # bad +# if condition +# statement +# end +# +# # bad +# case var +# when condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# @example EnforcedStyle: if +# # warn when an `if` expression is missing an `else` branch. +# +# # bad +# if condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# case var +# when condition +# statement +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# @example EnforcedStyle: case +# # warn when a `case` expression is missing an `else` branch. +# +# # bad +# case var +# when condition +# statement +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# if condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# source://rubocop//lib/rubocop/cop/style/missing_else.rb#99 +class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#115 + def on_case(node); end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#121 + def on_case_match(node); end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#108 + def on_normal_if_unless(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#146 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#159 + def case_style?; end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#127 + def check(node); end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#181 + def empty_else_config; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#171 + def empty_else_cop_enabled?; end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#175 + def empty_else_style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#155 + def if_style?; end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#135 + def message_template; end + + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#167 + def unless_else_config; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/missing_else.rb#163 + def unless_else_cop_enabled?; end +end + +# source://rubocop//lib/rubocop/cop/style/missing_else.rb#104 +RuboCop::Cop::Style::MissingElse::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/missing_else.rb#106 +RuboCop::Cop::Style::MissingElse::MSG_EMPTY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/missing_else.rb#105 +RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String) + +# Checks for the presence of `method_missing` without also +# defining `respond_to_missing?`. +# +# @example +# # bad +# def method_missing(name, *args) +# # ... +# end +# +# # good +# def respond_to_missing?(name, include_private) +# # ... +# end +# +# def method_missing(name, *args) +# # ... +# end +# +# source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#24 +class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#27 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#27 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#37 + def implements_respond_to_missing?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#25 +RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String) + +# Checks for grouping of mixins in `class` and `module` bodies. +# By default it enforces mixins to be placed in separate declarations, +# but it can be configured to enforce grouping them in one declaration. +# +# @example EnforcedStyle: separated (default) +# # bad +# class Foo +# include Bar, Qox +# end +# +# # good +# class Foo +# include Qox +# include Bar +# end +# @example EnforcedStyle: grouped +# # bad +# class Foo +# extend Bar +# extend Qox +# end +# +# # good +# class Foo +# extend Qox, Bar +# end +# +# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#33 +class RuboCop::Cop::Style::MixinGrouping < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#40 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#40 + def on_module(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#64 + def check(send_node); end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#72 + def check_grouped_style(send_node); end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#91 + def check_separated_style(send_node); end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#127 + def group_mixins(node, mixins); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#110 + def grouped_style?; end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#53 + def range_to_remove_for_subsequent_mixin(mixins, node); end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#118 + def separate_mixins(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#114 + def separated_style?; end + + # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#104 + def sibling_mixins(send_node); end +end + +# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#37 +RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#38 +RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String) + +# Checks that `include`, `extend` and `prepend` statements appear +# inside classes and modules, not at the top level, so as to not affect +# the behavior of `Object`. +# +# @example +# # bad +# include M +# +# class C +# end +# +# # bad +# extend M +# +# class C +# end +# +# # bad +# prepend M +# +# class C +# end +# +# # good +# class C +# include M +# end +# +# # good +# class C +# extend M +# end +# +# # good +# class C +# prepend M +# end +# +# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#43 +class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#54 + def in_top_level_scope?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#48 + def include_statement(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#62 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#44 +RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#45 +RuboCop::Cop::Style::MixinUsage::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for use of `extend self` or `module_function` in a module. +# +# Supported styles are: `module_function` (default), `extend_self` and `forbidden`. +# +# A couple of things to keep in mind: +# +# - `forbidden` style prohibits the usage of both styles +# - in default mode (`module_function`), the cop won't be activated when the module +# contains any private methods +# +# @example EnforcedStyle: module_function (default) +# # bad +# module Test +# extend self +# # ... +# end +# +# # good +# module Test +# module_function +# # ... +# end +# +# # good +# module Test +# extend self +# # ... +# private +# # ... +# end +# +# # good +# module Test +# class << self +# # ... +# end +# end +# @example EnforcedStyle: extend_self +# # bad +# module Test +# module_function +# # ... +# end +# +# # good +# module Test +# extend self +# # ... +# end +# +# # good +# module Test +# class << self +# # ... +# end +# end +# @example EnforcedStyle: forbidden +# # bad +# module Test +# module_function +# # ... +# end +# +# # bad +# module Test +# extend self +# # ... +# end +# +# # bad +# module Test +# extend self +# # ... +# private +# # ... +# end +# +# # good +# module Test +# class << self +# # ... +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/module_function.rb#95 +class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#107 + def extend_self_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#104 + def module_function_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#112 + def on_module(node); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#110 + def private_directive?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#149 + def check_extend_self(nodes); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#155 + def check_forbidden(nodes); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#141 + def check_module_function(nodes); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#130 + def each_wrong_style(nodes, &block); end + + # source://rubocop//lib/rubocop/cop/style/module_function.rb#162 + def message(_range); end +end + +# source://rubocop//lib/rubocop/cop/style/module_function.rb#100 +RuboCop::Cop::Style::ModuleFunction::EXTEND_SELF_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/module_function.rb#101 +RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/module_function.rb#99 +RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String) + +# Checks for chaining of a block after another block that spans +# multiple lines. +# +# @example +# +# # bad +# Thread.list.select do |t| +# t.alive? +# end.map do |t| +# t.object_id +# end +# +# # good +# alive_threads = Thread.list.select do |t| +# t.alive? +# end +# alive_threads.map do |t| +# t.object_id +# end +# +# source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#25 +class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#30 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#30 + def on_numblock(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#28 +RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of if/unless modifiers with multiple-lines bodies. +# +# @example +# +# # bad +# { +# result: 'this should not happen' +# } unless cond +# +# # good +# { result: 'ok' } if cond +# +# source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#17 +class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#25 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#43 + def indented_body(body, node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#35 + def to_normal_if(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#22 +RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the `then` keyword in multi-line if statements. +# +# @example +# # bad +# # This is considered bad practice. +# if cond then +# end +# +# # good +# # If statements can contain `then` on the same line. +# if cond then a +# elsif cond then b +# end +# +# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#19 +class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#28 + def on_normal_if_unless(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#38 + def non_modifier_then?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#26 +RuboCop::Cop::Style::MultilineIfThen::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#24 +RuboCop::Cop::Style::MultilineIfThen::NON_MODIFIER_THEN = T.let(T.unsafe(nil), Regexp) + +# Checks uses of the `then` keyword in multi-line `in` statement. +# +# @example +# # bad +# case expression +# in pattern then +# end +# +# # good +# case expression +# in pattern +# end +# +# # good +# case expression +# in pattern then do_something +# end +# +# # good +# case expression +# in pattern then do_something(arg1, +# arg2) +# end +# +# source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#30 +class RuboCop::Cop::Style::MultilineInPatternThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#39 + def on_in_pattern(node); end + + private + + # Requires `then` for write `in` and its body on the same line. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#51 + def require_then?(in_pattern_node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#37 +RuboCop::Cop::Style::MultilineInPatternThen::MSG = T.let(T.unsafe(nil), String) + +# Checks expressions wrapping styles for multiline memoization. +# +# @example EnforcedStyle: keyword (default) +# # bad +# foo ||= ( +# bar +# baz +# ) +# +# # good +# foo ||= begin +# bar +# baz +# end +# @example EnforcedStyle: braces +# # bad +# foo ||= begin +# bar +# baz +# end +# +# # good +# foo ||= ( +# bar +# baz +# ) +# +# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#33 +class RuboCop::Cop::Style::MultilineMemoization < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#56 + def message(_node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#41 + def on_or_asgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#62 + def bad_rhs?(rhs); end + + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#72 + def keyword_autocorrect(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#78 + def keyword_begin_str(node, node_buf); end + + # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#86 + def keyword_end_str(node, node_buf); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#39 +RuboCop::Cop::Style::MultilineMemoization::BRACES_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#38 +RuboCop::Cop::Style::MultilineMemoization::KEYWORD_MSG = T.let(T.unsafe(nil), String) + +# Checks for method signatures that span multiple lines. +# +# @example +# +# # good +# +# def foo(bar, baz) +# end +# +# # bad +# +# def foo(bar, +# baz) +# end +# +# source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#21 +class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#27 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#27 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#60 + def arguments_range(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#41 + def autocorrect(corrector, node, begin_of_arguments); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#72 + def closing_line(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#76 + def correction_exceeds_max_line_length?(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#84 + def definition_width(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#80 + def indentation_width(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#56 + def last_line_source_of_arguments(arguments); end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#88 + def max_line_length; end + + # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#68 + def opening_line(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#25 +RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String) + +# Checks for multi-line ternary op expressions. +# +# NOTE: `return if ... else ... end` is syntax error. If `return` is used before +# multiline ternary operator expression, it will be autocorrected to single-line +# ternary operator. The same is true for `break`, `next`, and method call. +# +# @example +# # bad +# a = cond ? +# b : c +# a = cond ? b : +# c +# a = cond ? +# b : +# c +# +# return cond ? +# b : +# c +# +# # good +# a = cond ? b : c +# a = if cond +# b +# else +# c +# end +# +# return cond ? b : c +# +# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#36 +class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#44 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#60 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#84 + def comments_in_condition(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#90 + def enforce_single_line_ternary_operator?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#56 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#70 + def replacement(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#94 + def use_assignment_method?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#40 +RuboCop::Cop::Style::MultilineTernaryOperator::MSG_IF = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#41 +RuboCop::Cop::Style::MultilineTernaryOperator::MSG_SINGLE_LINE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#42 +RuboCop::Cop::Style::MultilineTernaryOperator::SINGLE_LINE_TYPES = T.let(T.unsafe(nil), Array) + +# Checks uses of the `then` keyword +# in multi-line when statements. +# +# @example +# # bad +# case foo +# when bar then +# end +# +# # good +# case foo +# when bar +# end +# +# # good +# case foo +# when bar then do_something +# end +# +# # good +# case foo +# when bar then do_something(arg1, +# arg2) +# end +# +# source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#31 +class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#37 + def on_when(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#58 + def accept_node_type?(node); end + + # Requires `then` for write `when` and its body on the same line. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#49 + def require_then?(when_node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#35 +RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String) + +# Checks against comparing a variable with multiple items, where +# `Array#include?`, `Set#include?` or a `case` could be used instead +# to avoid code repetition. +# It accepts comparisons of multiple method calls to avoid unnecessary method calls +# by default. It can be configured by `AllowMethodComparison` option. +# +# @example +# # bad +# a = 'a' +# foo if a == 'a' || a == 'b' || a == 'c' +# +# # good +# a = 'a' +# foo if ['a', 'b', 'c'].include?(a) +# +# VALUES = Set['a', 'b', 'c'].freeze +# # elsewhere... +# foo if VALUES.include?(a) +# +# case foo +# when 'a', 'b', 'c' then foo +# # ... +# end +# +# # accepted (but consider `case` as above) +# foo if a == b.lightweight || a == b.heavyweight +# @example AllowMethodComparison: true (default) +# # good +# foo if a == b.lightweight || a == b.heavyweight +# @example AllowMethodComparison: false +# # bad +# foo if a == b.lightweight || a == b.heavyweight +# +# # good +# foo if [b.lightweight, b.heavyweight].include?(a) +# @example ComparisonsThreshold: 2 (default) +# # bad +# foo if a == 'a' || a == 'b' +# @example ComparisonsThreshold: 3 +# # good +# foo if a == 'a' || a == 'b' +# +# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#52 +class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#58 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#62 + def on_or(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#88 + def simple_comparison_lhs?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#93 + def simple_comparison_rhs?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#85 + def simple_double_comparison?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#161 + def allow_method_comparison?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#136 + def comparison?(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#165 + def comparisons_threshold; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#128 + def nested_comparison?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#97 + def nested_variable_comparison?(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#156 + def reset_comparison; end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#140 + def root_of_or_node(or_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#150 + def switch_comparison?(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#124 + def variable_name(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#103 + def variables_in_node(node); end + + # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#111 + def variables_in_simple_node(node); end +end + +# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#55 +RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +# Checks whether some constant value isn't a +# mutable literal (e.g. array or hash). +# +# Strict mode can be used to freeze all constants, rather than +# just literals. +# Strict mode is considered an experimental feature. It has not been +# updated with an exhaustive list of all methods that will produce +# frozen objects so there is a decent chance of getting some false +# positives. Luckily, there is no harm in freezing an already +# frozen object. +# +# From Ruby 3.0, this cop honours the magic comment +# 'shareable_constant_value'. When this magic comment is set to any +# acceptable value other than none, it will suppress the offenses +# raised by this cop. It enforces frozen state. +# +# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0. +# +# NOTE: From Ruby 3.0, interpolated strings are not frozen when +# `# frozen-string-literal: true` is used, so this cop enforces explicit +# freezing for such strings. +# +# NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when +# the `shareable_constant_value` directive is used. +# +# @example EnforcedStyle: literals (default) +# # bad +# CONST = [1, 2, 3] +# +# # good +# CONST = [1, 2, 3].freeze +# +# # good +# CONST = <<~TESTING.freeze +# This is a heredoc +# TESTING +# +# # good +# CONST = Something.new +# @example EnforcedStyle: strict +# # bad +# CONST = Something.new +# +# # bad +# CONST = Struct.new do +# def foo +# puts 1 +# end +# end +# +# # good +# CONST = Something.new.freeze +# +# # good +# CONST = Struct.new do +# def foo +# puts 1 +# end +# end.freeze +# @example +# # Magic comment - shareable_constant_value: literal +# +# # bad +# CONST = [1, 2, 3] +# +# # good +# # shareable_constant_value: literal +# CONST = [1, 2, 3] +# +# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#87 +class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue + include ::RuboCop::Cop::FrozenStringLiteral + 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 + def on_assignment(value); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#127 + def on_casgn(node); end + + # Some of these patterns may not actually return an immutable object, + # but we want to consider them immutable for this cop. + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#224 + def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#241 + def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end + + # 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 + def t_let(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#169 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#158 + def check(value); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#208 + def correct_splat_expansion(corrector, expr, splat_value); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#200 + def frozen_regexp_or_range_literals?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#190 + def immutable_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#184 + def mutable_literal?(value); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#204 + def requires_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#194 + def shareable_constant_value?(node); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#149 + def strict_check(value); end +end + +# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#125 +RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String) + +# Handles magic comment shareable_constant_value with O(n ^ 2) complexity +# n - number of lines in the source +# Iterates over all lines before a CONSTANT +# until it reaches shareable_constant_value +# +# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#88 +module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue + private + + # Identifies the most recent magic comment with valid shareable constant values + # that's in scope for this node + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#102 + def magic_comment_in_scope(node); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#110 + def processed_source_till_node(node); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#91 + def recent_shareable_value?(node); end + + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#114 + def shareable_constant_value_enabled?(value); end + + class << self + # Identifies the most recent magic comment with valid shareable constant values + # that's in scope for this node + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#102 + def magic_comment_in_scope(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#91 + def recent_shareable_value?(node); end + end +end + +# Checks for uses of if with a negated condition. Only ifs +# without else are considered. There are three different styles: +# +# * both +# * prefix +# * postfix +# +# @example EnforcedStyle: both (default) +# # enforces `unless` for `prefix` and `postfix` conditionals +# +# # bad +# +# if !foo +# bar +# end +# +# # good +# +# unless foo +# bar +# end +# +# # bad +# +# bar if !foo +# +# # good +# +# bar unless foo +# @example EnforcedStyle: prefix +# # enforces `unless` for just `prefix` conditionals +# +# # bad +# +# if !foo +# bar +# end +# +# # good +# +# unless foo +# bar +# end +# +# # good +# +# bar if !foo +# @example EnforcedStyle: postfix +# # enforces `unless` for just `postfix` conditionals +# +# # bad +# +# bar if !foo +# +# # good +# +# bar unless foo +# +# # good +# +# if !foo +# bar +# end +# +# source://rubocop//lib/rubocop/cop/style/negated_if.rb#71 +class RuboCop::Cop::Style::NegatedIf < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/negated_if.rb#76 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/negated_if.rb#92 + def correct_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_if.rb#88 + def message(node); end +end + +# Checks for uses of `if-else` and ternary operators with a negated condition +# which can be simplified by inverting condition and swapping branches. +# +# @example +# # bad +# if !x +# do_something +# else +# do_something_else +# end +# +# # good +# if x +# do_something_else +# else +# do_something +# end +# +# # bad +# !x ? do_something : do_something_else +# +# # good +# x ? do_something_else : do_something +# +# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#30 +class RuboCop::Cop::Style::NegatedIfElseCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#39 + def double_negation?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#49 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#45 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#94 + def correct_negated_condition(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#90 + def corrected_ancestor?(node); end + + # Collect the entire else branch, including whitespace and comments + # + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#125 + def else_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#68 + def if_else?(node); end + + # Collect the entire if branch, including whitespace and comments + # + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#116 + def if_range(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#84 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#79 + def negated_condition?(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#107 + def swap_branches(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#73 + def unwrap_begin_nodes(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#41 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#34 +RuboCop::Cop::Style::NegatedIfElseCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#36 +RuboCop::Cop::Style::NegatedIfElseCondition::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for uses of unless with a negated condition. Only unless +# without else are considered. There are three different styles: +# +# * both +# * prefix +# * postfix +# +# @example EnforcedStyle: both (default) +# # enforces `if` for `prefix` and `postfix` conditionals +# +# # bad +# unless !foo +# bar +# end +# +# # good +# if foo +# bar +# end +# +# # bad +# bar unless !foo +# +# # good +# bar if foo +# @example EnforcedStyle: prefix +# # enforces `if` for just `prefix` conditionals +# +# # bad +# unless !foo +# bar +# end +# +# # good +# if foo +# bar +# end +# +# # good +# bar unless !foo +# @example EnforcedStyle: postfix +# # enforces `if` for just `postfix` conditionals +# +# # bad +# bar unless !foo +# +# # good +# bar if foo +# +# # good +# unless !foo +# bar +# end +# +# source://rubocop//lib/rubocop/cop/style/negated_unless.rb#61 +class RuboCop::Cop::Style::NegatedUnless < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#66 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#82 + def correct_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#78 + def message(node); end +end + +# Checks for uses of while with a negated condition. +# +# @example +# # bad +# while !foo +# bar +# end +# +# # good +# until foo +# bar +# end +# +# # bad +# bar until !foo +# +# # good +# bar while foo +# bar while !foo && baz +# +# source://rubocop//lib/rubocop/cop/style/negated_while.rb#25 +class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Base + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/negated_while.rb#29 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/negated_while.rb#29 + def on_while(node); end +end + +# Checks for nested `File.dirname`. +# It replaces nested `File.dirname` with the level argument introduced in Ruby 3.1. +# +# @example +# +# # bad +# File.dirname(File.dirname(path)) +# +# # good +# File.dirname(path, 2) +# +# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#17 +class RuboCop::Cop::Style::NestedFileDirname < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#28 + def file_dirname?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#33 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#60 + def offense_range(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#49 + def path_with_dir_level(node, level); end +end + +# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#22 +RuboCop::Cop::Style::NestedFileDirname::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#23 +RuboCop::Cop::Style::NestedFileDirname::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for nested use of if, unless, while and until in their +# modifier form. +# +# @example +# +# # bad +# something if a if b +# +# # good +# something if b && a +# +# source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#16 +class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22 + def on_while(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#85 + def add_parentheses_to_method_arguments(send_node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#42 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#30 + def check(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#65 + def left_hand_operand(node, operator); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#38 + def modifier?(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#51 + def new_expression(inner_node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#61 + def replacement_operator(keyword); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#94 + def requires_parens?(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#71 + def right_hand_operand(node, left_hand_keyword); end +end + +# source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#20 +RuboCop::Cop::Style::NestedModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for unparenthesized method calls in the argument list +# of a parenthesized method call. +# `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`, +# `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`, +# `respond_to`, and `start_with` methods are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # good +# method1(method2(arg)) +# +# # bad +# method1(method2 arg) +# @example AllowedMethods: [foo] +# # good +# method1(foo arg) +# +# source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#24 +class RuboCop::Cop::Style::NestedParenthesizedCalls < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#35 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#71 + def allowed?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#65 + def allowed_omission?(send_node); end + + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#51 + def autocorrect(corrector, nested); end + + class << self + # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#29 +RuboCop::Cop::Style::NestedParenthesizedCalls::MSG = T.let(T.unsafe(nil), String) + +# Checks for nested ternary op expressions. +# +# @example +# # bad +# a ? (b ? b1 : b2) : a2 +# +# # good +# if a +# b ? b1 : b2 +# else +# a2 +# end +# +# source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#18 +class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#25 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#40 + def autocorrect(corrector, if_node); end + + # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#47 + def remove_parentheses(source); end + + # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#53 + def replace_loc_and_whitespace(corrector, range, replacement); end +end + +# source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#23 +RuboCop::Cop::Style::NestedTernaryOperator::MSG = T.let(T.unsafe(nil), String) + +# Use `next` to skip iteration instead of a condition at the end. +# +# @example EnforcedStyle: skip_modifier_ifs (default) +# # bad +# [1, 2].each do |a| +# if a == 1 +# puts a +# end +# end +# +# # good +# [1, 2].each do |a| +# next unless a == 1 +# puts a +# end +# +# # good +# [1, 2].each do |a| +# puts a if a == 1 +# end +# @example EnforcedStyle: always +# # With `always` all conditions at the end of an iteration needs to be +# # replaced by next - with `skip_modifier_ifs` the modifier if like +# # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }` +# +# # bad +# [1, 2].each do |a| +# puts a if a == 1 +# end +# +# # bad +# [1, 2].each do |a| +# if a == 1 +# puts a +# end +# end +# +# # good +# [1, 2].each do |a| +# next unless a == 1 +# puts a +# end +# +# source://rubocop//lib/rubocop/cop/style/next.rb#49 +class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/next.rb#68 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#76 + def on_for(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#62 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/style/next.rb#68 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#76 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#76 + def on_while(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/next.rb#213 + def actual_indent(lines, buffer); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#112 + def allowed_modifier_if?(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#155 + def autocorrect_block(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#145 + def autocorrect_modifier(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#84 + def check(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#170 + def cond_range(node, cond); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#189 + def end_followed_by_whitespace_only?(source_buffer, end_pos); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#180 + def end_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#98 + def ends_with_condition?(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#128 + def exit_body_type?(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#217 + def heredoc_lines(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#120 + def if_else_children?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#124 + def if_without_else?(node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#140 + def offense_location(offense_node); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#134 + def offense_node(body); end + + # Adjust indentation of `lines` to match `node` + # + # source://rubocop//lib/rubocop/cop/style/next.rb#204 + def reindent(lines, node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#224 + def reindent_line(corrector, lineno, delta, buffer); end + + # source://rubocop//lib/rubocop/cop/style/next.rb#193 + def reindentable_lines(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/next.rb#104 + def simple_if_without_break?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/next.rb#58 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/next.rb#56 +RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/next.rb#55 +RuboCop::Cop::Style::Next::MSG = T.let(T.unsafe(nil), String) + +# Checks for comparison of something with nil using `==` and +# `nil?`. +# +# Supported styles are: predicate, comparison. +# +# @example EnforcedStyle: predicate (default) +# +# # bad +# if x == nil +# end +# +# # good +# if x.nil? +# end +# @example EnforcedStyle: comparison +# +# # bad +# if x.nil? +# end +# +# # good +# if x == nil +# end +# +# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#31 +class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#44 + def nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#41 + def nil_comparison?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#46 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#65 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#77 + def prefer_comparison?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#69 + def style_check?(node, &block); end +end + +# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#36 +RuboCop::Cop::Style::NilComparison::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#35 +RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#38 +RuboCop::Cop::Style::NilComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for lambdas and procs that always return nil, +# which can be replaced with an empty lambda or proc instead. +# +# @example +# # bad +# -> { nil } +# +# lambda do +# next nil +# end +# +# proc { nil } +# +# Proc.new do +# break nil +# end +# +# # good +# -> {} +# +# lambda do +# end +# +# -> (x) { nil if x } +# +# proc {} +# +# Proc.new { nil if x } +# +# source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#35 +class RuboCop::Cop::Style::NilLambda < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#42 + def nil_return?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#46 + def on_block(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#58 + def autocorrect(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#39 +RuboCop::Cop::Style::NilLambda::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-nil checks, which are usually redundant. +# +# With `IncludeSemanticChanges` set to `false` by default, this cop +# does not report offenses for `!x.nil?` and does no changes that might +# change behavior. +# Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of +# `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and +# does no changes to `!x.nil?` style. +# +# With `IncludeSemanticChanges` set to `true`, this cop reports offenses +# for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which +# is *usually* OK, but might change behavior. +# +# @example +# # bad +# if x != nil +# end +# +# # good +# if x +# end +# +# # Non-nil checks are allowed if they are the final nodes of predicate. +# # good +# def signed_in? +# !current_user.nil? +# end +# @example IncludeSemanticChanges: false (default) +# # good +# if !x.nil? +# end +# @example IncludeSemanticChanges: true +# # bad +# if !x.nil? +# end +# +# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#44 +class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#59 + def nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#62 + def not_and_nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#53 + def not_equal_to_nil?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#73 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#73 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#64 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#56 + def unless_check?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#93 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#123 + def autocorrect_comparison(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#137 + def autocorrect_non_nil(corrector, node, inner_node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#145 + def autocorrect_unless_nil(corrector, node, receiver); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#119 + def include_semantic_changes?; end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#110 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#150 + def nil_comparison_style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#88 + def register_offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#104 + def unless_and_nil_check?(send_node); end +end + +# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#48 +RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REDUNDANCY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#47 +RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REPLACEMENT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#50 +RuboCop::Cop::Style::NonNilCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of the keyword `not` instead of `!`. +# +# @example +# +# # bad - parentheses are required because of op precedence +# x = (not something) +# +# # good +# x = !something +# +# source://rubocop//lib/rubocop/cop/style/not.rb#16 +class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/not.rb#32 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/not.rb#60 + def correct_opposite_method(corrector, range, child); end + + # source://rubocop//lib/rubocop/cop/style/not.rb#65 + def correct_with_parens(corrector, range, node); end + + # source://rubocop//lib/rubocop/cop/style/not.rb#70 + def correct_without_parens(corrector, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/not.rb#50 + def opposite_method?(child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/not.rb#54 + def requires_parens?(child); end +end + +# source://rubocop//lib/rubocop/cop/style/not.rb#20 +RuboCop::Cop::Style::Not::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/not.rb#23 +RuboCop::Cop::Style::Not::OPPOSITE_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/not.rb#21 +RuboCop::Cop::Style::Not::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for numbered parameters. +# +# It can either restrict the use of numbered parameters to +# single-lined blocks, or disallow completely numbered parameters. +# +# @example EnforcedStyle: allow_single_line (default) +# # bad +# collection.each do +# puts _1 +# end +# +# # good +# collection.each { puts _1 } +# @example EnforcedStyle: disallow +# # bad +# collection.each { puts _1 } +# +# # good +# collection.each { |item| puts item } +# +# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#27 +class RuboCop::Cop::Style::NumberedParameters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#36 + def on_numblock(node); end +end + +# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#31 +RuboCop::Cop::Style::NumberedParameters::MSG_DISALLOW = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#32 +RuboCop::Cop::Style::NumberedParameters::MSG_MULTI_LINE = T.let(T.unsafe(nil), String) + +# Detects use of an excessive amount of numbered parameters in a +# single block. Having too many numbered parameters can make code too +# cryptic and hard to read. +# +# The cop defaults to registering an offense if there is more than 1 numbered +# parameter but this maximum can be configured by setting `Max`. +# +# @example Max: 1 (default) +# # bad +# use_multiple_numbered_parameters { _1.call(_2, _3, _4) } +# +# # good +# array.each { use_array_element_as_numbered_parameter(_1) } +# hash.each { use_only_hash_value_as_numbered_parameter(_2) } +# +# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#20 +class RuboCop::Cop::Style::NumberedParametersLimit < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def max=(value); end + + # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#32 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#49 + def max_count; end + + # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#43 + def numbered_parameter_nodes(node); end +end + +# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#24 +RuboCop::Cop::Style::NumberedParametersLimit::DEFAULT_MAX_VALUE = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#29 +RuboCop::Cop::Style::NumberedParametersLimit::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#30 +RuboCop::Cop::Style::NumberedParametersLimit::NUMBERED_PARAMETER_PATTERN = T.let(T.unsafe(nil), Regexp) + +# Checks for octal, hex, binary, and decimal literals using +# uppercase prefixes and corrects them to lowercase prefix +# or no prefix (in case of decimals). +# +# @example EnforcedOctalStyle: zero_with_o (default) +# # bad - missing octal prefix +# num = 01234 +# +# # bad - uppercase prefix +# num = 0O1234 +# num = 0X12AB +# num = 0B10101 +# +# # bad - redundant decimal prefix +# num = 0D1234 +# num = 0d1234 +# +# # good +# num = 0o1234 +# num = 0x12AB +# num = 0b10101 +# num = 1234 +# @example EnforcedOctalStyle: zero_only +# # bad +# num = 0o1234 +# num = 0O1234 +# +# # good +# num = 01234 +# +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#36 +class RuboCop::Cop::Style::NumericLiteralPrefix < ::RuboCop::Cop::Base + include ::RuboCop::Cop::IntegerNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#52 + def on_int(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#109 + def format_binary(source); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#113 + def format_decimal(source); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#105 + def format_hex(source); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#97 + def format_octal(source); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#101 + def format_octal_zero_only(source); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#82 + def hex_bin_dec_literal_type(literal); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#68 + def literal_type(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#64 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#74 + def octal_literal_type(literal); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#93 + def octal_zero_only?; end +end + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#49 +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#43 +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#50 +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#44 +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#48 +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#42 +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#47 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#41 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#46 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#40 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks for big numeric literals without `_` between groups +# of digits in them. +# +# Additional allowed patterns can be added by adding regexps to +# the `AllowedPatterns` configuration. All regexps are treated +# as anchored even if the patterns do not contain anchors (so +# `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`). +# +# NOTE: Even if `AllowedPatterns` are given, autocorrection will +# only correct to the standard pattern of an `_` every 3 digits. +# +# @example +# +# # bad +# 1000000 +# 1_00_000 +# 1_0000 +# +# # good +# 1_000_000 +# 1000 +# @example Strict: false (default) +# +# # good +# 10_000_00 # typical representation of $10,000 in cents +# @example Strict: true +# +# # bad +# 10_000_00 # typical representation of $10,000 in cents +# @example AllowedNumbers: [3000] +# +# # good +# 3000 # You can specify allowed numbers. (e.g. port number) +# +# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#43 +class RuboCop::Cop::Style::NumericLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::IntegerNode + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11 + def min_digits=(value); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#60 + def on_float(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#56 + def on_int(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#118 + def allowed_numbers; end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#122 + def allowed_patterns; end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#66 + def check(node); end + + # @param int_part [String] + # + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#107 + def format_int_part(int_part); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#93 + def format_number(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#114 + def min_digits; end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#82 + def register_offense(node, &_block); end + + # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#89 + def short_group_regex; end +end + +# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#49 +RuboCop::Cop::Style::NumericLiterals::DELIMITER_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#48 +RuboCop::Cop::Style::NumericLiterals::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of comparison operators (`==`, +# `>`, `<`) to test numbers as zero, positive, or negative. +# These can be replaced by their respective predicate methods. +# This cop can also be configured to do the reverse. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# This cop disregards `#nonzero?` as its value is truthy or falsey, +# but not `true` and `false`, and thus not always interchangeable with +# `!= 0`. +# +# This cop allows comparisons to global variables, since they are often +# populated with objects which can be compared with integers, but are +# not themselves `Integer` polymorphic. +# +# @example EnforcedStyle: predicate (default) +# # bad +# foo == 0 +# 0 > foo +# bar.baz > 0 +# +# # good +# foo.zero? +# foo.negative? +# bar.baz.positive? +# @example EnforcedStyle: comparison +# # bad +# foo.zero? +# foo.negative? +# bar.baz.positive? +# +# # good +# foo == 0 +# 0 > foo +# bar.baz > 0 +# @example AllowedMethods: [] (default) with EnforcedStyle: predicate +# # bad +# foo == 0 +# 0 > foo +# bar.baz > 0 +# @example AllowedMethods: [==] with EnforcedStyle: predicate +# # good +# foo == 0 +# +# # bad +# 0 > foo +# bar.baz > 0 +# @example AllowedPatterns: [] (default) with EnforcedStyle: comparison +# # bad +# foo.zero? +# foo.negative? +# bar.baz.positive? +# @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate +# # good +# # bad +# foo.zero? +# +# # bad +# foo.negative? +# bar.baz.positive? +# +# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#78 +class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#166 + def comparison(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#171 + def inverted_comparison(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#90 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#161 + def predicate(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#107 + def allowed_method_name?(name); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#111 + def check(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#152 + def invert; end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#132 + def parenthesized_source(node); end + + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#124 + def replacement(numeric, operation); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#144 + def replacement_supported?(operator); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#140 + def require_parentheses?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#84 +RuboCop::Cop::Style::NumericPredicate::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#86 +RuboCop::Cop::Style::NumericPredicate::REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#88 +RuboCop::Cop::Style::NumericPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of consistent method names +# `Object#yield_self` or `Object#then`. +# +# @example EnforcedStyle: then (default) +# +# # bad +# obj.yield_self { |x| x.do_something } +# +# # good +# obj.then { |x| x.do_something } +# @example EnforcedStyle: yield_self +# +# # bad +# obj.then { |x| x.do_something } +# +# # good +# obj.yield_self { |x| x.do_something } +# +# source://rubocop//lib/rubocop/cop/style/object_then.rb#25 +class RuboCop::Cop::Style::ObjectThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#34 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#34 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#40 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#48 + def check_method_node(node); end + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#68 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/object_then.rb#57 + def preferred_method(node); end +end + +# source://rubocop//lib/rubocop/cop/style/object_then.rb#32 +RuboCop::Cop::Style::ObjectThen::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of if/then/else/end constructs on a single line. +# AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to +# multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the +# autocorrect will first try converting them to ternary operators. +# +# @example +# # bad +# if foo then bar else baz end +# +# # bad +# unless foo then baz else bar end +# +# # good +# foo ? bar : baz +# +# # good +# bar if foo +# +# # good +# if foo then bar end +# +# # good +# if foo +# bar +# else +# baz +# end +# +# source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#33 +class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::OnNormalIfUnless + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#42 + def on_normal_if_unless(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#77 + def always_multiline?; end + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#59 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#81 + def cannot_replace_to_ternary?(node); end + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#93 + def expr_replacement(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#114 + def keyword_with_changed_precedence?(node); end + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#55 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#107 + def method_call_with_changed_precedence?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#99 + def requires_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#67 + def ternary_correction(node); end + + # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#85 + def ternary_replacement(node); end +end + +# source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#39 +RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String) + +# Flags uses of OpenStruct, as it is now officially discouraged +# to be used for performance, version compatibility, and potential security issues. +# +# @example +# +# # bad +# point = OpenStruct.new(x: 0, y: 1) +# +# # good +# Point = Struct.new(:x, :y) +# point = Point.new(0, 1) +# +# # also good +# point = { x: 0, y: 1 } +# +# # bad +# test_double = OpenStruct.new(a: 'b') +# +# # good (assumes test using rspec-mocks) +# test_double = double +# allow(test_double).to receive(:a).and_return('b') +# +# source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#44 +class RuboCop::Cop::Style::OpenStructUse < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#52 + def on_const(node); end + + # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#48 + def uses_open_struct?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#61 + def custom_class_or_module_definition?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#45 +RuboCop::Cop::Style::OpenStructUse::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant dot before operator method call. +# The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`, +# `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`. +# +# @example +# +# # bad +# foo.+ bar +# foo.& bar +# +# # good +# foo + bar +# foo & bar +# +# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#20 +class RuboCop::Cop::Style::OperatorMethodCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#27 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#53 + def anonymous_forwarding?(argument); end + + # Checks for an acceptable case of `foo.+(bar).baz`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#47 + def method_call_with_parenthesized_arg?(argument); end + + # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#60 + def wrap_in_parentheses_if_chained(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#23 +RuboCop::Cop::Style::OperatorMethodCall::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#24 +RuboCop::Cop::Style::OperatorMethodCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for options hashes and discourages them if the +# current Ruby version supports keyword arguments. +# +# @example +# +# # bad +# def fry(options = {}) +# temperature = options.fetch(:temperature, 300) +# # ... +# end +# +# # good +# def fry(temperature: 300) +# # ... +# end +# +# source://rubocop//lib/rubocop/cop/style/option_hash.rb#22 +class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/option_hash.rb#30 + def on_args(node); end + + # source://rubocop//lib/rubocop/cop/style/option_hash.rb#26 + def option_hash(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/option_hash.rb#39 + def allowlist; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/option_hash.rb#48 + def super_used?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/option_hash.rb#43 + def suspicious_name?(arg_name); end +end + +# source://rubocop//lib/rubocop/cop/style/option_hash.rb#23 +RuboCop::Cop::Style::OptionHash::MSG = T.let(T.unsafe(nil), String) + +# Checks for optional arguments to methods +# that do not come at the end of the argument list. +# +# @example +# # bad +# def foo(a = 1, b, c) +# end +# +# # good +# def baz(a, b, c = 1) +# end +# +# def foobar(a = 1, b = 2, c = 3) +# end +# +# source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#24 +class RuboCop::Cop::Style::OptionalArguments < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#27 + def on_def(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#45 + def argument_positions(arguments); end + + # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#33 + def each_misplaced_optional_arg(arguments); end +end + +# source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#25 +RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where keyword arguments can be used instead of +# boolean arguments when defining methods. `respond_to_missing?` method is allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# def some_method(bar = false) +# puts bar +# end +# +# # bad - common hack before keyword args were introduced +# def some_method(options = {}) +# bar = options.fetch(:bar, false) +# puts bar +# end +# +# # good +# def some_method(bar: false) +# puts bar +# end +# @example AllowedMethods: ['some_method'] +# # good +# def some_method(bar = false) +# puts bar +# end +# +# source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#37 +class RuboCop::Cop::Style::OptionalBooleanParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#43 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#43 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#56 + def format_message(argument); end +end + +# source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#40 +RuboCop::Cop::Style::OptionalBooleanParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for potential usage of the `||=` operator. +# +# @example +# # bad +# name = name ? name : 'Bozhidar' +# +# # bad +# name = if name +# name +# else +# 'Bozhidar' +# end +# +# # bad +# unless name +# name = 'Bozhidar' +# end +# +# # bad +# name = 'Bozhidar' unless name +# +# # good - set name to 'Bozhidar', only if it's nil or false +# name ||= 'Bozhidar' +# +# source://rubocop//lib/rubocop/cop/style/or_assignment.rb#29 +class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#51 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#35 + def ternary_assignment?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#44 + def unless_assignment?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#70 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#80 + def take_variable_and_default_from_ternary(node); end + + # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#85 + def take_variable_and_default_from_unless(node); end +end + +# source://rubocop//lib/rubocop/cop/style/or_assignment.rb#32 +RuboCop::Cop::Style::OrAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for simple usages of parallel assignment. +# This will only complain when the number of variables +# being assigned matched the number of assigning variables. +# +# @example +# # bad +# a, b, c = 1, 2, 3 +# a, b, c = [1, 2, 3] +# +# # good +# one, two = *foo +# a, b = foo() +# a, b = b, a +# +# a = 1 +# b = 2 +# c = 3 +# +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#25 +class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#124 + def implicit_self_getter?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#31 + def on_masgn(node); end + + private + + # Converts (send nil :something) nodes to (send (:self) :something). + # This makes the sorting algorithm work for expressions such as + # `self.a, self.b = b, a`. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#117 + def add_self_to_getters(right_elements); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#64 + def allowed_lhs?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#58 + def allowed_masign?(lhs_elements, rhs_elements); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#72 + def allowed_rhs?(node); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#84 + def assignment_corrector(node, rhs, order); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#49 + def autocorrect(corrector, node, lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#100 + def find_valid_order(left_elements, right_elements); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#183 + def modifier_statement?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#80 + def return_of_method_call?(node); end +end + +# Helper class necessitated by silly design of TSort prior to Ruby 2.1 +# Newer versions have a better API, but that doesn't help us +# +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#128 +class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter + include ::TSort + extend ::RuboCop::AST::NodePattern::Macros + + # @return [AssignmentSorter] a new instance of AssignmentSorter + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#141 + def initialize(assignments); end + + # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`. + # Does `rhs` access the same value which is assigned by `lhs`? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#170 + def accesses?(rhs, lhs); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#163 + def dependency?(lhs, rhs); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#139 + def matching_calls(param0, param1, param2); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#149 + def tsort_each_child(assignment); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#145 + def tsort_each_node(&block); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#136 + def uses_var?(param0, param1); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#133 + def var_name(param0 = T.unsafe(nil)); end +end + +# An internal class for correcting parallel assignment +# +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#190 +class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + include ::RuboCop::Cop::Alignment + + # @return [GenericCorrector] a new instance of GenericCorrector + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#195 + def initialize(node, rhs, modifier, config, new_elements); end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def config; end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#203 + def correction; end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#207 + def correction_range; end + + # Returns the value of attribute node. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def node; end + + # Returns the value of attribute rescue_result. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def rescue_result; end + + # Returns the value of attribute rhs. + # + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193 + def rhs; end + + protected + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#213 + def assignment; end + + private + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#233 + def cop_config; end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#229 + def extract_sources(node); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#219 + def source(node); end +end + +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#29 +RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String) + +# An internal class for correcting parallel assignment +# guarded by if, unless, while, or until +# +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#275 +class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#276 + def correction; end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#285 + def correction_range; end + + private + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#291 + def modifier_range(node); end +end + +# An internal class for correcting parallel assignment +# protected by rescue +# +# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#240 +class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#241 + def correction; end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#252 + def correction_range; end + + private + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#263 + def begin_correction(rescue_result); end + + # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#258 + def def_correction(rescue_result); end +end + +# Checks for the presence of superfluous parentheses around the +# condition of if/unless/while/until. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example +# # bad +# x += 1 while (x < 10) +# foo unless (bar || baz) +# +# if (x > 10) +# elsif (x < 3) +# end +# +# # good +# x += 1 while x < 10 +# foo unless bar || baz +# +# if x > 10 +# elsif x < 3 +# end +# @example AllowSafeAssignment: true (default) +# # good +# foo unless (bar = baz) +# @example AllowSafeAssignment: false +# # bad +# foo unless (bar = baz) +# @example AllowInMultilineConditions: false (default) +# # bad +# if (x > 10 && +# y > 10) +# end +# +# # good +# if x > 10 && +# y > 10 +# end +# @example AllowInMultilineConditions: true +# # good +# if (x > 10 && +# y > 10) +# end +# +# source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#56 +class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::Parentheses + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#76 + def control_op_condition(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#62 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#68 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#68 + def on_while(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#122 + def allow_multiline_conditions?; end + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#110 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#103 + def modifier_op?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#116 + def parens_allowed?(node); end + + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#80 + def process_control_op(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#95 + def semicolon_separated_expressions?(first_exp, rest_exps); end +end + +# Enforces the consistent usage of `%`-literal delimiters. +# +# Specify the 'default' key to set all preferred delimiters at once. You +# can continue to specify individual preferred delimiters to override the +# default. +# +# @example +# # Style/PercentLiteralDelimiters: +# # PreferredDelimiters: +# # default: '[]' +# # '%i': '()' +# +# # good +# %w[alpha beta] + %i(gamma delta) +# +# # bad +# %W(alpha #{beta}) +# +# # bad +# %I(alpha beta) +# +# source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#26 +class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#30 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#38 + def on_dstr(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#34 + def on_regexp(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#38 + def on_str(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#43 + def on_sym(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#47 + def on_xstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#93 + def contains_delimiter?(node, delimiters); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#82 + def contains_preferred_delimiter?(node, type); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#86 + def include_same_character_as_used_for_delimiter?(node, type); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#107 + def matchpairs(begin_delimiter); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#67 + def message(type); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#53 + def on_percent_literal(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#74 + def preferred_delimiters_for(type); end + + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#99 + def string_source(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#78 + def uses_preferred_delimiter?(node, type); end +end + +# Checks for usage of the %Q() syntax when %q() would do. +# +# @example EnforcedStyle: lower_case_q (default) +# # The `lower_case_q` style prefers `%q` unless +# # interpolation is needed. +# # bad +# %Q[Mix the foo into the baz.] +# %Q(They all said: 'Hooray!') +# +# # good +# %q[Mix the foo into the baz] +# %q(They all said: 'Hooray!') +# @example EnforcedStyle: upper_case_q +# # The `upper_case_q` style requires the sole use of `%Q`. +# # bad +# %q/Mix the foo into the baz./ +# %q{They all said: 'Hooray!'} +# +# # good +# %Q/Mix the foo into the baz./ +# %Q{They all said: 'Hooray!'} +# +# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#28 +class RuboCop::Cop::Style::PercentQLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#36 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#55 + def correct_literal_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#64 + def corrected(src); end + + # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#60 + def message(_range); end + + # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#42 + def on_percent_literal(node); end +end + +# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#33 +RuboCop::Cop::Style::PercentQLiterals::LOWER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#34 +RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +# Looks for uses of Perl-style regexp match +# backreferences and their English versions like +# $1, $2, $&, &+, $MATCH, $PREMATCH, etc. +# +# @example +# # bad +# puts $1 +# +# # good +# puts Regexp.last_match(1) +# +# source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#16 +class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#21 + def on_back_ref(node); end + + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#25 + def on_gvar(node); end + + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#29 + def on_nth_ref(node); end + + private + + # @param node [RuboCop::AST::Node] + # @private + # @return [String] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#99 + def constant_prefix(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#38 + def derived_from_braceless_interpolation?(node); end + + # @param node [RuboCop::AST::Node] + # @param preferred_expression [String] + # @private + # @return [String] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#46 + def format_message(node:, preferred_expression:); end + + # @param node [RuboCop::AST::Node] + # @private + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#109 + def on_back_ref_or_gvar_or_nth_ref(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [String] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#58 + def original_expression_of(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [String, nil] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#70 + def preferred_expression_to(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [String, nil] + # + # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#89 + def preferred_expression_to_node_with_constant_prefix(node); end +end + +# source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#19 +RuboCop::Cop::Style::PerlBackrefs::MESSAGE_FORMAT = T.let(T.unsafe(nil), String) + +# Checks for uses of methods `Hash#has_key?` and +# `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead. +# +# It is configurable to enforce the verbose method names, by using the +# `EnforcedStyle: verbose` configuration. +# +# @example EnforcedStyle: short (default) +# # bad +# Hash#has_key? +# Hash#has_value? +# +# # good +# Hash#key? +# Hash#value? +# @example EnforcedStyle: verbose +# # bad +# Hash#key? +# Hash#value? +# +# # good +# Hash#has_key? +# Hash#has_value? +# +# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#33 +class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#43 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#43 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#56 + def message(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#68 + def offending_selector?(method_name); end + + # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#60 + def proper_method_name(method_name); end +end + +# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#37 +RuboCop::Cop::Style::PreferredHashMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#39 +RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#41 +RuboCop::Cop::Style::PreferredHashMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of Proc.new where Kernel#proc +# would be more appropriate. +# +# @example +# # bad +# p = Proc.new { |n| puts n } +# +# # good +# p = proc { |n| puts n } +# +# source://rubocop//lib/rubocop/cop/style/proc.rb#16 +class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/proc.rb#25 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/proc.rb#25 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/proc.rb#22 + def proc_new?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/proc.rb#19 +RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String) + +# Checks if the quotes used for quoted symbols match the configured defaults. +# By default uses the same configuration as `Style/StringLiterals`; if that +# cop is not enabled, the default `EnforcedStyle` is `single_quotes`. +# +# String interpolation is always kept in double quotes. +# +# Note: `Lint/SymbolConversion` can be used in parallel to ensure that symbols +# are not quoted that don't need to be. This cop is for configuring the quoting +# style to use for symbols that require quotes. +# +# @example EnforcedStyle: same_as_string_literals (default) / single_quotes +# # bad +# :"abc-def" +# +# # good +# :'abc-def' +# :"#{str}" +# :"a\'b" +# @example EnforcedStyle: double_quotes +# # bad +# :'abc-def' +# +# # good +# :"abc-def" +# :"#{str}" +# :"a\'b" +# +# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#33 +class RuboCop::Cop::Style::QuotedSymbols < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SymbolHelp + include ::RuboCop::Cop::StringLiteralsHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#44 + def on_sym(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#108 + def alternative_style; end + + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#71 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#88 + def correct_quotes(str); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#83 + def hash_colon_key?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#61 + def invalid_double_quotes?(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#112 + def quoted?(sym_node); end + + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#99 + def style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#116 + def wrong_quotes?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#41 +RuboCop::Cop::Style::QuotedSymbols::MSG_DOUBLE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#39 +RuboCop::Cop::Style::QuotedSymbols::MSG_SINGLE = T.let(T.unsafe(nil), String) + +# Checks the args passed to `fail` and `raise`. For exploded +# style (default), it recommends passing the exception class and message +# to `raise`, rather than construct an instance of the error. It will +# still allow passing just a message, or the construction of an error +# with more than one argument. +# +# The exploded style works identically, but with the addition that it +# will also suggest constructing error objects when the exception is +# passed multiple arguments. +# +# The exploded style has an `AllowedCompactTypes` configuration +# option that takes an Array of exception name Strings. +# +# @example EnforcedStyle: exploded (default) +# # bad +# raise StandardError.new('message') +# +# # good +# raise StandardError, 'message' +# fail 'message' +# raise MyCustomError +# raise MyCustomError.new(arg1, arg2, arg3) +# raise MyKwArgError.new(key1: val1, key2: val2) +# +# # With `AllowedCompactTypes` set to ['MyWrappedError'] +# raise MyWrappedError.new(obj) +# raise MyWrappedError.new(obj), 'message' +# @example EnforcedStyle: compact +# # bad +# raise StandardError, 'message' +# raise RuntimeError, arg1, arg2, arg3 +# +# # good +# raise StandardError.new('message') +# raise MyCustomError +# raise MyCustomError.new(arg1, arg2, arg3) +# fail 'message' +# +# source://rubocop//lib/rubocop/cop/style/raise_args.rb#44 +class RuboCop::Cop::Style::RaiseArgs < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#53 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#129 + def acceptable_exploded_args?(args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#143 + def allowed_non_exploded_type?(arg); end + + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#92 + def check_compact(node); end + + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#108 + def check_exploded(node); end + + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#66 + def correction_compact_to_exploded(node); end + + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#78 + def correction_exploded_to_compact(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#149 + def requires_parens?(parent); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/raise_args.rb#125 + def use_new_method?(first_arg); end +end + +# source://rubocop//lib/rubocop/cop/style/raise_args.rb#49 +RuboCop::Cop::Style::RaiseArgs::COMPACT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/raise_args.rb#48 +RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/raise_args.rb#51 +RuboCop::Cop::Style::RaiseArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of randomly generated numbers, +# added/subtracted with integer literals, as well as those with +# Integer#succ and Integer#pred methods. Prefer using ranges instead, +# as it clearly states the intentions. +# +# @example +# # bad +# rand(6) + 1 +# 1 + rand(6) +# rand(6) - 1 +# 1 - rand(6) +# rand(6).succ +# rand(6).pred +# Random.rand(6) + 1 +# Kernel.rand(6) + 1 +# rand(0..5) + 1 +# +# # good +# rand(1..6) +# rand(1...7) +# +# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#26 +class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#33 + def integer_op_rand?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#63 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#54 + def rand_modified?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#43 + def rand_op_integer?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#73 + def random_call(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#147 + def to_int(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#78 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#135 + def boundaries_from_random_node(random_node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#88 + def corrected_integer_op_rand(node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#118 + def corrected_rand_modified(node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#103 + def corrected_rand_op_integer(node); end + + # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#131 + def prefix_from_prefix_node(node); end +end + +# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#29 +RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#30 +RuboCop::Cop::Style::RandomWithOffset::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for a redundant argument passed to certain methods. +# +# NOTE: This cop is limited to methods with single parameter. +# +# Method names and their redundant arguments can be configured like this: +# +# [source,yaml] +# ---- +# Methods: +# join: '' +# sum: 0 +# split: ' ' +# chomp: "\n" +# chomp!: "\n" +# foo: 2 +# ---- +# +# @example +# # bad +# array.join('') +# [1, 2, 3].join("") +# array.sum(0) +# exit(true) +# exit!(false) +# string.split(" ") +# "first\nsecond".split(" ") +# string.chomp("\n") +# string.chomp!("\n") +# A.foo(2) +# +# # good +# array.join +# [1, 2, 3].join +# array.sum +# exit +# exit! +# string.split +# "first second".split +# string.chomp +# string.chomp! +# A.foo +# +# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#57 +class RuboCop::Cop::Style::RedundantArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#64 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#93 + def argument_range(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#86 + def redundant_arg_for_method(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#79 + def redundant_argument?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#61 +RuboCop::Cop::Style::RedundantArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#62 +RuboCop::Cop::Style::RedundantArgument::NO_RECEIVER_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for the instantiation of array using redundant `Array` constructor. +# Autocorrect replaces to array literal which is the simplest and fastest. +# +# @example +# +# # bad +# Array.new([]) +# Array[] +# Array([]) +# Array.new(['foo', 'foo', 'foo']) +# Array['foo', 'foo', 'foo'] +# Array(['foo', 'foo', 'foo']) +# +# # good +# [] +# ['foo', 'foo', 'foo'] +# Array.new(3, 'foo') +# Array.new(3) { 'foo' } +# +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#25 +class RuboCop::Cop::Style::RedundantArrayConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#47 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#33 + def redundant_array_constructor(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#69 + def register_offense(range, node, replacement); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#28 +RuboCop::Cop::Style::RedundantArrayConstructor::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#30 +RuboCop::Cop::Style::RedundantArrayConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant assignment before returning. +# +# @example +# # bad +# def test +# x = foo +# x +# end +# +# # bad +# def test +# if x +# z = foo +# z +# elsif y +# z = bar +# z +# end +# end +# +# # good +# def test +# foo +# end +# +# # good +# def test +# if x +# foo +# elsif y +# bar +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#40 +class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#50 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#50 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#46 + def redundant_assignment?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#91 + def check_begin_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#57 + def check_branch(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#71 + def check_case_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#87 + def check_ensure_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#76 + def check_if_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#83 + def check_rescue_node(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#43 +RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant `begin` blocks. +# +# Currently it checks for code like this: +# +# @example +# +# # bad +# def redundant +# begin +# ala +# bala +# rescue StandardError => e +# something +# end +# end +# +# # good +# def preferred +# ala +# bala +# rescue StandardError => e +# something +# end +# +# # bad +# begin +# do_something +# end +# +# # good +# do_something +# +# # bad +# # When using Ruby 2.5 or later. +# do_something do +# begin +# something +# rescue => ex +# anything +# end +# end +# +# # good +# # In Ruby 2.5 or later, you can omit `begin` in `do-end` block. +# do_something do +# something +# rescue => ex +# anything +# end +# +# # good +# # Stabby lambdas don't support implicit `begin` in `do-end` blocks. +# -> do +# begin +# foo +# rescue Bar +# baz +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#65 +class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#72 + def offensive_kwbegins(param0); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#84 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#76 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#76 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#95 + def on_kwbegin(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#84 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#103 + def allowable_kwbegin?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#177 + def begin_block_has_multiline_statements?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#169 + def condition_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#181 + def contain_rescue_or_ensure?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#162 + def correct_modifier_form_after_multiline_begin_block(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#173 + def empty_begin?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#110 + def register_offense(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#139 + def remove_begin(corrector, offense_range, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#127 + def replace_begin_with_statement(corrector, offense_range, node); end + + # Restore comments that occur between "begin" and "first_child". + # These comments will be moved to above the assignment line. + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#149 + def restore_removed_comments(corrector, offense_range, node, first_child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#156 + def use_modifier_form_after_multiline_begin_block?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#194 + def valid_begin_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#187 + def valid_context_using_only_begin?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#69 +RuboCop::Cop::Style::RedundantBegin::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of the %W() syntax when %w() would do. +# +# @example +# # bad +# %W(cat dog pig) +# %W[door wall floor] +# +# # good +# %w/swim run bike/ +# %w[shirt pants shoes] +# %W(apple #{fruit} grape) +# +# source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#17 +class RuboCop::Cop::Style::RedundantCapitalW < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#23 + def on_array(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#29 + def on_percent_literal(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#38 + def requires_interpolation?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#21 +RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary conditional expressions. +# +# @example +# # bad +# a = b ? b : c +# +# # good +# a = b || c +# @example +# # bad +# if b +# b +# else +# c +# end +# +# # good +# b || c +# +# # good +# if b +# b +# elsif cond +# c +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#33 +class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#43 + def on_if(node); end + + private + + # If the argument is using an operator, it is an invalid syntax. + # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#167 + def argument_with_operator?(argument); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#142 + def asgn_type?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#132 + def branches_have_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#146 + def branches_have_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#240 + def correct_ternary(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#187 + def else_source(else_branch, arithmetic_operation); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#213 + def else_source_if_has_assignment(else_branch); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#203 + def else_source_if_has_method(else_branch); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#175 + def if_source(if_branch, arithmetic_operation); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#223 + def make_ternary_form(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#64 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#79 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#72 + def range_of_offense(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#88 + def redundant_condition?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#255 + def require_braces?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#248 + def require_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#161 + def same_method?(if_branch, else_branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#155 + def single_argument_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#104 + def synonymous_condition_and_branch?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#259 + def use_arithmetic_operation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#100 + def use_hash_key_access?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#96 + def use_hash_key_assignment?(else_branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#92 + def use_if_branch?(else_branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#263 + def without_argument_parentheses_method?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#39 +RuboCop::Cop::Style::RedundantCondition::ARGUMENT_WITH_OPERATOR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#37 +RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#38 +RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String) + +# Checks for redundant returning of true/false in conditionals. +# +# @example +# # bad +# x == y ? true : false +# +# # bad +# if x == y +# true +# else +# false +# end +# +# # good +# x == y +# +# # bad +# x == y ? false : true +# +# # good +# x != y +# +# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#27 +class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#36 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#56 + def redundant_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#61 + def redundant_condition_inverted?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#78 + def indented_else_node(expression, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#48 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#65 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#71 + def replacement_condition(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#32 +RuboCop::Cop::Style::RedundantConditional::COMPARISON_OPERATOR_MATCHER = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#34 +RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String) + +# Avoid redundant `::` prefix on constant. +# +# How Ruby searches constant is a bit complicated, and it can often be difficult to +# understand from the code whether the `::` is intended or not. Where `Module.nesting` +# is empty, there is no need to prepend `::`, so it would be nice to consistently +# avoid such meaningless `::` prefix to avoid confusion. +# +# NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent +# conflicting rules. Because it respects user configurations that want to enable +# `Lint/ConstantResolution` cop which is disabled by default. +# +# @example +# # bad +# ::Const +# +# # good +# Const +# +# # bad +# class << self +# ::Const +# end +# +# # good +# class << self +# Const +# end +# +# # good +# class A +# ::Const +# end +# +# # good +# module A +# ::Const +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#43 +class RuboCop::Cop::Style::RedundantConstantBase < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#48 + def on_cbase(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#67 + def bad?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#63 + def lint_constant_resolution_config; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#59 + def lint_constant_resolution_cop_enabled?; end + + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#71 + def module_nesting_ancestors_of(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#77 + def used_in_super_class_part?(node, class_node:); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#46 +RuboCop::Cop::Style::RedundantConstantBase::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses a redundant current directory in path. +# +# @example +# +# # bad +# require_relative './path/to/feature' +# +# # good +# require_relative 'path/to/feature' +# +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#16 +class RuboCop::Cop::Style::RedundantCurrentDirectoryInPath < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#23 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#21 +RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::CURRENT_DIRECTORY_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#20 +RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant uses of double splat hash braces. +# +# @example +# +# # bad +# do_something(**{foo: bar, baz: qux}) +# +# # good +# do_something(foo: bar, baz: qux) +# +# # bad +# do_something(**{foo: bar, baz: qux}.merge(options)) +# +# # good +# do_something(foo: bar, baz: qux, **options) +# +# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#22 +class RuboCop::Cop::Style::RedundantDoubleSplatHashBraces < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#29 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#45 + def allowed_double_splat_receiver?(kwsplat); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#55 + def autocorrect(corrector, node, kwsplat); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#89 + def autocorrect_merge_methods(corrector, merge_methods, kwsplat); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#85 + def closing_brace(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#111 + def convert_to_new_arguments(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#107 + def extract_send_methods(kwsplat); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#123 + def mergeable?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#81 + def opening_brace(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#100 + def range_of_merge_methods(merge_methods); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#66 + def root_receiver(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#75 + def select_merge_method_nodes(kwsplat); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#26 +RuboCop::Cop::Style::RedundantDoubleSplatHashBraces::MERGE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#25 +RuboCop::Cop::Style::RedundantDoubleSplatHashBraces::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant `each`. +# +# @example +# +# # bad +# array.each.each { |v| do_something(v) } +# +# # good +# array.each { |v| do_something(v) } +# +# # bad +# array.each.each_with_index { |v, i| do_something(v, i) } +# +# # good +# array.each.with_index { |v, i| do_something(v, i) } +# array.each_with_index { |v, i| do_something(v, i) } +# +# # bad +# array.each.each_with_object { |v, o| do_something(v, o) } +# +# # good +# array.each.with_object { |v, o| do_something(v, o) } +# array.each_with_object { |v, o| do_something(v, o) } +# +# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#34 +class RuboCop::Cop::Style::RedundantEach < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#43 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#93 + def message(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#85 + def range(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#63 + def redundant_each_method(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#104 + def remove_redundant_each(corrector, range, redundant_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#37 +RuboCop::Cop::Style::RedundantEach::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#38 +RuboCop::Cop::Style::RedundantEach::MSG_WITH_INDEX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#39 +RuboCop::Cop::Style::RedundantEach::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#41 +RuboCop::Cop::Style::RedundantEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for RuntimeError as the argument of raise/fail. +# +# @example +# # bad +# raise RuntimeError, 'message' +# raise RuntimeError.new('message') +# +# # good +# raise 'message' +# +# # bad - message is not a string +# raise RuntimeError, Object.new +# raise RuntimeError.new(Object.new) +# +# # good +# raise Object.new.to_s +# +# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#23 +class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#79 + def compact?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#74 + def exploded?(param0 = T.unsafe(nil)); end + + # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and + # `raise RuntimeError.new('message')` to `raise 'message'`. + # + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#33 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#57 + def fix_compact(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#39 + def fix_exploded(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#65 + def replaced_compact(message); end + + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#47 + def replaced_exploded(node, command, message); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#53 + def string_message?(message); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#26 +RuboCop::Cop::Style::RedundantException::MSG_1 = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#27 +RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#29 +RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `fetch(key) { value }` can be replaced by `fetch(key, value)`. +# +# In such cases `fetch(key, value)` method is faster than `fetch(key) { value }`. +# +# NOTE: The block string `'value'` in `hash.fetch(:key) { 'value' }` is detected +# but not when disabled. +# +# @example SafeForConstants: false (default) +# # bad +# hash.fetch(:key) { 5 } +# hash.fetch(:key) { true } +# hash.fetch(:key) { nil } +# array.fetch(5) { :value } +# ENV.fetch(:key) { 'value' } +# +# # good +# hash.fetch(:key, 5) +# hash.fetch(:key, true) +# hash.fetch(:key, nil) +# array.fetch(5, :value) +# ENV.fetch(:key, 'value') +# @example SafeForConstants: true +# # bad +# ENV.fetch(:key) { VALUE } +# +# # good +# ENV.fetch(:key, VALUE) +# +# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#40 +class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#55 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#89 + def rails_cache?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#48 + def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#74 + def basic_literal?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#104 + def build_bad_method(send, body); end + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#97 + def build_good_method(send, body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#111 + def check_for_constant?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#115 + def check_for_string?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#78 + def const_type?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#93 + def fetch_range(send, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#82 + def should_not_check?(send, body); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#45 +RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of superfluous `.rb` extension in +# the filename provided to `require` and `require_relative`. +# +# Note: If the extension is omitted, Ruby tries adding '.rb', '.so', +# and so on to the name until found. If the file named cannot be found, +# a `LoadError` will be raised. +# There is an edge case where `foo.so` file is loaded instead of a `LoadError` +# if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`, +# but that seems harmless. +# +# @example +# # bad +# require 'foo.rb' +# require_relative '../foo.rb' +# +# # good +# require 'foo' +# require 'foo.so' +# require_relative '../foo' +# require_relative '../foo.so' +# +# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#27 +class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#39 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#35 + def require_call?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#53 + def extension_range(name_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#31 +RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#32 +RuboCop::Cop::Style::RedundantFileExtensionInRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies usages of `any?`, `empty?` or `none?` predicate methods +# chained to `select`/`filter`/`find_all` and change them to use predicate method instead. +# +# @example +# # bad +# arr.select { |x| x > 1 }.any? +# +# # good +# arr.any? { |x| x > 1 } +# +# # bad +# arr.select { |x| x > 1 }.empty? +# arr.select { |x| x > 1 }.none? +# +# # good +# arr.none? { |x| x > 1 } +# +# # good +# relation.select(:name).any? +# arr.select { |x| x > 1 }.any?(&:odd?) +# @example AllCops:ActiveSupportExtensionsEnabled: false (default) +# # good +# arr.select { |x| x > 1 }.many? +# +# # good +# arr.select { |x| x > 1 }.present? +# @example AllCops:ActiveSupportExtensionsEnabled: true +# # bad +# arr.select { |x| x > 1 }.many? +# +# # good +# arr.many? { |x| x > 1 } +# +# # bad +# arr.select { |x| x > 1 }.present? +# +# # good +# arr.any? { |x| x > 1 } +# +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#53 +class RuboCop::Cop::Style::RedundantFilterChain < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#81 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#81 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#62 + def select_predicate?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#108 + def offense_range(select_node, predicate_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#112 + def predicate_range(predicate_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#94 + def register_offense(select_node, predicate_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#56 +RuboCop::Cop::Style::RedundantFilterChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#58 +RuboCop::Cop::Style::RedundantFilterChain::RAILS_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#71 +RuboCop::Cop::Style::RedundantFilterChain::REPLACEMENT_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#59 +RuboCop::Cop::Style::RedundantFilterChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for uses of `Object#freeze` on immutable objects. +# +# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0. +# +# NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated +# string literals when `# frozen-string-literal: true` is used. +# +# @example +# # bad +# CONST = 1.freeze +# +# # good +# CONST = 1 +# +# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#19 +class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#26 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#57 + def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#39 + def immutable_literal?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#48 + def strip_parenthesis(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#23 +RuboCop::Cop::Style::RedundantFreeze::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#24 +RuboCop::Cop::Style::RedundantFreeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant heredoc delimiter quotes. +# +# @example +# +# # bad +# do_something(<<~'EOS') +# no string interpolation style text +# EOS +# +# # good +# do_something(<<~EOS) +# no string interpolation style text +# EOS +# +# do_something(<<~'EOS') +# #{string_interpolation_style_text_not_evaluated} +# EOS +# +# do_something(<<~'EOS') +# Preserve \ +# newlines +# EOS +# +# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#29 +class RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#36 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#48 + def need_heredoc_delimiter_quotes?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#33 +RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#34 +RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes::STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = T.let(T.unsafe(nil), Regexp) + +# Checks for `initialize` methods that are redundant. +# +# An initializer is redundant if it does not do anything, or if it only +# calls `super` with the same arguments given to it. If the initializer takes +# an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it +# will not register an offense, because it allows the initializer to take a different +# number of arguments as its superclass potentially does. +# +# NOTE: If an initializer argument has a default value, RuboCop assumes it +# to *not* be redundant. +# +# NOTE: Empty initializers are registered as offenses, but it is possible +# to purposely create an empty `initialize` method to override a superclass's +# initializer. +# +# @example +# # bad +# def initialize +# end +# +# # bad +# def initialize +# super +# end +# +# # bad +# def initialize(a, b) +# super +# end +# +# # bad +# def initialize(a, b) +# super(a, b) +# end +# +# # good +# def initialize +# do_something +# end +# +# # good +# def initialize +# do_something +# super +# end +# +# # good (different number of parameters) +# def initialize(a, b) +# super(a) +# end +# +# # good (default value) +# def initialize(a, b = 5) +# super +# end +# +# # good (default value) +# def initialize(a, b: 5) +# super +# end +# +# # good (changes the parameter requirements) +# def initialize(*) +# end +# +# # good (changes the parameter requirements) +# def initialize(**) +# end +# +# # good (changes the parameter requirements) +# def initialize(...) +# end +# @example AllowComments: true (default) +# +# # good +# def initialize +# # Overriding to negate superclass `initialize` method. +# end +# @example AllowComments: false +# +# # bad +# def initialize +# # Overriding to negate superclass `initialize` method. +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#97 +class RuboCop::Cop::Style::RedundantInitialize < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#106 + def initialize_forwards?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#110 + def on_def(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#134 + def acceptable?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#142 + def allow_comments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#138 + def forwards?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#128 + def register_offense(node, message); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#148 + def same_args?(super_node, args); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#102 +RuboCop::Cop::Style::RedundantInitialize::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#103 +RuboCop::Cop::Style::RedundantInitialize::MSG_EMPTY = T.let(T.unsafe(nil), String) + +# Checks for strings that are just an interpolated expression. +# +# @example +# +# # bad +# "#{@var}" +# +# # good +# @var.to_s +# +# # good if @var is already a String +# @var +# +# source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#39 +class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#49 + def on_dstr(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#122 + def autocorrect_other(corrector, embedded_node, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#105 + def autocorrect_single_variable_interpolation(corrector, embedded_node, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#99 + def autocorrect_variable_interpolation(corrector, embedded_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#95 + def embedded_in_percent_array?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#91 + def implicit_concatenation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#83 + def interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#132 + def require_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#67 + def single_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#74 + def single_variable_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#87 + def variable_interpolation?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#45 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#43 +RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Check for redundant line continuation. +# +# This cop marks a line continuation as redundant if removing the backslash +# does not result in a syntax error. +# However, a backslash at the end of a comment or +# for string concatenation is not redundant and is not considered an offense. +# +# @example +# # bad +# foo. \ +# bar +# foo \ +# &.bar \ +# .baz +# +# # good +# foo. +# bar +# foo +# &.bar +# .baz +# +# # bad +# [foo, \ +# bar] +# {foo: \ +# bar} +# +# # good +# [foo, +# bar] +# {foo: +# bar} +# +# # bad +# foo(bar, \ +# baz) +# +# # good +# foo(bar, +# baz) +# +# # also good - backslash in string concatenation is not redundant +# foo('bar' \ +# 'baz') +# +# # also good - backslash at the end of a comment is not redundant +# foo(bar, # \ +# baz) +# +# # also good - backslash at the line following the newline begins with a + or -, +# # it is not redundant +# 1 \ +# + 2 \ +# - 3 +# +# # also good - backslash with newline between the method name and its arguments, +# # it is not redundant. +# some_method \ +# (argument) +# +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#67 +class RuboCop::Cop::Style::RedundantLineContinuation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#78 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#168 + def argument_is_method?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#136 + def argument_newline?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#100 + def ends_with_backslash_without_comment?(source_line); end + + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#148 + def find_node_for_line(line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#124 + def inside_string_literal?(range, token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#108 + def inside_string_literal_or_method_with_argument?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#175 + def method_call_with_arguments?(node); end + + # A method call without parentheses such as the following cannot remove `\`: + # + # do_something \ + # argument + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#132 + def method_with_argument?(current_token, next_token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#116 + def redundant_line_continuation?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#93 + def require_line_continuation?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#154 + def same_line?(node, line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#179 + def start_with_arithmetic_operator?(source_line); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#104 + def string_concatenation?(source_line); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#72 +RuboCop::Cop::Style::RedundantLineContinuation::ALLOWED_STRING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#73 +RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#71 +RuboCop::Cop::Style::RedundantLineContinuation::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant parentheses. +# +# @example +# +# # bad +# (x) if ((y.z).nil?) +# +# # good +# x if y.z.nil? +# +# source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#16 +class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Parentheses + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#35 + def allowed_pin_operator?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#38 + def arg_in_call_with_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#254 + def first_send_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#259 + def first_super_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#264 + def first_yield_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#166 + def interpolation?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#29 + def method_node_and_args(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#40 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#26 + def range_end?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#32 + def rescue?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#23 + def square_brackets?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#70 + def allowed_ancestor?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#63 + def allowed_expression?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#75 + def allowed_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#80 + def allowed_multiple_expression?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#89 + def allowed_ternary?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#268 + def call_chain_starts_with_int?(begin_node, send_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#131 + def check(begin_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#168 + def check_send(begin_node, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#177 + def check_unary(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#201 + def disallowed_literal?(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#109 + def empty_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#142 + def find_offense_message(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#114 + def first_arg_begins_with_hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#243 + def first_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#56 + def ignore_syntax?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#197 + def keyword_ancestor?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#216 + def keyword_with_redundant_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#102 + def like_method_argument_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#229 + def method_call_with_redundant_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#123 + def method_chain_begins_with_hash_literal(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#187 + def offense(node, msg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#239 + def only_begin_arg?(args); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#48 + def parens_allowed?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#205 + def raised_to_power_negative_numeric?(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#193 + def suspect_unary?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#95 + def ternary_parentheses_required?; end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#20 +RuboCop::Cop::Style::RedundantParentheses::ALLOWED_NODE_TYPES = T.let(T.unsafe(nil), Array) + +# Checks for usage of the %q/%Q syntax when '' or "" would do. +# +# @example +# +# # bad +# name = %q(Bruce Wayne) +# time = %q(8 o'clock) +# question = %q("What did you say?") +# +# # good +# name = 'Bruce Wayne' +# time = "8 o'clock" +# question = '"What did you say?"' +# +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#20 +class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#34 + def on_dstr(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#40 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#99 + def acceptable_capital_q?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#91 + def acceptable_q?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#67 + def allowed_percent_q?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#51 + def check(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#63 + def interpolated_quotes?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#72 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#87 + def start_with_percent_q_variant?(string); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#82 + def string_literal?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#25 +RuboCop::Cop::Style::RedundantPercentQ::DYNAMIC_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#28 +RuboCop::Cop::Style::RedundantPercentQ::EMPTY = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#32 +RuboCop::Cop::Style::RedundantPercentQ::ESCAPED_NON_BACKSLASH = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#23 +RuboCop::Cop::Style::RedundantPercentQ::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#30 +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_CAPITAL_Q = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#29 +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_Q = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#27 +RuboCop::Cop::Style::RedundantPercentQ::QUOTE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#26 +RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#31 +RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp) + +# Identifies places where argument can be replaced from +# a deterministic regexp to a string. +# +# @example +# # bad +# 'foo'.byteindex(/f/) +# 'foo'.byterindex(/f/) +# 'foo'.gsub(/f/, 'x') +# 'foo'.gsub!(/f/, 'x') +# 'foo'.partition(/f/) +# 'foo'.rpartition(/f/) +# 'foo'.scan(/f/) +# 'foo'.split(/f/) +# 'foo'.start_with?(/f/) +# 'foo'.sub(/f/, 'x') +# 'foo'.sub!(/f/, 'x') +# +# # good +# 'foo'.byteindex('f') +# 'foo'.byterindex('f') +# 'foo'.gsub('f', 'x') +# 'foo'.gsub!('f', 'x') +# 'foo'.partition('f') +# 'foo'.rpartition('f') +# 'foo'.scan('f') +# 'foo'.split('f') +# 'foo'.start_with?('f') +# 'foo'.sub('f', 'x') +# 'foo'.sub!('f', 'x') +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#35 +class RuboCop::Cop::Style::RedundantRegexpArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#47 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#47 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#64 + def determinist_regexp?(regexp_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#68 + def preferred_argument(regexp_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#81 + def replacement(regexp_node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#42 +RuboCop::Cop::Style::RedundantRegexpArgument::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#38 +RuboCop::Cop::Style::RedundantRegexpArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#39 +RuboCop::Cop::Style::RedundantRegexpArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#43 +RuboCop::Cop::Style::RedundantRegexpArgument::STR_SPECIAL_CHARS = T.let(T.unsafe(nil), Array) + +# Checks for unnecessary single-element Regexp character classes. +# +# @example +# +# # bad +# r = /[x]/ +# +# # good +# r = /x/ +# +# # bad +# r = /[\s]/ +# +# # good +# r = /\s/ +# +# # bad +# r = %r{/[b]} +# +# # good +# r = %r{/b} +# +# # good +# r = /[ab]/ +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#30 +class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#37 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#101 + def backslash_b?(elem); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#53 + def each_redundant_character_class(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#61 + def each_single_element_character_class(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#83 + def multiple_codepoints?(expression); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#107 + def octal_requiring_char_class?(elem); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#72 + def redundant_single_element_character_class?(node, char_class); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#113 + def requires_escape_outside_char_class?(elem); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#95 + def whitespace_in_free_space_mode?(node, elem); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#87 + def without_character_class(loc); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#34 +RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#33 +RuboCop::Cop::Style::RedundantRegexpCharacterClass::REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = T.let(T.unsafe(nil), Array) + +# Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`. +# Autocorrect replaces to regexp literal which is the simplest and fastest. +# +# @example +# +# # bad +# Regexp.new(/regexp/) +# Regexp.compile(/regexp/) +# +# # good +# /regexp/ +# Regexp.new('regexp') +# Regexp.compile('regexp') +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#20 +class RuboCop::Cop::Style::RedundantRegexpConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#33 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#27 + def redundant_regexp_constructor(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#23 +RuboCop::Cop::Style::RedundantRegexpConstructor::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#24 +RuboCop::Cop::Style::RedundantRegexpConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant escapes inside Regexp literals. +# +# @example +# # bad +# %r{foo\/bar} +# +# # good +# %r{foo/bar} +# +# # good +# /foo\/bar/ +# +# # good +# %r/foo\/bar/ +# +# # good +# %r!foo\!bar! +# +# # bad +# /a\-b/ +# +# # good +# /a-b/ +# +# # bad +# /[\+\-]\d/ +# +# # good +# /[+\-]\d/ +# +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#35 +class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#45 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#60 + def allowed_escape?(node, char, index, within_character_class); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#76 + def char_class_begins_or_ends_with_escaped_hyphen?(node, index); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#92 + def delimiter?(node, char); end + + # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. + # It's for compatibility with regexp_parser 1.8 and will never be maintained. + # + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#99 + def each_escape(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#126 + def escape_range_at_index(node, index); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#41 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_ALWAYS_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#43 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#42 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#39 +RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String) + +# Checks for redundant `return` expressions. +# +# @example +# # These bad cases should be extended to handle methods whose body is +# # if/else or a case expression with a default branch. +# +# # bad +# def test +# return something +# end +# +# # bad +# def test +# one +# two +# three +# return something +# end +# +# # bad +# def test +# return something if something_else +# end +# +# # good +# def test +# something if something_else +# end +# +# # good +# def test +# if x +# elsif y +# else +# end +# end +# @example AllowMultipleReturnValues: false (default) +# # bad +# def test +# return x, y +# end +# @example AllowMultipleReturnValues: true +# # good +# def test +# return x, y +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#55 +class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#69 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#69 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#63 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#104 + def add_braces(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#99 + def add_brackets(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#169 + def allow_multiple_return_values?; end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#164 + def check_begin_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#110 + def check_branch(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#138 + def check_case_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#159 + def check_ensure_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#143 + def check_if_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#155 + def check_resbody_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#150 + def check_rescue_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#126 + def check_return_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#80 + def correct_with_arguments(return_node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#76 + def correct_without_arguments(return_node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#95 + def hash_without_braces?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#173 + def message(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#59 +RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#60 +RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#61 +RuboCop::Cop::Style::RedundantReturn::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant uses of `self`. +# +# The usage of `self` is only needed when: +# +# * Sending a message to same object with zero arguments in +# presence of a method name clash with an argument or a local +# variable. +# +# * Calling an attribute writer to prevent a local variable assignment. +# +# Note, with using explicit self you can only send messages with public or +# protected scope, you cannot send private messages this way. +# +# Note we allow uses of `self` with operators because it would be awkward +# otherwise. +# +# @example +# +# # bad +# def foo(bar) +# self.baz +# end +# +# # good +# def foo(bar) +# self.bar # Resolves name clash with the argument. +# end +# +# def foo +# bar = 1 +# self.bar # Resolves name clash with the local variable. +# end +# +# def foo +# %w[x y z].select do |bar| +# self.bar == bar # Resolves name clash with argument of the block. +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#44 +class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # @return [RedundantSelf] a new instance of RedundantSelf + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#59 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # Assignment of self.x + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#67 + def on_and_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#85 + def on_args(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#119 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#89 + def on_blockarg(node); end + + # Using self.x to distinguish from local variable x + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#80 + def on_def(node); end + + # Using self.x to distinguish from local variable x + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#80 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#125 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#103 + def on_in_pattern(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#98 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#93 + def on_masgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#119 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#73 + def on_op_asgn(node); end + + # Assignment of self.x + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#67 + def on_or_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#107 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#125 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#125 + def on_while(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#181 + def add_lhs_to_local_variables_scopes(rhs, lhs); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#189 + def add_masgn_lhs_variables(rhs, lhs); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#195 + def add_match_var_scopes(in_pattern_node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#143 + def add_scope(node, local_variables = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#175 + def allow_self(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#149 + def allowed_send_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#166 + def on_argument(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#158 + def regular_method_call?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#55 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#48 +RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#49 +RuboCop::Cop::Style::RedundantSelf::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#47 +RuboCop::Cop::Style::RedundantSelf::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where redundant assignments are made for in place +# modification methods. +# +# @example +# # bad +# args = args.concat(ary) +# hash = hash.merge!(other) +# +# # good +# args.concat(foo) +# args += foo +# hash.merge!(other) +# +# # bad +# self.foo = foo.concat(ary) +# +# # good +# foo.concat(ary) +# self.foo += ary +# +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#31 +class RuboCop::Cop::Style::RedundantSelfAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52 + def on_lvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#69 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#96 + def redundant_nonself_assignment?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#86 + def redundant_self_assignment?(param0 = T.unsafe(nil), param1); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#112 + def correction_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#81 + def method_returning_self?(method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#105 + def redundant_assignment?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#45 +RuboCop::Cop::Style::RedundantSelfAssignment::ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#38 +RuboCop::Cop::Style::RedundantSelfAssignment::METHODS_RETURNING_SELF = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#35 +RuboCop::Cop::Style::RedundantSelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where conditional branch makes redundant self-assignment. +# +# It only detects local variable because it may replace state of instance variable, +# class variable, and global variable that have state across methods with `nil`. +# +# @example +# +# # bad +# foo = condition ? bar : foo +# +# # good +# foo = bar if condition +# +# # bad +# foo = condition ? foo : bar +# +# # good +# foo = bar unless condition +# +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#25 +class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#32 + def bad_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#36 + def on_lvasgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#59 + def inconvertible_to_modifier?(if_branch, else_branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#64 + def multiple_statements?(branch); end + + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#74 + def register_offense(if_node, offense_branch, opposite_branch, keyword); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#70 + def self_assign?(variable, branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#53 + def use_if_and_else_branch?(expression); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#29 +RuboCop::Cop::Style::RedundantSelfAssignmentBranch::MSG = T.let(T.unsafe(nil), String) + +# Identifies instances of sorting and then +# taking only the first or last element. The same behavior can +# be accomplished without a relatively expensive sort by using +# `Enumerable#min` instead of sorting and taking the first +# element and `Enumerable#max` instead of sorting and taking the +# last element. Similarly, `Enumerable#min_by` and +# `Enumerable#max_by` can replace `Enumerable#sort_by` calls +# after which only the first or last element is used. +# +# @example +# # bad +# [2, 1, 3].sort.first +# [2, 1, 3].sort[0] +# [2, 1, 3].sort.at(0) +# [2, 1, 3].sort.slice(0) +# +# # good +# [2, 1, 3].min +# +# # bad +# [2, 1, 3].sort.last +# [2, 1, 3].sort[-1] +# [2, 1, 3].sort.at(-1) +# [2, 1, 3].sort.slice(-1) +# +# # good +# [2, 1, 3].max +# +# # bad +# arr.sort_by(&:foo).first +# arr.sort_by(&:foo)[0] +# arr.sort_by(&:foo).at(0) +# arr.sort_by(&:foo).slice(0) +# +# # good +# arr.min_by(&:foo) +# +# # bad +# arr.sort_by(&:foo).last +# arr.sort_by(&:foo)[-1] +# arr.sort_by(&:foo).at(-1) +# arr.sort_by(&:foo).slice(-1) +# +# # good +# arr.max_by(&:foo) +# +# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#79 +class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#104 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#88 + def redundant_sort?(param0 = T.unsafe(nil)); end + + private + + # This gets the start of the accessor whether it has a dot + # (e.g. `.first`) or doesn't (e.g. `[0]`) + # + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#192 + def accessor_start(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#182 + def arg_node(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#186 + def arg_value(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#147 + def autocorrect(corrector, node, sort_node, sorter, accessor); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#165 + def base(accessor, arg); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#114 + def find_redundant_sort(*nodes); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#135 + def message(node, sorter, accessor); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#131 + def offense_range(sort_node, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#124 + def register_offense(node, sort_node, sorter, accessor); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#156 + def replace_with_logical_operator(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#173 + def suffix(sorter); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#161 + def suggestion(sorter, accessor, arg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#200 + def with_logical_operator?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#83 +RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#85 +RuboCop::Cop::Style::RedundantSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `sort_by { ... }` can be replaced by +# `sort`. +# +# @example +# # bad +# array.sort_by { |x| x } +# array.sort_by do |var| +# var +# end +# +# # good +# array.sort +# +# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#18 +class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#25 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#35 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#48 + def redundant_sort_by_block(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#53 + def redundant_sort_by_numblock(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#57 + def sort_by_range(send, node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#22 +RuboCop::Cop::Style::RedundantSortBy::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#23 +RuboCop::Cop::Style::RedundantSortBy::MSG_NUMBLOCK = T.let(T.unsafe(nil), String) + +# Checks for redundant escapes in string literals. +# +# @example +# # bad - no need to escape # without following {/$/@ +# "\#foo" +# +# # bad - no need to escape single quotes inside double quoted string +# "\'foo\'" +# +# # bad - heredocs are also checked for unnecessary escapes +# <<~STR +# \#foo \"foo\" +# STR +# +# # good +# "#foo" +# +# # good +# "\#{no_interpolation}" +# +# # good +# "'foo'" +# +# # good +# "foo\ +# bar" +# +# # good +# <<~STR +# #foo "foo" +# STR +# +# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#37 +class RuboCop::Cop::Style::RedundantStringEscape < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#43 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#79 + def allowed_escape?(node, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#119 + def array_literal?(node, prefix); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#73 + def begin_loc_present?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#153 + def delimiter?(node, char); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#171 + def disabling_interpolation?(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#149 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#139 + def heredoc_with_disabled_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#100 + def interpolation_not_enabled?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#167 + def literal_in_interpolated_or_multiline_string?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#59 + def message(range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#135 + def percent_array_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#111 + def percent_q_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#127 + def percent_w_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#131 + def percent_w_upper_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#107 + def single_quoted?(node); end + + # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#63 + def str_contents_range(node); end +end + +# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#41 +RuboCop::Cop::Style::RedundantStringEscape::MSG = T.let(T.unsafe(nil), String) + +# Enforces using `//` or `%r` around regular expressions. +# +# NOTE: The following `%r` cases using a regexp starts with a blank or `=` +# as a method argument allowed to prevent syntax errors. +# +# [source,ruby] +# ---- +# do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax. +# do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax. +# ---- +# +# @example EnforcedStyle: slashes (default) +# # bad +# snake_case = %r{^[\dA-Z_]+$} +# +# # bad +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# +# # good +# snake_case = /^[\dA-Z_]+$/ +# +# # good +# regex = / +# foo +# (bar) +# (baz) +# /x +# @example EnforcedStyle: percent_r +# # bad +# snake_case = /^[\dA-Z_]+$/ +# +# # bad +# regex = / +# foo +# (bar) +# (baz) +# /x +# +# # good +# snake_case = %r{^[\dA-Z_]+$} +# +# # good +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# @example EnforcedStyle: mixed +# # bad +# snake_case = %r{^[\dA-Z_]+$} +# +# # bad +# regex = / +# foo +# (bar) +# (baz) +# /x +# +# # good +# snake_case = /^[\dA-Z_]+$/ +# +# # good +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# @example AllowInnerSlashes: false (default) +# # If `false`, the cop will always recommend using `%r` if one or more +# # slashes are found in the regexp string. +# +# # bad +# x =~ /home\// +# +# # good +# x =~ %r{home/} +# @example AllowInnerSlashes: true +# # good +# x =~ /home\// +# +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#93 +class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#101 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#144 + def allow_inner_slashes?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#132 + def allowed_mixed_percent_r?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#122 + def allowed_mixed_slash?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#161 + def allowed_omit_parentheses_with_percent_r_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#126 + def allowed_percent_r_literal?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#118 + def allowed_slash_literal?(node); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#221 + def calculate_replacement(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#136 + def contains_disallowed_slash?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#140 + def contains_slash?(node); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#170 + def correct_delimiters(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#176 + def correct_inner_slashes(node, corrector); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#209 + def inner_slash_after_correction(node); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#205 + def inner_slash_before_correction(node); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#213 + def inner_slash_for(opening_delimiter); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#192 + def inner_slash_indices(node); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#148 + def node_body(node, include_begin_nodes: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#157 + def preferred_delimiters; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#153 + def slash_literal?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#99 +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#98 +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String) + +# Sort `require` and `require_relative` in alphabetical order. +# +# @example +# # bad +# require 'b' +# require 'a' +# +# # good +# require 'a' +# require 'b' +# +# # bad +# require_relative 'b' +# require_relative 'a' +# +# # good +# require_relative 'a' +# require_relative 'b' +# +# # good (sorted within each section separated by a blank line) +# require 'a' +# require 'd' +# +# require 'b' +# require 'c' +# +# # good +# require 'b' +# require_relative 'c' +# require 'a' +# +# # bad +# require 'a' +# require 'c' if foo +# require 'b' +# +# # good +# require 'a' +# require 'b' +# require 'c' if foo +# +# # bad +# require 'c' +# if foo +# require 'd' +# require 'b' +# end +# require 'a' +# +# # good +# require 'c' +# if foo +# require 'b' +# require 'd' +# end +# require 'a' +# +# source://rubocop//lib/rubocop/cop/style/require_order.rb#66 +class RuboCop::Cop::Style::RequireOrder < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#76 + def if_inside_only_require(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#83 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#115 + def autocorrect(corrector, node, previous_older_sibling); end + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#101 + def find_previous_older_sibling(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/require_order.rb#133 + def in_same_section?(node1, node2); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/require_order.rb#97 + def not_modifier_form?(node); end + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#123 + def search_node(node); end + + # source://rubocop//lib/rubocop/cop/style/require_order.rb#127 + def sibling_node(node); end +end + +# source://rubocop//lib/rubocop/cop/style/require_order.rb#73 +RuboCop::Cop::Style::RequireOrder::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/require_order.rb#71 +RuboCop::Cop::Style::RequireOrder::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `rescue` in its modifier form is added for following +# reasons: +# +# * The syntax of modifier form `rescue` can be misleading because it +# might lead us to believe that `rescue` handles the given exception +# but it actually rescue all exceptions to return the given rescue +# block. In this case, value returned by handle_error or +# SomeException. +# +# * Modifier form `rescue` would rescue all the exceptions. It would +# silently skip all exception or errors and handle the error. +# Example: If `NoMethodError` is raised, modifier form rescue would +# handle the exception. +# +# @example +# # bad +# some_method rescue handle_error +# +# # bad +# some_method rescue SomeException +# +# # good +# begin +# some_method +# rescue +# handle_error +# end +# +# # good +# begin +# some_method +# rescue SomeException +# handle_error +# end +# +# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#40 +class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RescueNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#52 + def on_resbody(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#70 + def correct_rescue_block(corrector, node, parenthesized); end + + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#86 + def indentation_and_offset(node, parenthesized); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#66 + def parenthesized?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#48 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#46 +RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for rescuing `StandardError`. There are two supported +# styles `implicit` and `explicit`. This cop will not register an offense +# if any error other than `StandardError` is specified. +# +# @example EnforcedStyle: explicit (default) +# # `explicit` will enforce using `rescue StandardError` +# # instead of `rescue`. +# +# # bad +# begin +# foo +# rescue +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError +# bar +# end +# +# # good +# begin +# foo +# rescue OtherError +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, SecurityError +# bar +# end +# @example EnforcedStyle: implicit +# # `implicit` will enforce using `rescue` instead of +# # `rescue StandardError`. +# +# # bad +# begin +# foo +# rescue StandardError +# bar +# end +# +# # good +# begin +# foo +# rescue +# bar +# end +# +# # good +# begin +# foo +# rescue OtherError +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, SecurityError +# bar +# end +# +# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#73 +class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#92 + def on_resbody(node); end + + # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#88 + def rescue_standard_error?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#83 + def rescue_without_error_class?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#118 + def offense_for_explicit_enforced_style(node); end + + # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#107 + def offense_for_implicit_enforced_style(node, error); end +end + +# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#80 +RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#79 +RuboCop::Cop::Style::RescueStandardError::MSG_IMPLICIT = T.let(T.unsafe(nil), String) + +# Enforces consistency between `return nil` and `return`. +# +# This cop is disabled by default. Because there seems to be a perceived semantic difference +# between `return` and `return nil`. The former can be seen as just halting evaluation, +# while the latter might be used when the return value is of specific concern. +# +# Supported styles are `return` and `return_nil`. +# +# @example EnforcedStyle: return (default) +# # bad +# def foo(arg) +# return nil if arg +# end +# +# # good +# def foo(arg) +# return if arg +# end +# @example EnforcedStyle: return_nil +# # bad +# def foo(arg) +# return if arg +# end +# +# # good +# def foo(arg) +# return nil if arg +# end +# +# source://rubocop//lib/rubocop/cop/style/return_nil.rb#35 +class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#90 + def chained_send?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#93 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#48 + def on_return(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#46 + def return_nil_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#43 + def return_node?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#80 + def correct_style?(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#76 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/return_nil.rb#85 + def scoped_node?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/return_nil.rb#39 +RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/return_nil.rb#40 +RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String) + +# Checks if `return` or `return nil` is used in predicate method definitions. +# +# @example +# # bad +# def foo? +# return if condition +# +# do_something? +# end +# +# # bad +# def foo? +# return nil if condition +# +# do_something? +# end +# +# # good +# def foo? +# return false if condition +# +# do_something? +# end +# @example AllowedMethods: ['foo?'] +# # good +# def foo? +# return if condition +# +# do_something? +# end +# @example AllowedPatterns: [/foo/] +# # good +# def foo? +# return if condition +# +# do_something? +# end +# +# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#50 +class RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#62 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#62 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#58 + def return_nil?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#79 + def nil_node_at_the_end_of_method_body(body); end + + # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#87 + def register_offense(offense_node, replacement); end +end + +# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#55 +RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Transforms usages of a method call safeguarded by a non `nil` +# check for the variable whose method is being called to +# safe navigation (`&.`). If there is a method chain, all of the methods +# in the chain need to be checked for safety, and all of the methods will +# need to be changed to use safe navigation. +# +# The default for `ConvertCodeThatCanStartToReturnNil` is `false`. +# When configured to `true`, this will +# check for code in the format `!foo.nil? && foo.bar`. As it is written, +# the return of this code is limited to `false` and whatever the return +# of the method is. If this is converted to safe navigation, +# `foo&.bar` can start returning `nil` as well as what the method +# returns. +# +# The default for `MaxChainLength` is `2` +# We have limited the cop to not register an offense for method chains +# that exceed this option is set. +# +# @example +# # bad +# foo.bar if foo +# foo.bar.baz if foo +# foo.bar(param1, param2) if foo +# foo.bar { |e| e.something } if foo +# foo.bar(param) { |e| e.something } if foo +# +# foo.bar if !foo.nil? +# foo.bar unless !foo +# foo.bar unless foo.nil? +# +# foo && foo.bar +# foo && foo.bar.baz +# foo && foo.bar(param1, param2) +# foo && foo.bar { |e| e.something } +# foo && foo.bar(param) { |e| e.something } +# +# foo ? foo.bar : nil +# foo.nil? ? nil : foo.bar +# !foo.nil? ? foo.bar : nil +# !foo ? nil : foo.bar +# +# # good +# foo&.bar +# foo&.bar&.baz +# foo&.bar(param1, param2) +# foo&.bar { |e| e.something } +# foo&.bar(param) { |e| e.something } +# foo && foo.bar.baz.qux # method chain with more than 2 methods +# foo && foo.nil? # method that `nil` responds to +# +# # Method calls that do not use `.` +# foo && foo < bar +# foo < bar if foo +# +# # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually +# # do the opposite of what the author intends. +# foo && foo.empty? +# +# # This could start returning `nil` as well as the return of the method +# foo.nil? || foo.bar +# !foo || foo.bar +# +# # Methods that are used on assignment, arithmetic operation or +# # comparison should not be converted to use safe navigation +# foo.baz = bar if foo +# foo.baz + bar if foo +# foo.bar > 2 if foo +# +# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#84 +class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # if format: (if checked_variable body nil) + # unless format: (if checked_variable nil body) + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#99 + def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#125 + def not_nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#133 + def on_and(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#127 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#114 + def ternary_safe_navigation_candidate(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#307 + def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#200 + def allowed_if_condition?(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#154 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#299 + def begin_range(node, method_call); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#261 + def chain_length(method_chain, method); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#139 + def check_node(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#181 + def comments(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#303 + def end_range(node, method_call); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#166 + def extract_body(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#243 + def extract_common_parts(method_chain, checked_variable); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#209 + def extract_parts(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#233 + def extract_parts_from_and(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#218 + def extract_parts_from_if(node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#251 + def find_matching_receiver_invocation(method_chain, checked_variable); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#174 + def handle_comments(corrector, node, method_call); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#320 + def max_chain_length; end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#204 + def method_call(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#295 + def method_called?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#287 + def negated?(send_node); end + + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#187 + def relevant_comment_ranges(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#281 + def unsafe_method?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#269 + def unsafe_method_used?(method_chain, method); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#150 + def use_var_only_in_unless_modifier?(node, variable); end +end + +# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#92 +RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#90 +RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String) + +# Identifies usages of `shuffle.first`, +# `shuffle.last`, and `shuffle[]` and change them to use +# `sample` instead. +# +# @example +# # bad +# [1, 2, 3].shuffle.first +# [1, 2, 3].shuffle.first(2) +# [1, 2, 3].shuffle.last +# [2, 1, 3].shuffle.at(0) +# [2, 1, 3].shuffle.slice(0) +# [1, 2, 3].shuffle[2] +# [1, 2, 3].shuffle[0, 2] # sample(2) will do the same +# [1, 2, 3].shuffle[0..2] # sample(3) will do the same +# [1, 2, 3].shuffle(random: Random.new).first +# +# # good +# [1, 2, 3].shuffle +# [1, 2, 3].sample +# [1, 2, 3].sample(3) +# [1, 2, 3].shuffle[1, 3] # sample(3) might return a longer Array +# [1, 2, 3].shuffle[1..3] # sample(3) might return a longer Array +# [1, 2, 3].shuffle[foo, bar] +# [1, 2, 3].shuffle(random: Random.new) +# +# source://rubocop//lib/rubocop/cop/style/sample.rb#30 +class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/sample.rb#41 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#37 + def sample_candidate?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/sample.rb#123 + def correction(shuffle_arg, method, method_args); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#139 + def extract_source(args); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#117 + def message(shuffle_arg, method, method_args, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sample.rb#58 + def offensive?(method, method_args); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#95 + def range_size(range_node); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#130 + def sample_arg(method, method_args); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#69 + def sample_size(method_args); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#78 + def sample_size_for_one_arg(arg); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#88 + def sample_size_for_two_args(first, second); end + + # source://rubocop//lib/rubocop/cop/style/sample.rb#111 + def source_range(shuffle_node, node); end +end + +# source://rubocop//lib/rubocop/cop/style/sample.rb#33 +RuboCop::Cop::Style::Sample::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/sample.rb#34 +RuboCop::Cop::Style::Sample::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for places where an subset of an Enumerable (array, +# range, set, etc.; see note below) is calculated based on a `Regexp` +# match, and suggests `grep` or `grep_v` instead. +# +# NOTE: Hashes do not behave as you may expect with `grep`, which +# means that `hash.grep` is not equivalent to `hash.select`. Although +# RuboCop is limited by static analysis, this cop attempts to avoid +# registering an offense when the receiver is a hash (hash literal, +# `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`). +# +# NOTE: `grep` and `grep_v` were optimized when used without a block +# in Ruby 3.0, but may be slower in previous versions. +# See https://bugs.ruby-lang.org/issues/17030 +# +# @example +# # bad (select or find_all) +# array.select { |x| x.match? /regexp/ } +# array.select { |x| /regexp/.match?(x) } +# array.select { |x| x =~ /regexp/ } +# array.select { |x| /regexp/ =~ x } +# +# # bad (reject) +# array.reject { |x| x.match? /regexp/ } +# array.reject { |x| /regexp/.match?(x) } +# array.reject { |x| x =~ /regexp/ } +# array.reject { |x| /regexp/ =~ x } +# +# # good +# array.grep(regexp) +# array.grep_v(regexp) +# +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#45 +class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#79 + def calls_lvar?(param0 = T.unsafe(nil), param1); end + + # Returns true if a node appears to return a hash + # + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#65 + def creates_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#74 + def env_const?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#88 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#56 + def regexp_match?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#132 + def extract_send_node(block_node); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#145 + def find_regexp(node, block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#156 + def match_predicate_without_receiver?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#141 + def opposite?(regexp_method_send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#106 + def receiver_allowed?(node); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#120 + def register_offense(node, block_node, regexp, replacement); end + + # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#112 + def replacement(regexp_method_send_node, node); end +end + +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#49 +RuboCop::Cop::Style::SelectByRegexp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#52 +RuboCop::Cop::Style::SelectByRegexp::OPPOSITE_REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#53 +RuboCop::Cop::Style::SelectByRegexp::REGEXP_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#51 +RuboCop::Cop::Style::SelectByRegexp::REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#50 +RuboCop::Cop::Style::SelectByRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use the shorthand for self-assignment. +# +# @example +# +# # bad +# x = x + 1 +# +# # good +# x += 1 +# +# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#15 +class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#33 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#29 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#25 + def on_lvasgn(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#94 + def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#74 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#89 + def autocorrect_boolean_node(corrector, node, rhs); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#84 + def autocorrect_send_node(corrector, node, rhs); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#39 + def check(node, var_type); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#62 + def check_boolean_node(node, rhs, var_name, var_type); end + + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#50 + def check_send_node(node, rhs, var_name, var_type); end + + class << self + # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#21 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#18 +RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#19 +RuboCop::Cop::Style::SelfAssignment::OPS = T.let(T.unsafe(nil), Array) + +# Checks for multiple expressions placed on the same line. +# It also checks for lines terminated with a semicolon. +# +# This cop has `AllowAsExpressionSeparator` configuration option. +# It allows `;` to separate several expressions on the same line. +# +# @example +# # bad +# foo = 1; bar = 2; +# baz = 3; +# +# # good +# foo = 1 +# bar = 2 +# baz = 3 +# @example AllowAsExpressionSeparator: false (default) +# # bad +# foo = 1; bar = 2 +# @example AllowAsExpressionSeparator: true +# # good +# foo = 1; bar = 2 +# +# source://rubocop//lib/rubocop/cop/style/semicolon.rb#29 +class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#45 + def on_begin(node); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#39 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#64 + def check_for_line_terminator_or_opener; end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#70 + def each_semicolon; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#106 + def exist_semicolon_after_left_curly_brace?(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#110 + def exist_semicolon_after_left_lambda_curly_brace?(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#118 + def exist_semicolon_after_left_string_interpolation_brace?(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#102 + def exist_semicolon_before_right_curly_brace?(tokens); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#114 + def exist_semicolon_before_right_string_interpolation_brace?(tokens); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#142 + def expressions_per_line(exprs); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#156 + def find_range_node(token_before_semicolon); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#148 + def find_semicolon_positions(line); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#162 + def range_nodes; end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#122 + def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#84 + def semicolon_position(tokens); end + + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#79 + def tokens_for_lines; end + + class << self + # source://rubocop//lib/rubocop/cop/style/semicolon.rb#35 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/semicolon.rb#33 +RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of the send method. +# +# @example +# # bad +# Foo.send(:bar) +# quuz.send(:fred) +# +# # good +# Foo.__send__(:bar) +# quuz.public_send(:fred) +# +# source://rubocop//lib/rubocop/cop/style/send.rb#16 +class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/send.rb#20 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/send.rb#20 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/send.rb#17 +RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/send.rb#18 +RuboCop::Cop::Style::Send::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `fail` and `raise`. +# +# @example EnforcedStyle: only_raise (default) +# # The `only_raise` style enforces the sole use of `raise`. +# # bad +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# # handle it +# end +# +# Kernel.fail +# +# # good +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# raise +# rescue Exception +# # handle it +# end +# +# Kernel.raise +# @example EnforcedStyle: only_fail +# # The `only_fail` style enforces the sole use of `fail`. +# # bad +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# raise +# rescue Exception +# # handle it +# end +# +# Kernel.raise +# +# # good +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# # handle it +# end +# +# Kernel.fail +# @example EnforcedStyle: semantic +# # The `semantic` style enforces the use of `fail` to signal an +# # exception, then will use `raise` to trigger an offense after +# # it has been rescued. +# # bad +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# # Error thrown +# rescue Exception +# fail +# end +# +# Kernel.fail +# Kernel.raise +# +# # good +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# raise 'Preferably with descriptive message' +# end +# +# explicit_receiver.fail +# explicit_receiver.raise +# +# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#107 +class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#120 + def custom_fail_methods(param0); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#117 + def kernel_call?(param0 = T.unsafe(nil), param1); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#122 + def on_rescue(node); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#134 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#206 + def allow(method_name, node); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#188 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#167 + def check_scope(method_name, node); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#180 + def check_send(method_name, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#200 + def command_or_kernel_call?(name, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#149 + def custom_fail_defined?; end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#210 + def each_command_or_kernel_call(method_name, node); end + + # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#156 + def message(method_name); end +end + +# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#111 +RuboCop::Cop::Style::SignalException::FAIL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#112 +RuboCop::Cop::Style::SignalException::RAISE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#114 +RuboCop::Cop::Style::SignalException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Sometimes using dig method ends up with just a single +# argument. In such cases, dig should be replaced with []. +# +# @example +# # bad +# { key: 'value' }.dig(:key) +# [1, 2, 3].dig(0) +# +# # good +# { key: 'value' }[:key] +# [1, 2, 3][0] +# +# # good +# { key1: { key2: 'value' } }.dig(:key1, :key2) +# [1, [2, [3]]].dig(1, 1) +# +# # good +# keys = %i[key1 key2] +# { key1: { key2: 'value' } }.dig(*keys) +# +# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#31 +class RuboCop::Cop::Style::SingleArgumentDig < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#43 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#39 + def single_argument_dig?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#36 +RuboCop::Cop::Style::SingleArgumentDig::IGNORED_ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#34 +RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#35 +RuboCop::Cop::Style::SingleArgumentDig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks whether the block parameters of a single-line +# method accepting a block match the names specified via configuration. +# +# For instance one can configure `reduce`(`inject`) to use |a, e| as +# parameters. +# +# Configuration option: Methods +# Should be set to use this cop. Array of hashes, where each key is the +# method name and value - array of argument names. +# +# @example Methods: [{reduce: %w[a b]}] +# # bad +# foo.reduce { |c, d| c + d } +# foo.reduce { |_, _d| 1 } +# +# # good +# foo.reduce { |a, b| a + b } +# foo.reduce { |a, _b| a } +# foo.reduce { |a, (id, _)| a + id } +# foo.reduce { true } +# +# # good +# foo.reduce do |c, d| +# c + d +# end +# +# source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#31 +class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#36 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#105 + def args_match?(method_name, args); end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#69 + def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#57 + def build_preferred_arguments_map(node, preferred_arguments); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#79 + def eligible_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#83 + def eligible_method?(node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#95 + def method_name(method); end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#91 + def method_names; end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#87 + def methods; end + + # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#99 + def target_args(method_name); end +end + +# source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#34 +RuboCop::Cop::Style::SingleLineBlockParams::MSG = T.let(T.unsafe(nil), String) + +# Checks for single-line `do`...`end` block. +# +# In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic` +# in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to +# preserve semantics and does not change it to `{`...`}` block. +# +# @example +# +# # bad +# foo do |arg| bar(arg) end +# +# # good +# foo do |arg| +# bar(arg) +# end +# +# # bad +# ->(arg) do bar(arg) end +# +# # good +# ->(arg) { bar(arg) } +# +# source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#28 +class RuboCop::Cop::Style::SingleLineDoEndBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#34 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#34 + def on_numblock(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#55 + def do_line(node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#63 + def x(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#31 +RuboCop::Cop::Style::SingleLineDoEndBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for single-line method definitions that contain a body. +# It will accept single-line methods with no body. +# +# Endless methods added in Ruby 3.0 are also accepted by this cop. +# +# If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or +# `allow_always`, single-line methods will be autocorrected to endless +# methods if there is only one statement in the body. +# +# @example +# # bad +# def some_method; body end +# def link_to(url); {:name => url}; end +# def @table.columns; super; end +# +# # good +# def self.resource_class=(klass); end +# def @table.columns; end +# def some_method() = body +# @example AllowIfMethodIsEmpty: true (default) +# # good +# def no_op; end +# @example AllowIfMethodIsEmpty: false +# # bad +# def no_op; end +# +# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#34 +class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#41 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#41 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#60 + def allow_empty?; end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#52 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#97 + def break_line_before(corrector, node, range, indent_steps: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#88 + def correct_to_endless(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#64 + def correct_to_endless?(body_node); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#74 + def correct_to_multiline(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#136 + def disallow_endless_method_style?; end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#104 + def each_part(body); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#121 + def method_body_source(method_body); end + + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#114 + def move_comment(node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#132 + def require_parentheses?(method_body); end +end + +# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#38 +RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#39 +RuboCop::Cop::Style::SingleLineMethods::NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = T.let(T.unsafe(nil), Array) + +# Checks that arrays are sliced with endless ranges instead of +# `ary[start..-1]` on Ruby 2.6+. +# +# @example +# # bad +# items[1..-1] +# +# # good +# items[1..] +# +# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#28 +class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#40 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#38 + def range_till_minus_one?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#34 +RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#35 +RuboCop::Cop::Style::SlicingWithRange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# If the branch of a conditional consists solely of a conditional node, +# its conditions can be combined with the conditions of the outer branch. +# This helps to keep the nesting level from getting too deep. +# +# @example +# # bad +# if condition_a +# if condition_b +# do_something +# end +# end +# +# # bad +# if condition_b +# do_something +# end if condition_a +# +# # good +# if condition_a && condition_b +# do_something +# end +# @example AllowModifier: false (default) +# # bad +# if condition_a +# do_something if condition_b +# end +# +# # bad +# if condition_b +# do_something +# end if condition_a +# @example AllowModifier: true +# # good +# if condition_a +# do_something if condition_b +# end +# +# # good +# if condition_b +# do_something +# end if condition_a +# +# source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#49 +class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#59 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#242 + def allow_modifier?; end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#227 + def arguments_range(node); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#81 + def assigned_variables(condition); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#98 + def autocorrect(corrector, node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#110 + def autocorrect_outer_condition_basic(corrector, node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#125 + def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#145 + def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#175 + def correct_for_comment(corrector, node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#136 + def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#165 + def correct_for_outer_condition_modify_form_style(corrector, node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#130 + def correct_from_unless_to_if(corrector, node, is_modify_form: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#184 + def correct_outer_condition(corrector, condition); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#197 + def insert_bang(corrector, node, is_modify_form); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#210 + def insert_bang_for_and(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#89 + def offending_branch?(node, branch); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#246 + def outer_condition_modify_form?(node, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#238 + def replace_condition(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#222 + def require_parentheses?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#74 + def use_variable_assignment_in_condition?(condition, if_branch); end + + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#155 + def wrap_condition(corrector, condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#233 + def wrap_condition?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#55 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#53 +RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) + +# Looks for uses of Perl-style global variables. +# Correcting to global variables in the 'English' library +# will add a require statement to the top of the file if +# enabled by RequireEnglish config. +# +# Like `use_perl_names` but allows builtin global vars. +# +# # good +# puts $LOAD_PATH +# puts $LOADED_FEATURES +# puts $PROGRAM_NAME +# puts ARGV +# puts $: +# puts $" +# puts $0 +# puts $! +# puts $@ +# puts $; +# puts $, +# puts $/ +# puts $\ +# puts $. +# puts $_ +# puts $> +# puts $< +# puts $$ +# puts $? +# puts $~ +# puts $= +# puts $* +# +# @example EnforcedStyle: use_english_names (default) +# # good +# require 'English' # or this could be in another file. +# +# puts $LOAD_PATH +# puts $LOADED_FEATURES +# puts $PROGRAM_NAME +# puts $ERROR_INFO +# puts $ERROR_POSITION +# puts $FIELD_SEPARATOR # or $FS +# puts $OUTPUT_FIELD_SEPARATOR # or $OFS +# puts $INPUT_RECORD_SEPARATOR # or $RS +# puts $OUTPUT_RECORD_SEPARATOR # or $ORS +# puts $INPUT_LINE_NUMBER # or $NR +# puts $LAST_READ_LINE +# puts $DEFAULT_OUTPUT +# puts $DEFAULT_INPUT +# puts $PROCESS_ID # or $PID +# puts $CHILD_STATUS +# puts $LAST_MATCH_INFO +# puts $IGNORECASE +# puts $ARGV # or ARGV +# @example EnforcedStyle: use_perl_names +# # good +# puts $: +# puts $" +# puts $0 +# puts $! +# puts $@ +# puts $; +# puts $, +# puts $/ +# puts $\ +# puts $. +# puts $_ +# puts $> +# puts $< +# puts $$ +# puts $? +# puts $~ +# puts $= +# puts $* +# @example EnforcedStyle: use_builtin_english_names +# +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#87 +class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RequireLibrary + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#176 + def autocorrect(corrector, node, global_var); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#168 + def message(global_var); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#152 + def on_gvar(node); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#147 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#247 + def add_require_english?; end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#241 + def english_name_replacement(preferred_name, node); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#190 + def format_english_message(global_var); end + + # For now, we assume that lists are 2 items or less. Easy grammar! + # + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#212 + def format_list(items); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#198 + def format_message(english, regular, global); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#235 + def matching_styles(global); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#227 + def preferred_names(global); end + + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#216 + def replacement(node, global_var); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#251 + def should_require_english?(global_var); end +end + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#128 +RuboCop::Cop::Style::SpecialGlobalVars::BUILTIN_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#100 +RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#145 +RuboCop::Cop::Style::SpecialGlobalVars::LIBRARY_NAME = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#93 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#96 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#98 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String) + +# Anything *not* in this set is provided by the English library. +# +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#122 +RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#124 +RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#139 +RuboCop::Cop::Style::SpecialGlobalVars::STYLE_VARS_MAP = T.let(T.unsafe(nil), Hash) + +# Check for parentheses around stabby lambda arguments. +# There are two different styles. Defaults to `require_parentheses`. +# +# @example EnforcedStyle: require_parentheses (default) +# # bad +# ->a,b,c { a + b + c } +# +# # good +# ->(a,b,c) { a + b + c} +# @example EnforcedStyle: require_no_parentheses +# # bad +# ->(a,b,c) { a + b + c } +# +# # good +# ->a,b,c { a + b + c} +# +# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#22 +class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#28 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#54 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#46 + def missing_parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#58 + def missing_parentheses_corrector(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#73 + def parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#50 + def redundant_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#69 + def stabby_lambda_with_args?(node); end + + # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#62 + def unwanted_parentheses_corrector(corrector, node); end +end + +# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#27 +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_NO_REQUIRE = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#26 +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), String) + +# Checks for places where classes with only class methods can be +# replaced with a module. Classes should be used only when it makes sense to create +# instances out of them. +# +# @example +# # bad +# class SomeClass +# def self.some_method +# # body omitted +# end +# +# def self.some_other_method +# # body omitted +# end +# end +# +# # good +# module SomeModule +# module_function +# +# def some_method +# # body omitted +# end +# +# def some_other_method +# # body omitted +# end +# end +# +# # good - has instance method +# class SomeClass +# def instance_method; end +# def self.class_method; end +# end +# +# source://rubocop//lib/rubocop/cop/style/static_class.rb#46 +class RuboCop::Cop::Style::StaticClass < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/static_class.rb#53 + def on_class(class_node); end + + private + + # source://rubocop//lib/rubocop/cop/style/static_class.rb#64 + def autocorrect(corrector, class_node); end + + # source://rubocop//lib/rubocop/cop/style/static_class.rb#77 + def autocorrect_def(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/static_class.rb#83 + def autocorrect_sclass(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/static_class.rb#90 + def class_convertible_to_module?(class_node); end + + # source://rubocop//lib/rubocop/cop/style/static_class.rb#114 + def class_elements(class_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/static_class.rb#102 + def extend_call?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/static_class.rb#106 + def sclass_convertible_to_module?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/static_class.rb#51 +RuboCop::Cop::Style::StaticClass::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `$stderr.puts` can be replaced by +# `warn`. The latter has the advantage of easily being disabled by, +# the `-W0` interpreter flag or setting `$VERBOSE` to `nil`. +# +# @example +# # bad +# $stderr.puts('hello') +# +# # good +# warn('hello') +# +# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#17 +class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#32 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#25 + def stderr_puts?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#43 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#47 + def stderr_gvar?(sym); end + + # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#51 + def stderr_puts_range(send); end +end + +# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#21 +RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#22 +RuboCop::Cop::Style::StderrPuts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `String#split` with empty string or regexp literal argument. +# +# @example +# # bad +# string.split(//) +# string.split('') +# +# # good +# string.chars +# +# source://rubocop//lib/rubocop/cop/style/string_chars.rb#21 +class RuboCop::Cop::Style::StringChars < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_chars.rb#29 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/string_chars.rb#27 +RuboCop::Cop::Style::StringChars::BAD_ARGUMENTS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/string_chars.rb#25 +RuboCop::Cop::Style::StringChars::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/string_chars.rb#26 +RuboCop::Cop::Style::StringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where string concatenation +# can be replaced with string interpolation. +# +# The cop can autocorrect simple cases but will skip autocorrecting +# more complex cases where the resulting code would be harder to read. +# In those cases, it might be useful to extract statements to local +# variables or methods which you can then interpolate in a string. +# +# NOTE: When concatenation between two strings is broken over multiple +# lines, this cop does not register an offense; instead, +# `Style/LineEndConcatenation` will pick up the offense if enabled. +# +# Two modes are supported: +# 1. `aggressive` style checks and corrects all occurrences of `+` where +# either the left or right side of `+` is a string literal. +# 2. `conservative` style on the other hand, checks and corrects only if +# left side (receiver of `+` method call) is a string literal. +# This is useful when the receiver is some expression that returns string like `Pathname` +# instead of a string literal. +# +# @example Mode: aggressive (default) +# # bad +# email_with_name = user.name + ' <' + user.email + '>' +# Pathname.new('/') + 'test' +# +# # good +# email_with_name = "#{user.name} <#{user.email}>" +# email_with_name = format('%s <%s>', user.name, user.email) +# "#{Pathname.new('/')}test" +# +# # accepted, line-end concatenation +# name = 'First' + +# 'Last' +# @example Mode: conservative +# # bad +# 'Hello' + user.name +# +# # good +# "Hello #{user.name}" +# user.name + '!!' +# Pathname.new('/') + 'test' +# +# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#53 +class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#69 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#73 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#62 + def string_concatenation?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#116 + def collect_parts(node, parts = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#141 + def corrected_ancestor?(node); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#108 + def find_topmost_plus_node(node); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#162 + def handle_quotes(parts); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#135 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#98 + def line_end_concatenation?(node); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#172 + def mode; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#127 + def plus_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#86 + def register_offense(topmost_plus_node, parts); end + + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#145 + def replacement(parts); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#168 + def single_quoted?(str_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#131 + def uncorrectable?(part); end +end + +# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#58 +RuboCop::Cop::Style::StringConcatenation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#59 +RuboCop::Cop::Style::StringConcatenation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of strings as keys in hashes. The use of +# symbols is preferred instead. +# +# @example +# # bad +# { 'one' => 1, 'two' => 2, 'three' => 3 } +# +# # good +# { one: 1, two: 2, three: 3 } +# +# source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#19 +class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#42 + def on_pair(node); end + + # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#30 + def receive_environments_method?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#25 + def string_hash_key?(param0 = T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#22 +RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String) + +# Checks if uses of quotes match the configured preference. +# +# @example EnforcedStyle: single_quotes (default) +# # bad +# "No special symbols" +# "No string interpolation" +# "Just text" +# +# # good +# 'No special symbols' +# 'No string interpolation' +# 'Just text' +# "Wait! What's #{this}!" +# @example EnforcedStyle: double_quotes +# # bad +# 'Just some text' +# 'No special chars or interpolation' +# +# # good +# "Just some text" +# "No special chars or interpolation" +# "Every string in #{project} uses double_quotes" +# +# source://rubocop//lib/rubocop/cop/style/string_literals.rb#29 +class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#37 + def on_dstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#123 + def accept_child_double_quotes?(nodes); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#71 + def all_string_literals?(nodes); end + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#61 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#105 + def check_multiline_quote_style(node, quote); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#101 + def consistent_multiline?; end + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#75 + def detect_quote_styles(node); end + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#87 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#97 + def offense?(node); end + + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#65 + def register_offense(node, message: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#119 + def unexpected_double_quotes?(quote); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals.rb#115 + def unexpected_single_quotes?(quote); end +end + +# source://rubocop//lib/rubocop/cop/style/string_literals.rb#35 +RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String) + +# Checks that quotes inside string, symbol, and regexp interpolations +# match the configured preference. +# +# @example EnforcedStyle: single_quotes (default) +# # bad +# string = "Tests #{success ? "PASS" : "FAIL"}" +# symbol = :"Tests #{success ? "PASS" : "FAIL"}" +# heredoc = <<~TEXT +# Tests #{success ? "PASS" : "FAIL"} +# TEXT +# regexp = /Tests #{success ? "PASS" : "FAIL"}/ +# +# # good +# string = "Tests #{success ? 'PASS' : 'FAIL'}" +# symbol = :"Tests #{success ? 'PASS' : 'FAIL'}" +# heredoc = <<~TEXT +# Tests #{success ? 'PASS' : 'FAIL'} +# TEXT +# regexp = /Tests #{success ? 'PASS' : 'FAIL'}/ +# @example EnforcedStyle: double_quotes +# # bad +# string = "Tests #{success ? 'PASS' : 'FAIL'}" +# symbol = :"Tests #{success ? 'PASS' : 'FAIL'}" +# heredoc = <<~TEXT +# Tests #{success ? 'PASS' : 'FAIL'} +# TEXT +# regexp = /Tests #{success ? 'PASS' : 'FAIL'}/ +# +# # good +# string = "Tests #{success ? "PASS" : "FAIL"}" +# symbol = :"Tests #{success ? "PASS" : "FAIL"}" +# heredoc = <<~TEXT +# Tests #{success ? "PASS" : "FAIL"} +# TEXT +# regexp = /Tests #{success ? "PASS" : "FAIL"}/ +# +# source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#42 +class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#48 + def autocorrect(corrector, node); end + + # Cop classes that include the StringHelp module usually ignore regexp + # nodes. Not so for this cop, which is why we override the on_regexp + # definition with an empty one. + # + # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#55 + def on_regexp(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#59 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#66 + def offense?(node); end +end + +# Enforces the use of consistent method names +# from the String class. +# +# @example +# # bad +# 'name'.intern +# 'var'.unfavored_method +# +# # good +# 'name'.to_sym +# 'var'.preferred_method +# +# source://rubocop//lib/rubocop/cop/style/string_methods.rb#17 +class RuboCop::Cop::Style::StringMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/string_methods.rb#23 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/string_methods.rb#23 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/string_methods.rb#21 +RuboCop::Cop::Style::StringMethods::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `lstrip.rstrip` can be replaced by +# `strip`. +# +# @example +# # bad +# 'abc'.lstrip.rstrip +# 'abc'.rstrip.lstrip +# +# # good +# 'abc'.strip +# +# source://rubocop//lib/rubocop/cop/style/strip.rb#16 +class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/strip.rb#24 + def lstrip_rstrip(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/strip.rb#29 + def on_send(node); end +end + +# source://rubocop//lib/rubocop/cop/style/strip.rb#20 +RuboCop::Cop::Style::Strip::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/strip.rb#21 +RuboCop::Cop::Style::Strip::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for inheritance from Struct.new. +# +# @example +# # bad +# class Person < Struct.new(:first_name, :last_name) +# def age +# 42 +# end +# end +# +# # good +# Person = Struct.new(:first_name, :last_name) do +# def age +# 42 +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#26 +class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#33 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#45 + def struct_constructor?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#52 + def correct_parent(parent, corrector); end + + # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#62 + def range_for_empty_class_body(class_node, struct_new); end +end + +# source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#30 +RuboCop::Cop::Style::StructInheritance::MSG = T.let(T.unsafe(nil), String) + +# Enforces the presence of parentheses in `super` containing arguments. +# +# `super` is a keyword and is provided as a distinct cop from those designed for method call. +# +# @example +# +# # bad +# super name, age +# +# # good +# super(name, age) +# +# source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#18 +class RuboCop::Cop::Style::SuperWithArgsParentheses < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#23 + def on_super(node); end +end + +# source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#21 +RuboCop::Cop::Style::SuperWithArgsParentheses::MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of shorthand-style swapping of 2 variables. +# +# @example +# # bad +# tmp = x +# x = y +# y = tmp +# +# # good +# x, y = y, x +# +# source://rubocop//lib/rubocop/cop/style/swap_values.rb#21 +class RuboCop::Cop::Style::SwapValues < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_asgn(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_casgn(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_cvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_gvasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_ivasgn(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30 + def on_lvasgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#47 + def allowed_assignment?(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#104 + def correction_range(tmp_assign, y_assign); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#81 + def lhs(node); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#66 + def message(x_assign, y_assign); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#75 + def replacement(x_assign); end + + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#95 + def rhs(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#60 + def simple_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/swap_values.rb#51 + def swapping_values?(tmp_assign, x_assign, y_assign); end +end + +# source://rubocop//lib/rubocop/cop/style/swap_values.rb#25 +RuboCop::Cop::Style::SwapValues::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/swap_values.rb#28 +RuboCop::Cop::Style::SwapValues::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Set) + +# Checks for array literals made up of symbols that are not +# using the %i() syntax. +# +# Alternatively, it checks for symbol arrays using the %i() syntax on +# projects which do not want to use that syntax, perhaps because they +# support a version of Ruby lower than 2.0. +# +# Configuration option: MinSize +# If set, arrays with fewer elements than this value will not trigger the +# cop. For example, a `MinSize` of `3` will not enforce a style on an +# array of 2 or fewer elements. +# +# @example EnforcedStyle: percent (default) +# # good +# %i[foo bar baz] +# +# # bad +# [:foo, :bar, :baz] +# +# # bad (contains spaces) +# %i[foo\ bar baz\ quux] +# +# # bad (contains [] with spaces) +# %i[foo \[ \]] +# +# # bad (contains () with spaces) +# %i(foo \( \)) +# @example EnforcedStyle: brackets +# # good +# [:foo, :bar, :baz] +# +# # bad +# %i[foo bar baz] +# +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#40 +class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#66 + def on_array(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#96 + def build_bracketed_array(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#78 + def complex_content?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#92 + def invalid_percent_array_contents?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#119 + def symbol_without_quote?(string); end + + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#111 + def to_symbol_literal(string); end + + class << self + # Returns the value of attribute largest_brackets. + # + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#63 + def largest_brackets; end + + # Sets the attribute largest_brackets + # + # @param value the value to set the attribute largest_brackets to. + # + # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#63 + def largest_brackets=(_arg0); end + end +end + +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#51 +RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#52 +RuboCop::Cop::Style::SymbolArray::DELIMITERS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#50 +RuboCop::Cop::Style::SymbolArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#57 +RuboCop::Cop::Style::SymbolArray::REDEFINABLE_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#53 +RuboCop::Cop::Style::SymbolArray::SPECIAL_GVARS = T.let(T.unsafe(nil), Array) + +# Checks symbol literal syntax. +# +# @example +# +# # bad +# :"symbol" +# +# # good +# :symbol +# +# source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#15 +class RuboCop::Cop::Style::SymbolLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#20 + def on_sym(node); end +end + +# source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#18 +RuboCop::Cop::Style::SymbolLiteral::MSG = T.let(T.unsafe(nil), String) + +# Use symbols as procs when possible. +# +# If you prefer a style that allows block for method with arguments, +# please set `true` to `AllowMethodsWithArguments`. +# `define_method?` methods are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# something.map { |s| s.upcase } +# something.map { _1.upcase } +# +# # good +# something.map(&:upcase) +# @example AllowMethodsWithArguments: false (default) +# # bad +# something.do_something(foo) { |o| o.bar } +# +# # good +# something.do_something(foo, &:bar) +# @example AllowMethodsWithArguments: true +# # good +# something.do_something(foo) { |o| o.bar } +# @example AllowComments: false (default) +# # bad +# something.do_something do |s| # some comment +# # some comment +# s.upcase # some comment +# # some comment +# end +# @example AllowComments: true +# # good - if there are comment in either position +# something.do_something do |s| # some comment +# # some comment +# s.upcase # some comment +# # some comment +# end +# @example AllowedMethods: [define_method] (default) +# # good +# define_method(:foo) { |foo| foo.bar } +# @example AllowedPatterns: [] (default) +# # bad +# something.map { |s| s.upcase } +# @example AllowedPatterns: ['map'] (default) +# # good +# something.map { |s| s.upcase } +# +# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#87 +class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#136 + def destructuring_block_argument?(argument_node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#116 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#116 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#98 + def proc_node?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#104 + def symbol_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#101 + def symbol_proc_receiver?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#204 + def allow_comments?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#200 + def allow_if_method_has_argument?(send_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#151 + def allowed_method_name?(name); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#164 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#176 + def autocorrect_with_args(corrector, node, args, method_name); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#172 + def autocorrect_without_args(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#190 + def begin_pos_for_replacement(node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#185 + def block_range_with_space(node); end + + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#155 + def register_offense(node, method_name, block_method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#147 + def unsafe_array_usage?(node); end + + # See: https://github.com/rubocop/rubocop/issues/10864 + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#143 + def unsafe_hash_usage?(node); end + + class << self + # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#111 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#94 +RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#95 +RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array) + +# Corrector to correct conditional assignment in ternary conditions. +# +# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#500 +class RuboCop::Cop::Style::TernaryCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#505 + def correct(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#509 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#523 + def correction(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#536 + def element_assignment?(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#540 + def extract_branches(node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#553 + def move_branch_inside_condition(corrector, branch, assignment); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#548 + def remove_parentheses(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#527 + def ternary(node); end + end +end + +# Checks for the presence of parentheses around ternary +# conditions. It is configurable to enforce inclusion or omission of +# parentheses using `EnforcedStyle`. Omission is only enforced when +# removing the parentheses won't cause a different behavior. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example EnforcedStyle: require_no_parentheses (default) +# # bad +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = (bar && baz) ? a : b +# +# # good +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = bar && baz ? a : b +# @example EnforcedStyle: require_parentheses +# # bad +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = bar && baz ? a : b +# +# # good +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = (bar && baz) ? a : b +# @example EnforcedStyle: require_parentheses_when_complex +# # bad +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = bar && baz ? a : b +# +# # good +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = (bar && baz) ? a : b +# @example AllowSafeAssignment: true (default) +# # good +# foo = (bar = baz) ? a : b +# @example AllowSafeAssignment: false +# # bad +# foo = (bar = baz) ? a : b +# +# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#57 +class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#193 + def method_name(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#69 + def on_if(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#100 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#183 + def below_ternary_precedence?(child); end + + # If the condition is parenthesized we recurse and check for any + # complex expressions within it. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#131 + def complex_condition?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#89 + def condition_as_parenthesized_one_line_pattern_matching?(condition); end + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#198 + def correct_parenthesized(corrector, condition); end + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#208 + def correct_unparenthesized(corrector, condition); end + + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#151 + def message(node); end + + # Anything that is not a variable, constant, or method/.method call + # will be counted as a complex expression. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#141 + def non_complex_expression?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#145 + def non_complex_send?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#113 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#85 + def only_closing_parenthesis_is_last_line?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#169 + def parenthesized?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#161 + def require_parentheses?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#165 + def require_parentheses_when_complex?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#179 + def unparenthesized_method_call?(child); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#173 + def unsafe_autocorrect?(condition); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#212 + def whitespace_after?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#66 +RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#67 +RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#64 +RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#63 +RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set) + +# Newcomers to ruby applications may write top-level methods, +# when ideally they should be organized in appropriate classes or modules. +# This cop looks for definitions of top-level methods and warns about them. +# +# However for ruby scripts it is perfectly fine to use top-level methods. +# Hence this cop is disabled by default. +# +# @example +# # bad +# def some_method +# end +# +# # bad +# def self.some_method +# end +# +# # bad +# define_method(:foo) { puts 1 } +# +# # good +# module Foo +# def some_method +# end +# end +# +# # good +# class Foo +# def self.some_method +# end +# end +# +# # good +# Struct.new do +# def some_method +# end +# end +# +# # good +# class Foo +# define_method(:foo) { puts 1 } +# end +# +# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#47 +class RuboCop::Cop::Style::TopLevelMethodDefinition < ::RuboCop::Cop::Base + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#79 + def define_method_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#60 + def on_block(node); end + + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52 + def on_defs(node); end + + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#60 + def on_numblock(node); end + + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#70 + def top_level_method_definition?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#48 +RuboCop::Cop::Style::TopLevelMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#50 +RuboCop::Cop::Style::TopLevelMethodDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for trailing code after the class definition. +# +# @example +# # bad +# class Foo; def foo; end +# end +# +# # good +# class Foo +# def foo; end +# end +# +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#18 +class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25 + def on_class(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25 + def on_sclass(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#23 +RuboCop::Cop::Style::TrailingBodyOnClass::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing code after the method definition. +# +# NOTE: It always accepts endless method definitions that are basically on the same line. +# +# @example +# # bad +# def some_method; do_stuff +# end +# +# def f(x); b = foo +# b[c: x] +# end +# +# # good +# def some_method +# do_stuff +# end +# +# def f(x) +# b = foo +# b[c: x] +# end +# +# def endless_method = do_stuff +# +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#31 +class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#38 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#38 + def on_defs(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#36 +RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing code after the module definition. +# +# @example +# # bad +# module Foo extend self +# end +# +# # good +# module Foo +# extend self +# end +# +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#18 +class RuboCop::Cop::Style::TrailingBodyOnModule < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#25 + def on_module(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#23 +RuboCop::Cop::Style::TrailingBodyOnModule::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing comma in argument lists. +# The supported styles are: +# +# * `consistent_comma`: Requires a comma after the last argument, +# for all parenthesized method calls with arguments. +# * `comma`: Requires a comma after the last argument, but only for +# parenthesized method calls where each argument is on its own line. +# * `no_comma`: Requires that there is no comma after the last +# argument. +# +# @example EnforcedStyleForMultiline: consistent_comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # bad +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, +# 3 +# ) +# +# # bad +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, 2, 3 +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: no_comma (default) +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, +# 2 +# ) +# +# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#87 +class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95 + def on_csend(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95 + def on_send(node); end + + class << self + # source://rubocop-rspec/2.27.1/lib/rubocop-rspec.rb#60 + def autocorrect_incompatible_with; end + end +end + +# Checks for trailing comma in array literals. +# The configuration options are: +# +# * `consistent_comma`: Requires a comma after the +# last item of all non-empty, multiline array literals. +# * `comma`: Requires a comma after last item in an array, +# but only when each item is on its own line. +# * `no_comma`: Does not require a comma after the +# last item in an array +# +# @example EnforcedStyleForMultiline: consistent_comma +# # bad +# a = [1, 2,] +# +# # good +# a = [1, 2] +# +# # good +# a = [ +# 1, 2, +# 3, +# ] +# +# # good +# a = [ +# 1, 2, 3, +# ] +# +# # good +# a = [ +# 1, +# 2, +# ] +# @example EnforcedStyleForMultiline: comma +# # bad +# a = [1, 2,] +# +# # good +# a = [1, 2] +# +# # bad +# a = [ +# 1, 2, +# 3, +# ] +# +# # good +# a = [ +# 1, 2, +# 3 +# ] +# +# # bad +# a = [ +# 1, 2, 3, +# ] +# +# # good +# a = [ +# 1, 2, 3 +# ] +# +# # good +# a = [ +# 1, +# 2, +# ] +# @example EnforcedStyleForMultiline: no_comma (default) +# # bad +# a = [1, 2,] +# +# # good +# a = [ +# 1, +# 2 +# ] +# +# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_array_literal.rb#84 +class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_array_literal.rb#88 + def on_array(node); end +end + +# Checks whether trailing commas in block arguments are +# required. Blocks with only one argument and a trailing comma require +# that comma to be present. Blocks with more than one argument never +# require a trailing comma. +# +# @example +# # bad +# add { |foo, bar,| foo + bar } +# +# # good +# add { |foo, bar| foo + bar } +# +# # good +# add { |foo,| foo } +# +# # good +# add { foo } +# +# # bad +# add do |foo, bar,| +# foo + bar +# end +# +# # good +# add do |foo, bar| +# foo + bar +# end +# +# # good +# add do |foo,| +# foo +# end +# +# # good +# add do +# foo + bar +# end +# +# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#62 +class RuboCop::Cop::Style::TrailingCommaInBlockArgs < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#67 + def on_block(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#83 + def arg_count(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#95 + def argument_tokens(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#91 + def last_comma(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#87 + def trailing_comma?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#79 + def useless_trailing_comma?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#65 +RuboCop::Cop::Style::TrailingCommaInBlockArgs::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing comma in hash literals. +# The configuration options are: +# +# * `consistent_comma`: Requires a comma after the +# last item of all non-empty, multiline hash literals. +# * `comma`: Requires a comma after the last item in a hash, +# but only when each item is on its own line. +# * `no_comma`: Does not require a comma after the +# last item in a hash +# +# @example EnforcedStyleForMultiline: consistent_comma +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { foo: 1, bar: 2 } +# +# # good +# a = { +# foo: 1, bar: 2, +# qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, qux: 3, +# } +# +# # good +# a = { +# foo: 1, +# bar: 2, +# } +# @example EnforcedStyleForMultiline: comma +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { foo: 1, bar: 2 } +# +# # bad +# a = { +# foo: 1, bar: 2, +# qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, +# qux: 3 +# } +# +# # bad +# a = { +# foo: 1, bar: 2, qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, qux: 3 +# } +# +# # good +# a = { +# foo: 1, +# bar: 2, +# } +# @example EnforcedStyleForMultiline: no_comma (default) +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { +# foo: 1, +# bar: 2 +# } +# +# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb#87 +class RuboCop::Cop::Style::TrailingCommaInHashLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb#91 + def on_hash(node); end +end + +# Checks for trailing code after the method definition. +# +# @example +# # bad +# def some_method +# do_stuff; end +# +# def do_this(x) +# baz.map { |b| b.this(x) } end +# +# def foo +# block do +# bar +# end end +# +# # good +# def some_method +# do_stuff +# end +# +# def do_this(x) +# baz.map { |b| b.this(x) } +# end +# +# def foo +# block do +# bar +# end +# end +# +# source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#36 +class RuboCop::Cop::Style::TrailingMethodEndStatement < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#41 + def on_def(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#55 + def body_and_end_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#51 + def trailing_end?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#39 +RuboCop::Cop::Style::TrailingMethodEndStatement::MSG = T.let(T.unsafe(nil), String) + +# Checks for extra underscores in variable assignment. +# +# @example +# # bad +# a, b, _ = foo() +# a, b, _, = foo() +# a, _, _ = foo() +# a, _, _, = foo() +# +# # good +# a, b, = foo() +# a, = foo() +# *a, b, _ = foo() +# # => We need to know to not include 2 variables in a +# a, *b, _ = foo() +# # => The correction `a, *b, = foo()` is a syntax error +# @example AllowNamedUnderscoreVariables: true (default) +# # good +# a, b, _something = foo() +# @example AllowNamedUnderscoreVariables: false +# # bad +# a, b, _something = foo() +# +# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#31 +class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#41 + def on_masgn(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#92 + def allow_named_underscore_variables; end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#125 + def children_offenses(variables); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#57 + def find_first_offense(variables); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#66 + def find_first_possible_offense(variables); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#108 + def main_node_offense(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#146 + def range_for_parentheses(offense, left); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#88 + def reverse_index(collection, item); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#80 + def splat_variable_before?(first_offense, variables); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#96 + def unneeded_ranges(node); end + + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#133 + def unused_range(node_type, mlhs_node, right); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#129 + def unused_variables_only?(offense, variables); end +end + +# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#38 +RuboCop::Cop::Style::TrailingUnderscoreVariable::DISALLOW = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#36 +RuboCop::Cop::Style::TrailingUnderscoreVariable::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#37 +RuboCop::Cop::Style::TrailingUnderscoreVariable::UNDERSCORE = T.let(T.unsafe(nil), String) + +# Looks for trivial reader/writer methods, that could +# have been created with the attr_* family of functions automatically. +# `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`, +# `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods +# are allowed by default. These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# def foo +# @foo +# end +# +# def bar=(val) +# @bar = val +# end +# +# def self.baz +# @baz +# end +# +# # good +# attr_reader :foo +# attr_writer :bar +# +# class << self +# attr_reader :baz +# end +# @example ExactNameMatch: true (default) +# # good +# def name +# @other_name +# end +# @example ExactNameMatch: false +# # bad +# def name +# @other_name +# end +# @example AllowPredicates: true (default) +# # good +# def foo? +# @foo +# end +# @example AllowPredicates: false +# # bad +# def foo? +# @foo +# end +# +# # good +# attr_reader :foo +# @example AllowDSLWriters: true (default) +# # good +# def on_exception(action) +# @on_exception=action +# end +# @example AllowDSLWriters: false +# # bad +# def on_exception(action) +# @on_exception=action +# end +# +# # good +# attr_writer :on_exception +# @example IgnoreClassMethods: false (default) +# # bad +# def self.foo +# @foo +# end +# +# # good +# class << self +# attr_reader :foo +# end +# @example IgnoreClassMethods: true +# # good +# def self.foo +# @foo +# end +# @example AllowedMethods: ['allowed_method'] +# # good +# def allowed_method +# @foo +# end +# +# source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#98 +class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#190 + def looks_like_trivial_writer?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#104 + def on_def(node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#104 + def on_defs(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#222 + def accessor(kind, method_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#161 + def allow_dsl_writers?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#157 + def allow_predicates?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#195 + def allowed_method_name?(node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#169 + def allowed_method_names; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#204 + def allowed_reader?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#200 + def allowed_writer?(node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#142 + def autocorrect(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#234 + def autocorrect_class(corrector, node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#226 + def autocorrect_instance(corrector, node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#173 + def dsl_writer?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#153 + def exact_name_match?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#165 + def ignore_class_methods?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#115 + def in_module_or_instance_eval?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#181 + def looks_like_trivial_reader?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#208 + def names_match?(node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#129 + def on_method_def(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#248 + def top_level_node?(node); end + + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#214 + def trivial_accessor_kind(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#177 + def trivial_reader?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#185 + def trivial_writer?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#102 +RuboCop::Cop::Style::TrivialAccessors::MSG = T.let(T.unsafe(nil), String) + +# Looks for `unless` expressions with `else` clauses. +# +# @example +# # bad +# unless foo_bar.nil? +# # do something... +# else +# # do a different thing... +# end +# +# # good +# if foo_bar.present? +# # do something... +# else +# # do a different thing... +# end +# +# source://rubocop//lib/rubocop/cop/style/unless_else.rb#22 +class RuboCop::Cop::Style::UnlessElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/unless_else.rb#28 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/unless_else.rb#45 + def range_between_condition_and_else(node, condition); end + + # source://rubocop//lib/rubocop/cop/style/unless_else.rb#49 + def range_between_else_and_end(node); end +end + +# source://rubocop//lib/rubocop/cop/style/unless_else.rb#26 +RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of logical operators in an `unless` condition. +# It discourages such code, as the condition becomes more difficult +# to read and understand. +# +# This cop supports two styles: +# +# - `forbid_mixed_logical_operators` (default) +# - `forbid_logical_operators` +# +# `forbid_mixed_logical_operators` style forbids the use of more than one type +# of logical operators. This makes the `unless` condition easier to read +# because either all conditions need to be met or any condition need to be met +# in order for the expression to be truthy or falsey. +# +# `forbid_logical_operators` style forbids any use of logical operator. +# This makes it even more easy to read the `unless` condition as +# there is only one condition in the expression. +# +# @example EnforcedStyle: forbid_mixed_logical_operators (default) +# # bad +# return unless a || b && c +# return unless a && b || c +# return unless a && b and c +# return unless a || b or c +# return unless a && b or c +# return unless a || b and c +# +# # good +# return unless a && b && c +# return unless a || b || c +# return unless a and b and c +# return unless a or b or c +# return unless a? +# @example EnforcedStyle: forbid_logical_operators +# # bad +# return unless a || b +# return unless a && b +# return unless a or b +# return unless a and b +# +# # good +# return unless a +# return unless a? +# +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#50 +class RuboCop::Cop::Style::UnlessLogicalOperators < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#62 + def and_with_or?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#67 + def logical_operator?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#71 + def on_if(node); end + + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#57 + def or_with_and?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#83 + def mixed_logical_operator?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#90 + def mixed_precedence_and?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#97 + def mixed_precedence_or?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#54 +RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#53 +RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_MIXED_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) + +# Checks for accessing the first element of `String#unpack` +# which can be replaced with the shorter method `unpack1`. +# +# @example +# +# # bad +# 'foo'.unpack('h*').first +# 'foo'.unpack('h*')[0] +# 'foo'.unpack('h*').slice(0) +# 'foo'.unpack('h*').at(0) +# +# # good +# 'foo'.unpack1('h*') +# +# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#20 +class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#38 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#31 + def unpack_and_first_element?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#54 + def first_element_range(node, unpack_call); end +end + +# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#26 +RuboCop::Cop::Style::UnpackFirst::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#28 +RuboCop::Cop::Style::UnpackFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for variable interpolation (like "#@ivar"). +# +# @example +# # bad +# "His name is #$name" +# /check #$pattern/ +# "Let's go to the #@store" +# +# # good +# "His name is #{$name}" +# /check #{$pattern}/ +# "Let's go to the #{@store}" +# +# source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#18 +class RuboCop::Cop::Style::VariableInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#25 + def on_node_with_interpolations(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#35 + def message(range); end + + # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#39 + def var_nodes(nodes); end +end + +# source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#22 +RuboCop::Cop::Style::VariableInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for `when;` uses in `case` expressions. +# +# @example +# # bad +# case foo +# when 1; 'baz' +# when 2; 'bar' +# end +# +# # good +# case foo +# when 1 then 'baz' +# when 2 then 'bar' +# end +# +# source://rubocop//lib/rubocop/cop/style/when_then.rb#20 +class RuboCop::Cop::Style::WhenThen < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/when_then.rb#25 + def on_when(node); end +end + +# source://rubocop//lib/rubocop/cop/style/when_then.rb#23 +RuboCop::Cop::Style::WhenThen::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of `do` in multi-line `while/until` statements. +# +# @example +# +# # bad +# while x.any? do +# do_something(x.pop) +# end +# +# # good +# while x.any? +# do_something(x.pop) +# end +# @example +# +# # bad +# until x.empty? do +# do_something(x.pop) +# end +# +# # good +# until x.empty? +# do_something(x.pop) +# end +# +# source://rubocop//lib/rubocop/cop/style/while_until_do.rb#31 +class RuboCop::Cop::Style::WhileUntilDo < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/while_until_do.rb#36 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/while_until_do.rb#36 + def on_while(node); end +end + +# source://rubocop//lib/rubocop/cop/style/while_until_do.rb#34 +RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String) + +# Checks for while and until statements that would fit on one line +# if written as a modifier while/until. The maximum line length is +# configured in the `Layout/LineLength` cop. +# +# @example +# # bad +# while x < 10 +# x += 1 +# end +# +# # good +# x += 1 while x < 10 +# @example +# # bad +# until x > 10 +# x += 1 +# end +# +# # good +# x += 1 until x > 10 +# @example +# # bad +# x += 100 while x < 500 # a long comment that makes code too long if it were a single line +# +# # good +# while x < 500 # a long comment that makes code too long if it were a single line +# x += 100 +# end +# +# source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#36 +class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#42 + def on_until(node); end + + # source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#42 + def on_while(node); end +end + +# source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#40 +RuboCop::Cop::Style::WhileUntilModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for array literals made up of word-like +# strings, that are not using the %w() syntax. +# +# Alternatively, it can check for uses of the %w() syntax, in projects +# which do not want to include that syntax. +# +# NOTE: When using the `percent` style, %w() arrays containing a space +# will be registered as offenses. +# +# Configuration option: MinSize +# If set, arrays with fewer elements than this value will not trigger the +# cop. For example, a `MinSize` of `3` will not enforce a style on an +# array of 2 or fewer elements. +# +# @example EnforcedStyle: percent (default) +# # good +# %w[foo bar baz] +# +# # bad +# ['foo', 'bar', 'baz'] +# +# # bad (contains spaces) +# %w[foo\ bar baz\ quux] +# +# # bad +# [ +# ['one', 'One'], +# ['two', 'Two'] +# ] +# +# # good +# [ +# %w[one One], +# %w[two Two] +# ] +# +# # good (2d array containing spaces) +# [ +# ['one', 'One'], +# ['two', 'Two'], +# ['forty two', 'Forty Two'] +# ] +# @example EnforcedStyle: brackets +# # good +# ['foo', 'bar', 'baz'] +# +# # bad +# %w[foo bar baz] +# +# # good (contains spaces) +# ['foo bar', 'baz quux'] +# +# # good +# [ +# ['one', 'One'], +# ['two', 'Two'] +# ] +# +# # bad +# [ +# %w[one One], +# %w[two Two] +# ] +# +# source://rubocop//lib/rubocop/cop/style/word_array.rb#71 +class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/word_array.rb#94 + def on_array(node); end + + # source://rubocop//lib/rubocop/cop/style/word_array.rb#85 + def on_new_investigation; end + + private + + # source://rubocop//lib/rubocop/cop/style/word_array.rb#138 + def build_bracketed_array(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#118 + def complex_content?(strings, complex_regex: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#129 + def invalid_percent_array_contents?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#113 + def matrix_of_complex_content?(array); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#107 + def within_matrix_of_complex_content?(node); end + + # source://rubocop//lib/rubocop/cop/style/word_array.rb#134 + def word_regex; end + + class << self + # Returns the value of attribute largest_brackets. + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#82 + def largest_brackets; end + + # Sets the attribute largest_brackets + # + # @param value the value to set the attribute largest_brackets to. + # + # source://rubocop//lib/rubocop/cop/style/word_array.rb#82 + def largest_brackets=(_arg0); end + end +end + +# source://rubocop//lib/rubocop/cop/style/word_array.rb#79 +RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/word_array.rb#78 +RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with +# `File.read` argument. +# +# NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0. +# +# @example +# +# # bad +# YAML.load(File.read(path)) +# YAML.parse(File.read(path)) +# +# # good +# YAML.load_file(path) +# YAML.parse_file(path) +# +# # bad +# YAML.safe_load(File.read(path)) # Ruby 3.0 and newer +# +# # good +# YAML.safe_load_file(path) # Ruby 3.0 and newer +# +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#27 +class RuboCop::Cop::Style::YAMLFileRead < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#41 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#34 + def yaml_file_read?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#60 + def offense_range(node); end +end + +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#30 +RuboCop::Cop::Style::YAMLFileRead::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#31 +RuboCop::Cop::Style::YAMLFileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces or forbids Yoda conditions, +# i.e. comparison operations where the order of expression is reversed. +# eg. `5 == x` +# +# @example EnforcedStyle: forbid_for_all_comparison_operators (default) +# # bad +# 99 == foo +# "bar" != foo +# 42 >= foo +# 10 < bar +# 99 == CONST +# +# # good +# foo == 99 +# foo == "bar" +# foo <= 42 +# bar > 10 +# CONST == 99 +# "#{interpolation}" == foo +# /#{interpolation}/ == foo +# @example EnforcedStyle: forbid_for_equality_operators_only +# # bad +# 99 == foo +# "bar" != foo +# +# # good +# 99 >= foo +# 3 < a && a < 5 +# @example EnforcedStyle: require_for_all_comparison_operators +# # bad +# foo == 99 +# foo == "bar" +# foo <= 42 +# bar > 10 +# +# # good +# 99 == foo +# "bar" != foo +# 42 >= foo +# 10 < bar +# @example EnforcedStyle: require_for_equality_operators_only +# # bad +# 99 >= foo +# 3 < a && a < 5 +# +# # good +# 99 == foo +# "bar" != foo +# +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#77 +class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#90 + def file_constant_equal_program_name?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#94 + def on_send(node); end + + private + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#149 + def actual_code_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#145 + def constant_portion?(node); end + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#138 + def corrected_code(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#107 + def enforce_yoda?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#112 + def equality_only?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#173 + def interpolation?(node); end + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#134 + def message(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#157 + def non_equality_operator?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#161 + def noncommutative_operator?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#169 + def program_name?(name); end + + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#153 + def reverse_comparison(operator); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#165 + def source_file_path_constant?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#122 + def valid_yoda?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#117 + def yoda_compatible_condition?(node); end +end + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#84 +RuboCop::Cop::Style::YodaCondition::EQUALITY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#82 +RuboCop::Cop::Style::YodaCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#85 +RuboCop::Cop::Style::YodaCondition::NONCOMMUTATIVE_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#86 +RuboCop::Cop::Style::YodaCondition::PROGRAM_NAMES = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#87 +RuboCop::Cop::Style::YodaCondition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#83 +RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Hash) + +# Forbids Yoda expressions, i.e. binary operations (using `*`, `+`, `&`, `|`, +# and `^` operators) where the order of expression is reversed, eg. `1 + x`. +# This cop complements `Style/YodaCondition` cop, which has a similar purpose. +# +# This cop is disabled by default to respect user intentions such as: +# +# [source,ruby] +# ---- +# config.server_port = 9000 + ENV["TEST_ENV_NUMBER"].to_i +# ---- +# +# @example SupportedOperators: ['*', '+', '&', '|', '^'] (default) +# # bad +# 10 * y +# 1 + x +# 1 & z +# 1 | x +# 1 ^ x +# 1 + CONST +# +# # good +# y * 10 +# x + 1 +# z & 1 +# x | 1 +# x ^ 1 +# CONST + 1 +# 60 * 24 +# +# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#40 +class RuboCop::Cop::Style::YodaExpression < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#47 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#51 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#73 + def constant_portion?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#81 + def offended_ancestor?(node); end + + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#85 + def offended_nodes; end + + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#77 + def supported_operators; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#69 + def yoda_expression_constant?(lhs, rhs); end +end + +# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#43 +RuboCop::Cop::Style::YodaExpression::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#45 +RuboCop::Cop::Style::YodaExpression::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for numeric comparisons that can be replaced +# by a predicate method, such as `receiver.length == 0`, +# `receiver.length > 0`, and `receiver.length != 0`, +# `receiver.length < 1` and `receiver.size == 0` that can be +# replaced by `receiver.empty?` and `!receiver.empty?`. +# +# NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?` +# so allow `size == 0` and `size.zero?`. +# +# @example +# # bad +# [1, 2, 3].length == 0 +# 0 == "foobar".length +# array.length < 1 +# {a: 1, b: 2}.length != 0 +# string.length > 0 +# hash.size > 0 +# +# # good +# [1, 2, 3].empty? +# "foobar".empty? +# array.empty? +# !{a: 1, b: 2}.empty? +# !string.empty? +# !hash.empty? +# +# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#37 +class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # Some collection like objects in the Ruby standard library + # implement `#size`, but not `#empty`. We ignore those to + # reduce false positives. + # + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#139 + def non_polymorphic_collection?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#109 + def nonzero_length_comparison(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#45 + def on_send(node); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#130 + def other_receiver(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#101 + def zero_length_comparison(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#96 + def zero_length_predicate(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#122 + def zero_length_receiver(param0 = T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#80 + def check_nonzero_length_comparison(node); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#65 + def check_zero_length_comparison(node); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#53 + def check_zero_length_predicate(node); end + + # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#114 + def replacement(node); end +end + +# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#41 +RuboCop::Cop::Style::ZeroLengthPredicate::NONZERO_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#43 +RuboCop::Cop::Style::ZeroLengthPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#40 +RuboCop::Cop::Style::ZeroLengthPredicate::ZERO_MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking and correcting surrounding whitespace. +# +# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#6 +module RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#110 + def empty_brackets?(left_bracket_token, right_bracket_token, tokens: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#104 + def empty_offense(node, range, message, command); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#94 + def empty_offenses(node, left, right, message); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#68 + def extra_space?(token, side); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#129 + def no_character_between?(left_bracket_token, right_bracket_token); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#38 + def no_space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#120 + def offending_empty_no_space?(config, left_token, right_token); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#116 + def offending_empty_space?(config, left_token, right_token); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#33 + def on_new_investigation; end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#78 + def reposition(src, pos, step, include_newlines: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#16 + def side_space_range(range:, side:, include_newlines: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#124 + def space_between?(left_bracket_token, right_bracket_token); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#85 + def space_offense(node, token, side, message, command); end + + # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#53 + def space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end +end + +# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#9 +RuboCop::Cop::SurroundingSpace::NO_SPACE_COMMAND = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#12 +RuboCop::Cop::SurroundingSpace::SINGLE_SPACE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#10 +RuboCop::Cop::SurroundingSpace::SPACE_COMMAND = T.let(T.unsafe(nil), String) + +# Classes that include this module just implement functions for working +# with symbol nodes. +# +# source://rubocop//lib/rubocop/cop/mixin/symbol_help.rb#7 +module RuboCop::Cop::SymbolHelp + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/symbol_help.rb#8 + def hash_key?(node); end +end + +# Common functionality for checking target ruby version. +# +# source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#6 +module RuboCop::Cop::TargetRubyVersion + # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#11 + def minimum_target_ruby_version(version); end + + # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#7 + def required_minimum_ruby_version; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#15 + def support_target_ruby_version?(version); end +end + +# A group of cops, ready to be called on duty to inspect files. +# Team is responsible for selecting only relevant cops to be sent on duty, +# as well as insuring that the needed forces are sent along with them. +# +# For performance reasons, Team will first dispatch cops & forces in two groups, +# first the ones needed for autocorrection (if any), then the rest +# (unless autocorrections happened). +# +# source://rubocop//lib/rubocop/cop/team.rb#12 +class RuboCop::Cop::Team + # @return [Team] a new instance of Team + # + # source://rubocop//lib/rubocop/cop/team.rb#55 + def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/team.rb#66 + def autocorrect?; end + + # Returns the value of attribute cops. + # + # source://rubocop//lib/rubocop/cop/team.rb#51 + def cops; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/team.rb#70 + def debug?; end + + # Returns the value of attribute errors. + # + # source://rubocop//lib/rubocop/cop/team.rb#51 + def errors; end + + # source://rubocop//lib/rubocop/cop/team.rb#114 + def external_dependency_checksum; end + + # @deprecated + # + # source://rubocop//lib/rubocop/cop/team.rb#110 + def forces; end + + # source://rubocop//lib/rubocop/cop/team.rb#76 + def inspect_file(processed_source); end + + # @return [Commissioner::InvestigationReport] + # + # source://rubocop//lib/rubocop/cop/team.rb#81 + def investigate(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end + + # Returns the value of attribute updated_source_file. + # + # source://rubocop//lib/rubocop/cop/team.rb#51 + def updated_source_file; end + + # Returns the value of attribute updated_source_file. + # + # source://rubocop//lib/rubocop/cop/team.rb#51 + def updated_source_file?; end + + # Returns the value of attribute warnings. + # + # source://rubocop//lib/rubocop/cop/team.rb#51 + def warnings; end + + private + + # source://rubocop//lib/rubocop/cop/team.rb#121 + def autocorrect(processed_source, report, original:, offset:); end + + # source://rubocop//lib/rubocop/cop/team.rb#182 + def autocorrect_report(report, offset:, original:); end + + # source://rubocop//lib/rubocop/cop/team.rb#140 + def be_ready; end + + # source://rubocop//lib/rubocop/cop/team.rb#188 + def collate_corrections(report, offset:, original:); end + + # source://rubocop//lib/rubocop/cop/team.rb#204 + def each_corrector(report); end + + # source://rubocop//lib/rubocop/cop/team.rb#254 + def handle_error(error, location, cop); end + + # source://rubocop//lib/rubocop/cop/team.rb#246 + def handle_warning(error, location); end + + # @return [Commissioner::InvestigationReport] + # + # source://rubocop//lib/rubocop/cop/team.rb#154 + def investigate_partial(cops, processed_source, offset:, original:); end + + # source://rubocop//lib/rubocop/cop/team.rb#231 + def process_errors(file, errors); end + + # source://rubocop//lib/rubocop/cop/team.rb#148 + def reset; end + + # @return [Array] + # + # source://rubocop//lib/rubocop/cop/team.rb#160 + def roundup_relevant_cops(processed_source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/team.rb#176 + def support_target_rails_version?(cop); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/team.rb#170 + def support_target_ruby_version?(cop); end + + # source://rubocop//lib/rubocop/cop/team.rb#219 + def suppress_clobbering; end + + # source://rubocop//lib/rubocop/cop/team.rb#225 + def validate_config; end + + class << self + # @return [Array] needed for the given cops + # + # source://rubocop//lib/rubocop/cop/team.rb#37 + def forces_for(cops); end + + # @return [Team] with cops assembled from the given `cop_classes` + # + # source://rubocop//lib/rubocop/cop/team.rb#22 + def mobilize(cop_classes, config, options = T.unsafe(nil)); end + + # @return [Array] + # + # source://rubocop//lib/rubocop/cop/team.rb#28 + def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end + + # @return [Team] + # + # source://rubocop//lib/rubocop/cop/team.rb#14 + def new(cop_or_classes, config, options = T.unsafe(nil)); end + end +end + +# Common methods shared by TrailingBody cops +# +# source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#6 +module RuboCop::Cop::TrailingBody + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#12 + def body_on_first_line?(node, body); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#16 + def first_part_of(body); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#7 + def trailing_body?(node); end +end + +# Common methods shared by Style/TrailingCommaInArguments and +# Style/TrailingCommaInLiteral +# +# source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#7 +module RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + private + + # A single argument with the closing bracket on the same line as the end + # of the argument is not considered multiline, even if the argument + # itself might span multiple lines. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#104 + def allowed_multiline_argument?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#167 + def any_heredoc?(items); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#159 + def autocorrect_range(item); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#133 + def avoid_comma(kind, comma_begin_pos, extra_info); end + + # Returns true if the node has round/square/curly brackets. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#82 + def brackets?(node); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#19 + def check(node, items, kind, begin_pos, end_pos); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#37 + def check_comma(node, kind, comma_pos); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#43 + def check_literal(node, kind); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#30 + def comma_offset(items, range); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#108 + def elements(node); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#54 + def extra_avoid_comma_info; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#171 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#189 + def heredoc_send?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#76 + def inside_comment?(range, comma_offset); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#93 + def method_name_and_arguments_on_same_line?(node); end + + # Returns true if the round/square/curly brackets of the given node are + # on different lines, each item within is on its own line, and the + # closing bracket is on its own line. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#89 + def multiline?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#123 + def no_elements_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#129 + def on_same_line?(range1, range2); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#147 + def put_comma(items, kind); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#65 + def should_have_comma?(style, node); end + + # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#15 + def style_parameter_name; end +end + +# source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#11 +RuboCop::Cop::TrailingComma::MSG = T.let(T.unsafe(nil), String) + +# Common functionality shared by Uncommunicative cops +# +# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#6 +module RuboCop::Cop::UncommunicativeName + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#12 + def check(node, args); end + + private + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#95 + def allow_nums; end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#87 + def allowed_names; end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#78 + def arg_range(arg, length); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#45 + def case_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#64 + def ends_with_num?(name); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#91 + def forbidden_names; end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#83 + def forbidden_offense(node, range, name); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#36 + def issue_offenses(node, range, name); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#68 + def length_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#74 + def long_enough?(name); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#99 + def min_length; end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#53 + def name_type(node); end + + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#60 + def num_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#49 + def uppercase?(name); end +end + +# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#7 +RuboCop::Cop::UncommunicativeName::CASE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#10 +RuboCop::Cop::UncommunicativeName::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#9 +RuboCop::Cop::UncommunicativeName::LENGTH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#8 +RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String) + +# This autocorrects unused arguments. +# +# source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#6 +class RuboCop::Cop::UnusedArgCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#12 + def correct(corrector, processed_source, node); end + + # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#31 + def correct_for_blockarg_type(corrector, node); end + + # Returns the value of attribute processed_source. + # + # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#10 + def processed_source; end + end +end + +# This module contains a collection of useful utility methods. +# +# source://rubocop//lib/rubocop/cop/util.rb#7 +module RuboCop::Cop::Util + include ::RuboCop::PathUtil + + private + + # source://rubocop//lib/rubocop/cop/util.rb#35 + def add_parentheses(node, corrector); end + + # source://rubocop//lib/rubocop/cop/util.rb#56 + def any_descendant?(node, *types); end + + # source://rubocop//lib/rubocop/cop/util.rb#71 + def args_begin(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#83 + def args_end(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#104 + def begins_its_line?(range); end + + # This is a bad API + # + # source://rubocop//lib/rubocop/cop/util.rb#17 + def comment_line?(line_source); end + + # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar + # + # source://rubocop//lib/rubocop/cop/util.rb#22 + def comment_lines?(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#192 + def compatible_external_encoding_for?(src); end + + # If converting a string to Ruby string literal source code, must + # double quotes be used? + # + # source://rubocop//lib/rubocop/cop/util.rb#130 + def double_quotes_required?(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#144 + def escape_string(string); end + + # Returns, for example, a bare `if` node if the given node is an `if` + # with calls chained to the end of it. + # + # source://rubocop//lib/rubocop/cop/util.rb#114 + def first_part_of_call_chain(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#197 + def include_or_equal?(source, target); end + + # source://rubocop//lib/rubocop/cop/util.rb#179 + def indent(node, offset: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/util.rb#161 + def interpret_string_escapes(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#165 + def line(node_or_range); end + + # source://rubocop//lib/rubocop/cop/util.rb#26 + def line_range(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#140 + def needs_escaping?(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#87 + def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end + + # source://rubocop//lib/rubocop/cop/util.rb#30 + def parentheses?(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#173 + def same_line?(node1, node2); end + + # source://rubocop//lib/rubocop/cop/util.rb#148 + def to_string_literal(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#185 + def to_supported_styles(enforced_style); end + + # source://rubocop//lib/rubocop/cop/util.rb#157 + def trim_string_interpolation_escape_character(str); end + + class << self + # source://rubocop//lib/rubocop/cop/util.rb#35 + def add_parentheses(node, corrector); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#56 + def any_descendant?(node, *types); end + + # source://rubocop//lib/rubocop/cop/util.rb#71 + def args_begin(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#83 + def args_end(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#104 + def begins_its_line?(range); end + + # This is a bad API + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#17 + def comment_line?(line_source); end + + # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#22 + def comment_lines?(node); end + + # If converting a string to Ruby string literal source code, must + # double quotes be used? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#130 + def double_quotes_required?(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#144 + def escape_string(string); end + + # Returns, for example, a bare `if` node if the given node is an `if` + # with calls chained to the end of it. + # + # source://rubocop//lib/rubocop/cop/util.rb#114 + def first_part_of_call_chain(node); end + + # source://rubocop//lib/rubocop/cop/util.rb#179 + def indent(node, offset: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/util.rb#161 + def interpret_string_escapes(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#165 + def line(node_or_range); end + + # source://rubocop//lib/rubocop/cop/util.rb#26 + def line_range(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#140 + def needs_escaping?(string); end + + # @yield [sexp] + # + # source://rubocop//lib/rubocop/cop/util.rb#87 + def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#30 + def parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/util.rb#173 + def same_line?(node1, node2); end + + # source://rubocop//lib/rubocop/cop/util.rb#148 + def to_string_literal(string); end + + # source://rubocop//lib/rubocop/cop/util.rb#185 + def to_supported_styles(enforced_style); end + + # source://rubocop//lib/rubocop/cop/util.rb#157 + def trim_string_interpolation_escape_character(str); end + end +end + +# source://rubocop//lib/rubocop/cop/util.rb#99 +RuboCop::Cop::Util::LINE_BEGINS_REGEX_CACHE = T.let(T.unsafe(nil), Hash) + +# Match literal regex characters, not including anchors, character +# classes, alternatives, groups, repetitions, references, etc +# +# source://rubocop//lib/rubocop/cop/util.rb#12 +RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# Arbitrarily chosen value, should be enough to cover +# the most nested source code in real world projects. +# +# source://rubocop//lib/rubocop/cop/util.rb#98 +RuboCop::Cop::Util::MAX_LINE_BEGINS_REGEX_INDEX = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#5 +module RuboCop::Cop::Utils; end + +# Parses {Kernel#sprintf} format strings. +# +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#7 +class RuboCop::Cop::Utils::FormatString + # @return [FormatString] a new instance of FormatString + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#89 + def initialize(string); end + + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#93 + def format_sequences; end + + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#105 + def max_digit_dollar_num; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#101 + def named_interpolation?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#97 + def valid?; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#117 + def mixed_formats?; end + + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#111 + def parse; end +end + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#8 +RuboCop::Cop::Utils::FormatString::DIGIT_DOLLAR = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#9 +RuboCop::Cop::Utils::FormatString::FLAG = T.let(T.unsafe(nil), Regexp) + +# The syntax of a format sequence is as follows. +# +# ``` +# %[flags][width][.precision]type +# ``` +# +# A format sequence consists of a percent sign, followed by optional +# flags, width, and precision indicators, then terminated with a field +# type character. +# +# For more complex formatting, Ruby supports a reference by name. +# +# @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format +# +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#43 +class RuboCop::Cop::Utils::FormatString::FormatSequence + # @return [FormatSequence] a new instance of FormatSequence + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#46 + def initialize(match); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#61 + def annotated?; end + + # Number of arguments required for the format sequence + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#70 + def arity; end + + # Returns the value of attribute begin_pos. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def begin_pos; end + + # Returns the value of attribute end_pos. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def end_pos; end + + # Returns the value of attribute flags. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def flags; end + + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#74 + def max_digit_dollar_num; end + + # Returns the value of attribute name. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def name; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#57 + def percent?; end + + # Returns the value of attribute precision. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def precision; end + + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#78 + def style; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#65 + def template?; end + + # Returns the value of attribute type. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def type; end + + # Returns the value of attribute width. + # + # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44 + def width; end +end + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#15 +RuboCop::Cop::Utils::FormatString::NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#11 +RuboCop::Cop::Utils::FormatString::NUMBER = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#10 +RuboCop::Cop::Utils::FormatString::NUMBER_ARG = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#13 +RuboCop::Cop::Utils::FormatString::PRECISION = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#18 +RuboCop::Cop::Utils::FormatString::SEQUENCE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#16 +RuboCop::Cop::Utils::FormatString::TEMPLATE_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#14 +RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/cop/utils/format_string.rb#12 +RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp) + +# Helper to abstract complexity of building range pairs +# with octal escape reconstruction (needed for regexp_parser < 2.7). +# +# source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#8 +class RuboCop::Cop::Utils::RegexpRanges + # @return [RegexpRanges] a new instance of RegexpRanges + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#11 + def initialize(root); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#18 + def compound_token; end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#24 + def pairs; end + + # Returns the value of attribute root. + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#9 + def root; end + + private + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#78 + def compose_range(expressions, current); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#90 + def escaped_octal?(expr); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#94 + def octal_digit?(char); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#98 + def pop_octal_digits(expressions); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#44 + def populate(expr); end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#32 + def populate_all; end + + # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#63 + def process_set(expressions, current); end +end + +# This force provides a way to track local variables and scopes of Ruby. +# Cops interact with this force need to override some of the hook methods. +# +# def before_entering_scope(scope, variable_table) +# end +# +# def after_entering_scope(scope, variable_table) +# end +# +# def before_leaving_scope(scope, variable_table) +# end +# +# def after_leaving_scope(scope, variable_table) +# end +# +# def before_declaring_variable(variable, variable_table) +# end +# +# def after_declaring_variable(variable, variable_table) +# end +# +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#27 +class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force + # Starting point. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#76 + def investigate(processed_source); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#85 + def process_node(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#71 + def variable_table; end + + private + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def after_declaring_variable(arg); end + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def after_entering_scope(arg); end + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def after_leaving_scope(arg); end + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def before_declaring_variable(arg); end + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def before_entering_scope(arg); end + + # source://rubocop//lib/rubocop/cop/variable_force.rb#368 + def before_leaving_scope(arg); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#339 + def descendant_reference(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#329 + def each_descendant_reference(loop_node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#314 + def find_variables_in_loop(loop_node); end + + # This is called for each scope recursively. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#94 + def inspect_variables_in_scope(scope_node); end + + # Mark all assignments which are referenced in the same loop + # as referenced by ignoring AST order since they would be referenced + # in next iteration. + # + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#295 + def mark_assignments_as_referenced_in_loop(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#126 + def node_handler_method_name(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#100 + def process_children(origin_node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#231 + def process_loop(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#160 + def process_regexp_named_captures(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#246 + def process_rescue(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#265 + def process_scope(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#284 + def process_send(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#142 + def process_variable_assignment(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#130 + def process_variable_declaration(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#219 + def process_variable_multiple_assignment(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#184 + def process_variable_operator_assignment(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#226 + def process_variable_referencing(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#257 + def process_zero_arity_super(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#178 + def regexp_captured_names(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#351 + def scanned_node?(node); end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#355 + def scanned_nodes; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#108 + def skip_children!; end + + # @api private + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#278 + def twisted_nodes(node); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#32 +RuboCop::Cop::VariableForce::ARGUMENT_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +# This class represents each assignment of a variable. +# +# source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#7 +class RuboCop::Cop::VariableForce::Assignment + include ::RuboCop::Cop::VariableForce::Branchable + + # @return [Assignment] a new instance of Assignment + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#16 + def initialize(node, variable); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#50 + def exception_assignment?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#72 + def for_assignment?; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#83 + def meta_assignment_node; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#60 + def multiple_assignment?; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#29 + def name; end + + # Returns the value of attribute node. + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 + def node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#78 + def operator; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#54 + def operator_assignment?; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#37 + def reference!(node); end + + # Returns the value of attribute referenced. + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 + def referenced; end + + # Returns the value of attribute referenced. + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 + def referenced?; end + + # Returns the value of attribute references. + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 + def references; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#46 + def regexp_named_capture?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#66 + def rest_assignment?; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#33 + def scope; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#42 + def used?; end + + # Returns the value of attribute variable. + # + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12 + def variable; end + + private + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#125 + def find_multiple_assignment_node(grandparent_node); end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#121 + def for_assignment_node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#104 + def multiple_assignment_node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#96 + def operator_assignment_node; end + + # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#114 + def rest_assignment_node; end +end + +# source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#10 +RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#65 +class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#66 + def assignment?; end + + # Returns the value of attribute node + # + # @return [Object] the current value of node + def node; end + + # Sets the attribute node + # + # @param value [Object] the value to set the attribute node to. + # @return [Object] the newly set value + def node=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# Namespace for branch classes for each control structure. +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#7 +module RuboCop::Cop::VariableForce::Branch + class << self + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#8 + def of(target_node, scope: T.unsafe(nil)); end + end +end + +# left_body && right_body +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#265 +class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def left_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def right_body?; end +end + +# Abstract base class for branch classes. +# A branch represents a conditional branch in a scope. +# +# @example +# def some_scope +# do_something # no branch +# +# if foo +# do_something # branch A +# do_something # branch A +# else +# do_something # branch B +# if bar +# do_something # branch C (whose parent is branch B) +# end +# end +# +# do_something # no branch +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#42 +class RuboCop::Cop::VariableForce::Branch::Base < ::Struct + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#121 + def ==(other); end + + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#92 + def always_run?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#88 + def branched?; end + + # Returns the value of attribute child_node + # + # @return [Object] the current value of child_node + def child_node; end + + # Sets the attribute child_node + # + # @param value [Object] the value to set the attribute child_node to. + # @return [Object] the newly set value + def child_node=(_); end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#70 + def control_node; end + + # @yield [_self] + # @yieldparam _self [RuboCop::Cop::VariableForce::Branch::Base] the object that the method was called on + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#80 + def each_ancestor(include_self: T.unsafe(nil), &block); end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#121 + def eql?(other); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#104 + def exclusive_with?(other); end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#129 + def hash; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#96 + def may_jump_to_other_branch?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#100 + def may_run_incompletely?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#74 + def parent; end + + # Returns the value of attribute scope + # + # @return [Object] the current value of scope + def scope; end + + # Sets the attribute scope + # + # @param value [Object] the value to set the attribute scope to. + # @return [Object] the newly set value + def scope=(_); end + + private + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#135 + def scan_ancestors; end + + class << self + def [](*_arg0); end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#43 + def classes; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#56 + def define_predicate(name, child_index: T.unsafe(nil)); end + + # @private + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#47 + def inherited(subclass); end + + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#52 + def type; end + end +end + +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#325 +RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash) + +# case target +# when /pattern/ # when_clause +# else +# else_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#219 +class RuboCop::Cop::VariableForce::Branch::Case < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#224 + def always_run?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def else_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def target?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def when_clause?; end +end + +# case target +# in pattern # in_pattern +# else +# else_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#234 +class RuboCop::Cop::VariableForce::Branch::CaseMatch < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#239 + def always_run?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def else_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def in_pattern?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def target?; end +end + +# begin +# main_body +# ensure +# ensure_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#314 +class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#320 + def always_run?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def ensure_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def main_body?; end +end + +# Mix-in module for exception handling control structures. +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#281 +module RuboCop::Cop::VariableForce::Branch::ExceptionHandler + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#282 + def may_jump_to_other_branch?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#286 + def may_run_incompletely?; end +end + +# for element in collection +# loop_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#247 +class RuboCop::Cop::VariableForce::Branch::For < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#252 + def always_run?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def collection?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def element?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def loop_body?; end +end + +# if conditional_clause +# truthy_body +# else +# falsey_body +# end +# +# unless conditional_clause +# falsey_body +# else +# truthy_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#166 +class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def conditional_clause?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def falsey_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def truthy_body?; end +end + +# Mix-in module for logical operator control structures. +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#258 +module RuboCop::Cop::VariableForce::Branch::LogicalOperator + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#259 + def always_run?; end +end + +# left_body || right_body +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#273 +class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def left_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def right_body?; end +end + +# begin +# main_body +# rescue StandardError => error # rescue_clause +# else +# else_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#297 +class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#304 + def always_run?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def else_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def main_body?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def rescue_clause?; end +end + +# Mix-in module for simple conditional control structures. +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#145 +module RuboCop::Cop::VariableForce::Branch::SimpleConditional + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#150 + def always_run?; end + + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#146 + def conditional_clause?; end +end + +# until conditional_clause +# loop_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#187 +class RuboCop::Cop::VariableForce::Branch::Until < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def conditional_clause?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def loop_body?; end +end + +# begin +# loop_body +# end until conditional_clause +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#207 +class RuboCop::Cop::VariableForce::Branch::UntilPost < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def conditional_clause?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def loop_body?; end +end + +# while conditional_clause +# loop_body +# end +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#177 +class RuboCop::Cop::VariableForce::Branch::While < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def conditional_clause?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def loop_body?; end +end + +# begin +# loop_body +# end while conditional_clause +# +# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#197 +class RuboCop::Cop::VariableForce::Branch::WhilePost < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def conditional_clause?; end + + # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57 + def loop_body?; end +end + +# Mix-in module for classes which own a node and need branch information +# of the node. The user classes must implement #node and #scope. +# +# source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#8 +module RuboCop::Cop::VariableForce::Branchable + # source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#9 + def branch; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#15 + def run_exclusively_with?(other); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#39 +RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#48 +RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#42 +RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#112 +RuboCop::Cop::VariableForce::NODE_HANDLER_METHOD_NAMES = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#40 +RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#47 +RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#29 +RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#50 +RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#43 +RuboCop::Cop::VariableForce::REST_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +# This class represents each reference of a variable. +# +# source://rubocop//lib/rubocop/cop/variable_force/reference.rb#7 +class RuboCop::Cop::VariableForce::Reference + include ::RuboCop::Cop::VariableForce::Branchable + + # @return [Reference] a new instance of Reference + # + # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#16 + def initialize(node, scope); end + + # There's an implicit variable reference by the zero-arity `super`: + # + # def some_method(foo) + # super + # end + # + # Another case is `binding`: + # + # def some_method(foo) + # do_something(binding) + # end + # + # In these cases, the variable `foo` is not explicitly referenced, + # but it can be considered used implicitly by the `super` or `binding`. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#41 + def explicit?; end + + # Returns the value of attribute node. + # + # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#14 + def node; end + + # Returns the value of attribute scope. + # + # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#14 + def scope; end +end + +# source://rubocop//lib/rubocop/cop/variable_force/reference.rb#10 +RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#55 +RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#57 +RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol) + +# A Scope represents a context of local variable visibility. +# This is a place where local variables belong to. +# A scope instance holds a scope node and variable entries. +# +# source://rubocop//lib/rubocop/cop/variable_force/scope.rb#9 +class RuboCop::Cop::VariableForce::Scope + # @return [Scope] a new instance of Scope + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#22 + def initialize(node); end + + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#35 + def ==(other); end + + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#43 + def body_node; end + + # @yield [node] + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#61 + def each_node(&block); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#57 + def include?(target_node); end + + # Returns the value of attribute naked_top_level. + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18 + def naked_top_level; end + + # Returns the value of attribute naked_top_level. + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18 + def naked_top_level?; end + + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#39 + def name; end + + # Returns the value of attribute node. + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18 + def node; end + + # Returns the value of attribute variables. + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18 + def variables; end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#100 + def ancestor_node?(target_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#90 + def belong_to_inner_scope?(target_node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#79 + def belong_to_outer_scope?(target_node); end + + # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#70 + def scan_node(node, &block); end +end + +# source://rubocop//lib/rubocop/cop/variable_force/scope.rb#10 +RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#54 +RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#28 +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#30 +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#45 +RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol) + +# A Variable represents existence of a local variable. +# This holds a variable declaration node and some states of the variable. +# +# source://rubocop//lib/rubocop/cop/variable_force/variable.rb#8 +class RuboCop::Cop::VariableForce::Variable + # @return [Variable] a new instance of Variable + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#15 + def initialize(name, declaration_node, scope); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#94 + def argument?; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#31 + def assign(node); end + + # Returns the value of attribute assignments. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def assignments; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#102 + def block_argument?; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#74 + def capture_with_block!; end + + # Returns the value of attribute captured_by_block. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def captured_by_block; end + + # Returns the value of attribute captured_by_block. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def captured_by_block?; end + + # Returns the value of attribute declaration_node. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def declaration_node; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#110 + def explicit_block_local_variable?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#66 + def in_modifier_conditional?(assignment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#106 + def keyword_argument?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#98 + def method_argument?; end + + # Returns the value of attribute name. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def name; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#40 + def reference!(node); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#35 + def referenced?; end + + # Returns the value of attribute references. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def references; end + + # Returns the value of attribute scope. + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11 + def scope; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#90 + def should_be_unused?; end + + # This is a convenient way to check whether the variable is used + # in its entire variable lifetime. + # For more precise usage check, refer Assignment#used?. + # + # Once the variable is captured by a block, we have no idea + # when, where, and how many times the block would be invoked. + # This means we cannot track the usage of the variable. + # So we consider it's used to suppress false positive offenses. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#86 + def used?; end +end + +# source://rubocop//lib/rubocop/cop/variable_force/variable.rb#9 +RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#59 +class RuboCop::Cop::VariableForce::VariableReference < ::Struct + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force.rb#60 + def assignment?; end + + # Returns the value of attribute name + # + # @return [Object] the current value of name + def name; end + + # Sets the attribute name + # + # @param value [Object] the value to set the attribute name to. + # @return [Object] the newly set value + def name=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# A VariableTable manages the lifetime of all scopes and local variables +# in a program. +# This holds scopes as stack structure, provides a way to add local +# variables to current scope, and find local variables by considering +# variable visibility of the current scope. +# +# source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#11 +class RuboCop::Cop::VariableForce::VariableTable + # @return [VariableTable] a new instance of VariableTable + # + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#12 + def initialize(hook_receiver = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#113 + def accessible_variables; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#56 + def assign_to_variable(name, node); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#40 + def current_scope; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#44 + def current_scope_level; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#48 + def declare_variable(name, node); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#94 + def find_variable(name); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#16 + def invoke_hook(hook_name, *args); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#32 + def pop_scope; end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#24 + def push_scope(scope_node); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#68 + def reference_variable(name, node); end + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#20 + def scope_stack; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#109 + def variable_exist?(name); end + + private + + # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#122 + def mark_variable_as_captured_by_block_if_so(variable); end +end + +# @api private +# +# source://rubocop//lib/rubocop/cop/variable_force.rb#52 +RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol) + +# Help methods for determining node visibility. +# +# source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#8 +module RuboCop::Cop::VisibilityHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#57 + def visibility_block?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#62 + def visibility_inline_on_def?(param0 = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#67 + def visibility_inline_on_method_name?(param0 = T.unsafe(nil), method_name:); end + + private + + # Navigate to find the last protected method + # + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#48 + def find_visibility_end(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#43 + def find_visibility_start(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#15 + def node_visibility(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#39 + def node_visibility_from_visibility_block(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#21 + def node_visibility_from_visibility_inline(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#28 + def node_visibility_from_visibility_inline_on_def(node); end + + # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#33 + def node_visibility_from_visibility_inline_on_method_name(node); end +end + +# source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#11 +RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Set) + +# This class wraps the `Parser::Source::Comment` object that represents a +# cops it contains. +# +# source://rubocop//lib/rubocop/directive_comment.rb#7 +class RuboCop::DirectiveComment + # @return [DirectiveComment] a new instance of DirectiveComment + # + # source://rubocop//lib/rubocop/directive_comment.rb#30 + def initialize(comment, cop_registry = T.unsafe(nil)); end + + # Checks if all cops specified in this directive + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#80 + def all_cops?; end + + # Returns the value of attribute comment. + # + # source://rubocop//lib/rubocop/directive_comment.rb#28 + def comment; end + + # Returns array of specified in this directive cop names + # + # source://rubocop//lib/rubocop/directive_comment.rb#85 + def cop_names; end + + # Returns the value of attribute cop_registry. + # + # source://rubocop//lib/rubocop/directive_comment.rb#28 + def cop_registry; end + + # Returns the value of attribute cops. + # + # source://rubocop//lib/rubocop/directive_comment.rb#28 + def cops; end + + # Returns array of specified in this directive department names + # when all department disabled + # + # source://rubocop//lib/rubocop/directive_comment.rb#91 + def department_names; end + + # source://rubocop//lib/rubocop/directive_comment.rb#105 + def directive_count; end + + # Checks if this directive disables cops + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#60 + def disabled?; end + + # Checks if this directive disables all cops + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#75 + def disabled_all?; end + + # Checks if this directive enables cops + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#65 + def enabled?; end + + # Checks if this directive enables all cops + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#70 + def enabled_all?; end + + # Checks if directive departments include cop + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#96 + def in_directive_department?(cop); end + + # Returns line number for directive + # + # source://rubocop//lib/rubocop/directive_comment.rb#110 + def line_number; end + + # Checks if this directive contains all the given cop names + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#42 + def match?(cop_names); end + + # Returns match captures to directive comment pattern + # + # source://rubocop//lib/rubocop/directive_comment.rb#55 + def match_captures; end + + # Returns the value of attribute mode. + # + # source://rubocop//lib/rubocop/directive_comment.rb#28 + def mode; end + + # Checks if cop department has already used in directive comment + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#101 + def overridden_by_department?(cop); end + + # source://rubocop//lib/rubocop/directive_comment.rb#46 + def range; end + + # Checks if this directive relates to single line + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#37 + def single_line?; end + + private + + # source://rubocop//lib/rubocop/directive_comment.rb#130 + def all_cop_names; end + + # source://rubocop//lib/rubocop/directive_comment.rb#134 + def cop_names_for_department(department); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/directive_comment.rb#126 + def department?(name); end + + # source://rubocop//lib/rubocop/directive_comment.rb#140 + def exclude_redundant_directive_cop(cops); end + + # source://rubocop//lib/rubocop/directive_comment.rb#120 + def parsed_cop_names; end + + # source://rubocop//lib/rubocop/directive_comment.rb#116 + def splitted_cops_string; end + + class << self + # source://rubocop//lib/rubocop/directive_comment.rb#24 + def before_comment(line); end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#17 +RuboCop::DirectiveComment::COPS_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#15 +RuboCop::DirectiveComment::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#13 +RuboCop::DirectiveComment::COP_NAME_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#19 +RuboCop::DirectiveComment::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#11 +RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/directive_comment.rb#9 +RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP_DEPARTMENT = T.let(T.unsafe(nil), String) + +# An Error exception is different from an Offense with severity 'error' +# When this exception is raised, it means that RuboCop is unable to perform +# a requested action (probably due to misconfiguration) and must stop +# immediately, rather than carrying on +# +# source://rubocop//lib/rubocop/error.rb#8 +class RuboCop::Error < ::StandardError; end + +# A wrapper to display errored location of analyzed file. +# +# source://rubocop//lib/rubocop/error.rb#13 +class RuboCop::ErrorWithAnalyzedFileLocation < ::RuboCop::Error + # @return [ErrorWithAnalyzedFileLocation] a new instance of ErrorWithAnalyzedFileLocation + # + # source://rubocop//lib/rubocop/error.rb#14 + def initialize(cause:, node:, cop:); end + + # Returns the value of attribute cause. + # + # source://rubocop//lib/rubocop/error.rb#21 + def cause; end + + # source://rubocop//lib/rubocop/error.rb#27 + def column; end + + # Returns the value of attribute cop. + # + # source://rubocop//lib/rubocop/error.rb#21 + def cop; end + + # source://rubocop//lib/rubocop/error.rb#23 + def line; end + + # source://rubocop//lib/rubocop/error.rb#31 + def message; end +end + +# Allows specified configuration options to have an exclude limit +# ie. a maximum value tracked that it can be used by `--auto-gen-config`. +# +# source://rubocop//lib/rubocop/cop/exclude_limit.rb#6 +module RuboCop::ExcludeLimit + # Sets up a configuration option to have an exclude limit tracked. + # The parameter name given is transformed into a method name (eg. `Max` + # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`). + # + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#10 + def exclude_limit(parameter_name, method_name: T.unsafe(nil)); end + + private + + # source://rubocop//lib/rubocop/cop/exclude_limit.rb#22 + def transform(parameter_name); end +end + +# source://rubocop//lib/rubocop/ext/comment.rb#4 +module RuboCop::Ext; end + +# Extensions to `Parser::Source::Comment`. +# +# source://rubocop//lib/rubocop/ext/comment.rb#6 +module RuboCop::Ext::Comment + # source://rubocop//lib/rubocop/ext/comment.rb#7 + def source; end + + # source://rubocop//lib/rubocop/ext/comment.rb#11 + def source_range; end +end + +# Extensions to AST::ProcessedSource for our cached comment_config +# +# source://rubocop//lib/rubocop/ext/processed_source.rb#6 +module RuboCop::Ext::ProcessedSource + # source://rubocop//lib/rubocop/ext/processed_source.rb#9 + def comment_config; end + + # Returns the value of attribute config. + # + # source://rubocop//lib/rubocop/ext/processed_source.rb#7 + def config; end + + # Sets the attribute config + # + # @param value the value to set the attribute config to. + # + # source://rubocop//lib/rubocop/ext/processed_source.rb#7 + def config=(_arg0); end + + # source://rubocop//lib/rubocop/ext/processed_source.rb#13 + def disabled_line_ranges; end + + # Returns the value of attribute registry. + # + # source://rubocop//lib/rubocop/ext/processed_source.rb#7 + def registry; end + + # Sets the attribute registry + # + # @param value the value to set the attribute registry to. + # + # source://rubocop//lib/rubocop/ext/processed_source.rb#7 + def registry=(_arg0); end +end + +# Extensions to Parser::Source::Range +# +# source://rubocop//lib/rubocop/ext/range.rb#6 +module RuboCop::Ext::Range + # Adds `Range#single_line?` to parallel `Node#single_line?` + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/ext/range.rb#8 + def single_line?; end +end + +# Extensions to AST::RegexpNode for our cached parsed regexp info +# +# source://rubocop//lib/rubocop/ext/regexp_node.rb#6 +module RuboCop::Ext::RegexpNode + # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. + # It's for compatibility with regexp_parser 1.8 and will never be maintained. + # + # source://rubocop//lib/rubocop/ext/regexp_node.rb#19 + def assign_properties(*_arg0); end + + # source://rubocop//lib/rubocop/ext/regexp_node.rb#53 + def each_capture(named: T.unsafe(nil)); end + + # Note: we extend Regexp nodes to provide `loc` and `expression` + # see `ext/regexp_parser`. + # + # @return [Regexp::Expression::Root, nil] + # + # source://rubocop//lib/rubocop/ext/regexp_node.rb#16 + def parsed_tree; end + + private + + # source://rubocop//lib/rubocop/ext/regexp_node.rb#68 + def with_interpolations_blanked; end +end + +# source://rubocop//lib/rubocop/ext/regexp_node.rb#7 +RuboCop::Ext::RegexpNode::ANY = T.let(T.unsafe(nil), Object) + +# Extensions for `regexp_parser` gem +# +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#6 +module RuboCop::Ext::RegexpParser; end + +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#20 +module RuboCop::Ext::RegexpParser::Expression; end + +# Add `expression` and `loc` to all `regexp_parser` nodes +# +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#22 +module RuboCop::Ext::RegexpParser::Expression::Base + # Shortcut to `loc.expression` + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#27 + def expression; end + + # E.g. + # [a-z]{2,} + # ^^^^^^^^^ expression + # ^^^^ quantifier + # ^^^^^ body + # ^ begin + # ^ end + # + # Please open issue if you need other locations + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#61 + def loc; end + + # Returns the value of attribute origin. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#23 + def origin; end + + # Sets the attribute origin + # + # @param value the value to set the attribute origin to. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#23 + def origin=(_arg0); end + + private + + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#67 + def build_location; end +end + +# Provide `CharacterSet` with `begin` and `end` locations. +# +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#79 +module RuboCop::Ext::RegexpParser::Expression::CharacterSet + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#80 + def build_location; end +end + +# Source map for RegexpParser nodes +# +# source://rubocop//lib/rubocop/ext/regexp_parser.rb#8 +class RuboCop::Ext::RegexpParser::Map < ::Parser::Source::Map + # @return [Map] a new instance of Map + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#11 + def initialize(expression, body:, quantifier: T.unsafe(nil), begin_l: T.unsafe(nil), end_l: T.unsafe(nil)); end + + # Returns the value of attribute begin. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9 + def begin; end + + # Returns the value of attribute body. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9 + def body; end + + # Returns the value of attribute end. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9 + def end; end + + # Returns the value of attribute quantifier. + # + # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9 + def quantifier; end +end + +# This class handles loading files (a.k.a. features in Ruby) specified +# by `--require` command line option and `require` directive in the config. +# +# Normally, the given string is directly passed to `require`. If a string +# beginning with `.` is given, it is assumed to be relative to the given +# directory. +# +# If a string containing `-` is given, it will be used as is, but if we +# cannot find the file to load, we will replace `-` with `/` and try it +# again as when Bundler loads gems. +# +# @api private +# +# source://rubocop//lib/rubocop/feature_loader.rb#16 +class RuboCop::FeatureLoader + # @api private + # @param config_directory_path [String] + # @param feature [String] + # @return [FeatureLoader] a new instance of FeatureLoader + # + # source://rubocop//lib/rubocop/feature_loader.rb#27 + def initialize(config_directory_path:, feature:); end + + # @api private + # + # source://rubocop//lib/rubocop/feature_loader.rb#32 + def load; end + + private + + # @api private + # @return [String] + # + # source://rubocop//lib/rubocop/feature_loader.rb#55 + def namespaced_feature; end + + # @api private + # @return [String] + # + # source://rubocop//lib/rubocop/feature_loader.rb#60 + def namespaced_target; end + + # @api private + # @param [String] + # @return [String] + # + # source://rubocop//lib/rubocop/feature_loader.rb#70 + def relative(feature); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/feature_loader.rb#75 + def relative?; end + + # @api private + # @param error [LoadError] + # @return [Boolean] + # + # source://rubocop//lib/rubocop/feature_loader.rb#81 + def seems_cannot_load_such_file_error?(error); end + + # @api private + # @return [String] + # + # source://rubocop//lib/rubocop/feature_loader.rb#86 + def target; end + + class << self + # @api private + # @param config_directory_path [String] + # @param feature [String] + # + # source://rubocop//lib/rubocop/feature_loader.rb#20 + def load(config_directory_path:, feature:); end + end +end + +# Common methods for finding files. +# +# @api private +# +# source://rubocop//lib/rubocop/file_finder.rb#8 +module RuboCop::FileFinder + # @api private + # + # source://rubocop//lib/rubocop/file_finder.rb#13 + def find_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/file_finder.rb#20 + def find_last_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/file_finder.rb#28 + def traverse_files_upwards(filename, start_dir, stop_dir); end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/file_finder.rb#10 + def root_level; end + + # @api private + # + # source://rubocop//lib/rubocop/file_finder.rb#10 + def root_level=(_arg0); end + end +end + +# A wrapper around patterns array to perform optimized search. +# +# For projects with a large set of rubocop todo files, most items in `Exclude`/`Include` +# are exact file names. It is wasteful to linearly check the list of patterns over and over +# to check if the file is relevant to the cop. +# +# This class partitions an array of patterns into a set of exact match strings and the rest +# of the patterns. This way we can firstly do a cheap check in the set and then proceed via +# the costly patterns check, if needed. +# +# @api private +# +# source://rubocop//lib/rubocop/file_patterns.rb#14 +class RuboCop::FilePatterns + # @api private + # @return [FilePatterns] a new instance of FilePatterns + # + # source://rubocop//lib/rubocop/file_patterns.rb#21 + def initialize(patterns); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/file_patterns.rb#27 + def match?(path); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/file_patterns.rb#33 + def partition_patterns(patterns); end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/file_patterns.rb#17 + def from(patterns); end + end +end + +# The bootstrap module for formatter. +# +# source://rubocop//lib/rubocop/formatter.rb#5 +module RuboCop::Formatter; end + +# Does not show individual offenses in the console. +# +# source://rubocop//lib/rubocop/formatter/auto_gen_config_formatter.rb#6 +class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::ProgressFormatter + # source://rubocop//lib/rubocop/formatter/auto_gen_config_formatter.rb#7 + def finished(inspected_files); end +end + +# Abstract base class for formatter, implements all public API methods. +# +# ## Creating Custom Formatter +# +# You can create a custom formatter by subclassing +# `RuboCop::Formatter::BaseFormatter` and overriding some methods +# or by implementing all the methods by duck typing. +# +# ## Using Custom Formatter in Command Line +# +# You can tell RuboCop to use your custom formatter with a combination of +# `--format` and `--require` option. +# For example, when you have defined `MyCustomFormatter` in +# `./path/to/my_custom_formatter.rb`, you would type this command: +# +# rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter +# +# Note: The path passed to `--require` is directly passed to +# `Kernel.require`. +# If your custom formatter file is not in `$LOAD_PATH`, +# you need to specify the path as relative path prefixed with `./` +# explicitly or absolute path. +# +# ## Method Invocation Order +# +# For example, when RuboCop inspects 2 files, +# the invocation order should be like this: +# +# * `#initialize` +# * `#started` +# * `#file_started` +# * `#file_finished` +# * `#file_started` +# * `#file_finished` +# * `#finished` +# +# source://rubocop//lib/rubocop/formatter/base_formatter.rb#41 +class RuboCop::Formatter::BaseFormatter + # @api public + # @param output [IO] `$stdout` or opened file + # @return [BaseFormatter] a new instance of BaseFormatter + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#63 + def initialize(output, options = T.unsafe(nil)); end + + # Invoked at the end of inspecting each files. + # + # @api public + # @param file [String] the file path + # @param offenses [Array(RuboCop::Cop::Offense)] all detected offenses for the file + # @return [void] + # @see RuboCop::Cop::Offense + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#104 + def file_finished(file, offenses); end + + # Invoked at the beginning of inspecting each files. + # + # @api public + # @param file [String] the file path + # @param options [Hash] file specific information, currently this is always empty. + # @return [void] + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#89 + def file_started(file, options); end + + # Invoked after all files are inspected or interrupted by user. + # + # @api public + # @param inspected_files [Array(String)] the inspected file paths. + # This would be same as `target_files` passed to `#started` + # unless RuboCop is interrupted by user. + # @return [void] + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#116 + def finished(inspected_files); end + + # @api public + # @return [Hash] + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#57 + def options; end + + # @api public + # @return [IO] the IO object passed to `#initialize` + # @see #initialize + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#50 + def output; end + + # Invoked once before any files are inspected. + # + # @api public + # @param target_files [Array(String)] all target file paths to be inspected + # @return [void] + # + # source://rubocop//lib/rubocop/formatter/base_formatter.rb#76 + def started(target_files); end +end + +# This formatter formats report data in clang style. +# The precise location of the problem is shown together with the +# relevant source code. +# +# source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#8 +class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleTextFormatter + # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#11 + def report_file(file, offenses); end + + private + + # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#51 + def report_highlighted_area(highlighted_area); end + + # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#41 + def report_line(location); end + + # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#17 + def report_offense(file, offense); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#37 + def valid_line?(offense); end +end + +# source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#9 +RuboCop::Formatter::ClangStyleFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +# This mix-in module provides string coloring methods for terminals. +# It automatically disables coloring if coloring is disabled in the process +# globally or the formatter's output is not a terminal. +# +# source://rubocop//lib/rubocop/formatter/colorizable.rb#8 +module RuboCop::Formatter::Colorizable + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def black(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def blue(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#21 + def colorize(string, *args); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def cyan(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def green(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def magenta(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#9 + def rainbow; end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def red(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def white(string); end + + # source://rubocop//lib/rubocop/formatter/colorizable.rb#35 + def yellow(string); end +end + +# This formatter displays a YAML configuration file where all cops that +# detected any offenses are configured to not detect the offense. +# +# source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#7 +class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::PathUtil + + # @return [DisabledConfigFormatter] a new instance of DisabledConfigFormatter + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#27 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#39 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#33 + def file_started(_file, _file_info); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#47 + def finished(_inspected_files); end + + private + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#68 + def auto_gen_enforced_style?; end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#72 + def command; end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#156 + def cop_config_params(default_cfg, cfg); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#176 + def default_config(cop_name); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#220 + def excludes(offending_files, cop_name, parent); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#191 + def filtered_config(cfg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#241 + def merge_mode_for_exclude?(cfg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#262 + def no_exclude_limit?; end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#101 + def output_cop(cop_name, offense_count); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#128 + def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#180 + def output_cop_config(output_buffer, cfg, cop_name); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#163 + def output_cop_param_comments(output_buffer, params, default_cfg); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#210 + def output_exclude_list(output_buffer, offending_files, cop_name); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#245 + def output_exclude_path(output_buffer, exclude_path, parent); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#199 + def output_offending_files(output_buffer, cfg, cop_name); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#95 + def output_offenses; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#258 + def safe_autocorrect?(config); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#115 + def set_max(cfg, cop_name); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#64 + def show_offense_counts?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#60 + def show_timestamp?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#148 + def supports_safe_autocorrect?(cop_class, default_cfg); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#152 + def supports_unsafe_autocorrect?(cop_class, default_cfg); end + + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#91 + def timestamp; end + + class << self + # Returns the value of attribute config_to_allow_offenses. + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24 + def config_to_allow_offenses; end + + # Sets the attribute config_to_allow_offenses + # + # @param value the value to set the attribute config_to_allow_offenses to. + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24 + def config_to_allow_offenses=(_arg0); end + + # Returns the value of attribute detected_styles. + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24 + def detected_styles; end + + # Sets the attribute detected_styles + # + # @param value the value to set the attribute detected_styles to. + # + # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24 + def detected_styles=(_arg0); end + end +end + +# source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#10 +RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String) + +# This formatter displays the report data in format that's +# easy to process in the Emacs text editor. +# The output is machine-parsable. +# +# source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#8 +class RuboCop::Formatter::EmacsStyleFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#9 + def file_finished(file, offenses); end + + private + + # source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#24 + def message(offense); end +end + +# This formatter displays just a list of the files with offenses in them, +# separated by newlines. The output is machine-parsable. +# +# Here's the format: +# +# /some/file +# /some/other/file +# +# source://rubocop//lib/rubocop/formatter/file_list_formatter.rb#12 +class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop//lib/rubocop/formatter/file_list_formatter.rb#13 + def file_finished(file, offenses); end +end + +# This is a collection of formatters. A FormatterSet can hold multiple +# formatter instances and provides transparent formatter API methods +# which invoke same method of each formatters. +# +# source://rubocop//lib/rubocop/formatter/formatter_set.rb#10 +class RuboCop::Formatter::FormatterSet < ::Array + # @return [FormatterSet] a new instance of FormatterSet + # + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#39 + def initialize(options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#55 + def add_formatter(formatter_type, output_path = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#67 + def close_output_files; end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#50 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#44 + def file_started(file, options); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#34 + def finished(*args); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#34 + def started(*args); end + + private + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#86 + def builtin_formatter_class(specified_key); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#99 + def custom_formatter_class(specified_class_name); end + + # source://rubocop//lib/rubocop/formatter/formatter_set.rb#75 + def formatter_class(formatter_type); end +end + +# source://rubocop//lib/rubocop/formatter/formatter_set.rb#11 +RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/formatter/formatter_set.rb#31 +RuboCop::Formatter::FormatterSet::FORMATTER_APIS = T.let(T.unsafe(nil), Array) + +# This formatter displays a progress bar and shows details of offenses as +# soon as they are detected. +# This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer. +# https://github.com/jeffkreeftmeijer/fuubar +# +# source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#11 +class RuboCop::Formatter::FuubarStyleFormatter < ::RuboCop::Formatter::ClangStyleFormatter + # @return [FuubarStyleFormatter] a new instance of FuubarStyleFormatter + # + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#14 + def initialize(*output); end + + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#51 + def count_stats(offenses); end + + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#40 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#71 + def progressbar_color; end + + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#20 + def started(target_files); end + + # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#61 + def with_color; end +end + +# source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#12 +RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String) + +# This formatter formats report data as GitHub Workflow commands resulting +# in GitHub check annotations when run within GitHub Actions. +# +# source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#7 +class RuboCop::Formatter::GitHubActionsFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#14 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#18 + def finished(_inspected_files); end + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#10 + def started(_target_files); end + + private + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#29 + def github_escape(string); end + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#41 + def github_severity(offense); end + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#33 + def minimum_severity_to_fail; end + + # source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#45 + def report_offense(file, offense); end +end + +# source://rubocop//lib/rubocop/formatter/git_hub_actions_formatter.rb#8 +RuboCop::Formatter::GitHubActionsFormatter::ESCAPE_MAP = T.let(T.unsafe(nil), Hash) + +# This formatter saves the output as an html file. +# +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#9 +class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter + # @return [HTMLFormatter] a new instance of HTMLFormatter + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#28 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#38 + def file_finished(file, offenses); end + + # Returns the value of attribute files. + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#26 + def files; end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#43 + def finished(inspected_files); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#49 + def render_html; end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#34 + def started(target_files); end + + # Returns the value of attribute summary. + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#26 + def summary; end +end + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#13 +class RuboCop::Formatter::HTMLFormatter::Color < ::Struct + # Returns the value of attribute alpha + # + # @return [Object] the current value of alpha + def alpha; end + + # Sets the attribute alpha + # + # @param value [Object] the value to set the attribute alpha to. + # @return [Object] the newly set value + def alpha=(_); end + + # Returns the value of attribute blue + # + # @return [Object] the current value of blue + def blue; end + + # Sets the attribute blue + # + # @param value [Object] the value to set the attribute blue to. + # @return [Object] the newly set value + def blue=(_); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#18 + def fade_out(amount); end + + # Returns the value of attribute green + # + # @return [Object] the current value of green + def green; end + + # Sets the attribute green + # + # @param value [Object] the value to set the attribute green to. + # @return [Object] the newly set value + def green=(_); end + + # Returns the value of attribute red + # + # @return [Object] the current value of red + def red; end + + # Sets the attribute red + # + # @param value [Object] the value to set the attribute red to. + # @return [Object] the newly set value + def red=(_); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#14 + def to_s; end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#10 +RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +# This class provides helper methods used in the ERB template. +# +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#60 +class RuboCop::Formatter::HTMLFormatter::ERBContext + include ::RuboCop::PathUtil + include ::RuboCop::Formatter::TextUtil + + # @return [ERBContext] a new instance of ERBContext + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#76 + def initialize(files, summary); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#123 + def base64_encoded_logo_image; end + + # Make Kernel#binding public. + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#83 + def binding; end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#88 + def decorated_message(offense); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#119 + def escape(string); end + + # Returns the value of attribute files. + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#74 + def files; end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#99 + def highlight_source_tag(offense); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#92 + def highlighted_source_line(offense); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#115 + def possible_ellipses(location); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#110 + def source_after_highlight(offense); end + + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#105 + def source_before_highlight(offense); end + + # Returns the value of attribute summary. + # + # source://rubocop//lib/rubocop/formatter/html_formatter.rb#74 + def summary; end +end + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#72 +RuboCop::Formatter::HTMLFormatter::ERBContext::LOGO_IMAGE_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#64 +RuboCop::Formatter::HTMLFormatter::ERBContext::SEVERITY_COLORS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#24 +class RuboCop::Formatter::HTMLFormatter::FileOffenses < ::Struct + # Returns the value of attribute offenses + # + # @return [Object] the current value of offenses + def offenses; end + + # Sets the attribute offenses + # + # @param value [Object] the value to set the attribute offenses to. + # @return [Object] the newly set value + def offenses=(_); end + + # Returns the value of attribute path + # + # @return [Object] the current value of path + def path; end + + # Sets the attribute path + # + # @param value [Object] the value to set the attribute path to. + # @return [Object] the newly set value + def path=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#23 +class RuboCop::Formatter::HTMLFormatter::Summary < ::Struct + # Returns the value of attribute inspected_files + # + # @return [Object] the current value of inspected_files + def inspected_files; end + + # Sets the attribute inspected_files + # + # @param value [Object] the value to set the attribute inspected_files to. + # @return [Object] the newly set value + def inspected_files=(_); end + + # Returns the value of attribute offense_count + # + # @return [Object] the current value of offense_count + def offense_count; end + + # Sets the attribute offense_count + # + # @param value [Object] the value to set the attribute offense_count to. + # @return [Object] the newly set value + def offense_count=(_); end + + # Returns the value of attribute target_files + # + # @return [Object] the current value of target_files + def target_files; end + + # Sets the attribute target_files + # + # @param value [Object] the value to set the attribute target_files to. + # @return [Object] the newly set value + def target_files=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def keyword_init?; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop//lib/rubocop/formatter/html_formatter.rb#11 +RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String) + +# This formatter formats the report data in JSON format. +# +# source://rubocop//lib/rubocop/formatter/json_formatter.rb#9 +class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::PathUtil + + # @return [JSONFormatter] a new instance of JSONFormatter + # + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#14 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#23 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#28 + def finished(inspected_files); end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#43 + def hash_for_file(file, offenses); end + + # TODO: Consider better solution for Offense#real_column. + # The minimum value of `start_column: real_column` is 1. + # So, the minimum value of `last_column` should be 1. + # And non-zero value of `last_column` should be used as is. + # + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#65 + def hash_for_location(offense); end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#50 + def hash_for_offense(offense); end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#33 + def metadata_hash; end + + # Returns the value of attribute output_hash. + # + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#12 + def output_hash; end + + # source://rubocop//lib/rubocop/formatter/json_formatter.rb#19 + def started(target_files); end +end + +# This formatter formats the report data in JUnit format. +# +# source://rubocop//lib/rubocop/formatter/junit_formatter.rb#17 +class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter + # @return [JUnitFormatter] a new instance of JUnitFormatter + # + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#18 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#55 + def add_testcase_element_to_testsuite_element(file, target_offenses, cop); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#64 + def classname_attribute_value(file); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#29 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#71 + def finished(_inspected_files); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#51 + def offenses_for_cop(all_offenses, cop); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#47 + def relevant_for_output?(options, target_offenses); end + + private + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#83 + def add_failure_to(testcase, offenses, cop_name); end + + # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#78 + def reset_count; end +end + +# This formatter displays the report data in markdown +# +# source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#6 +class RuboCop::Formatter::MarkdownFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::Formatter::TextUtil + include ::RuboCop::PathUtil + + # @return [MarkdownFormatter] a new instance of MarkdownFormatter + # + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#11 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#21 + def file_finished(file, offenses); end + + # Returns the value of attribute files. + # + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#9 + def files; end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#26 + def finished(inspected_files); end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#17 + def started(target_files); end + + # Returns the value of attribute summary. + # + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#9 + def summary; end + + private + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#73 + def possible_ellipses(location); end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#33 + def render_markdown; end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#67 + def write_code(offense); end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#61 + def write_context(offense); end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#42 + def write_file_messages; end + + # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#54 + def write_heading(file); end +end + +# This formatter displays the list of offended cops with a count of how +# many offenses of their kind were found. Ordered by desc offense count +# +# Here's the format: +# +# 26 LineLength +# 3 OneLineConditional +# -- +# 29 Total in 5 files +# +# source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#16 +class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#42 + def file_finished(_file, offenses); end + + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#51 + def finished(_inspected_files); end + + # Returns the value of attribute offense_counts. + # + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#17 + def offense_counts; end + + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#74 + def ordered_offense_counts(offense_counts); end + + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#56 + def report_summary(offense_counts, offending_files_count); end + + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#19 + def started(target_files); end + + # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#78 + def total_offense_count(offense_counts); end +end + +# This formatter prints a PACDOT per every file to be analyzed. +# Pacman will "eat" one PACDOT per file when no offense is detected. +# Otherwise it will print a Ghost. +# This is inspired by the Pacman formatter for RSpec by Carlos Rojas. +# https://github.com/go-labs/rspec_pacman_formatter +# +# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#10 +class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include ::RuboCop::Formatter::TextUtil + + # @return [PacmanFormatter] a new instance of PacmanFormatter + # + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#19 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#50 + def cols; end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#37 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#33 + def file_started(_file, _options); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#43 + def next_step(offenses); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#64 + def pacdots(number); end + + # Returns the value of attribute progress_line. + # + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#12 + def progress_line; end + + # Sets the attribute progress_line + # + # @param value the value to set the attribute progress_line to. + # + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#12 + def progress_line=(_arg0); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#26 + def started(target_files); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#68 + def step(character); end + + # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#57 + def update_progress_line; end +end + +# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#14 +RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#15 +RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#17 +RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter) + +# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#16 +RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter) + +# This formatter display dots for files with no offenses and +# letters for files with problems in the them. In the end it +# appends the regular report data in the clang style format. +# +# source://rubocop//lib/rubocop/formatter/progress_formatter.rb#8 +class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include ::RuboCop::Formatter::TextUtil + + # @return [ProgressFormatter] a new instance of ProgressFormatter + # + # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#13 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#24 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#33 + def finished(inspected_files); end + + # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#50 + def report_file_as_mark(offenses); end + + # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#18 + def started(target_files); end +end + +# source://rubocop//lib/rubocop/formatter/progress_formatter.rb#11 +RuboCop::Formatter::ProgressFormatter::DOT = T.let(T.unsafe(nil), String) + +# If no offenses are found, no output is displayed. +# Otherwise, SimpleTextFormatter's output is displayed. +# +# source://rubocop//lib/rubocop/formatter/quiet_formatter.rb#7 +class RuboCop::Formatter::QuietFormatter < ::RuboCop::Formatter::SimpleTextFormatter + # source://rubocop//lib/rubocop/formatter/quiet_formatter.rb#8 + def report_summary(file_count, offense_count, correction_count, correctable_count); end +end + +# A basic formatter that displays only files with offenses. +# Offenses are displayed at compact form - just the +# location of the problem and the associated message. +# +# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#10 +class RuboCop::Formatter::SimpleTextFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::PathUtil + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#29 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#36 + def finished(inspected_files); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#43 + def report_file(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#57 + def report_summary(file_count, offense_count, correction_count, correctable_count); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#23 + def started(_target_files); end + + private + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#85 + def annotate_message(msg); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#80 + def colored_severity_code(offense); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#73 + def count_stats(offenses); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#89 + def message(offense); end +end + +# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#14 +RuboCop::Formatter::SimpleTextFormatter::COLOR_FOR_SEVERITY = T.let(T.unsafe(nil), Hash) + +# A helper class for building the report summary text. +# +# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#105 +class RuboCop::Formatter::SimpleTextFormatter::Report + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::Formatter::TextUtil + + # @return [Report] a new instance of Report + # + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#110 + def initialize(file_count, offense_count, correction_count, correctable_count, rainbow, safe_autocorrect: T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#123 + def summary; end + + private + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#160 + def correctable; end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#153 + def corrections; end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#142 + def files; end + + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#146 + def offenses; end + + # Returns the value of attribute rainbow. + # + # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#140 + def rainbow; end +end + +# This formatter formats report data using the Test Anything Protocol. +# TAP allows for to communicate tests results in a language agnostics way. +# +# source://rubocop//lib/rubocop/formatter/tap_formatter.rb#7 +class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatter + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#14 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#8 + def started(target_files); end + + private + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#66 + def annotate_message(msg); end + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#70 + def message(offense); end + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#39 + def report_highlighted_area(highlighted_area); end + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#29 + def report_line(location); end + + # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#46 + def report_offense(file, offense); end +end + +# Common logic for UI texts. +# +# source://rubocop//lib/rubocop/formatter/text_util.rb#6 +module RuboCop::Formatter::TextUtil + private + + # source://rubocop//lib/rubocop/formatter/text_util.rb#9 + def pluralize(number, thing, options = T.unsafe(nil)); end + + class << self + # source://rubocop//lib/rubocop/formatter/text_util.rb#9 + def pluralize(number, thing, options = T.unsafe(nil)); end + end +end + +# This formatter displays the list of offensive files, sorted by number of +# offenses with the worst offenders first. +# +# Here's the format: +# +# 26 this/file/is/really/bad.rb +# 3 just/ok.rb +# -- +# 29 Total in 2 files +# +# source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#16 +class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#24 + def file_finished(file, offenses); end + + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#31 + def finished(_inspected_files); end + + # Returns the value of attribute offense_counts. + # + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#17 + def offense_counts; end + + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#55 + def ordered_offense_counts(offense_counts); end + + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#36 + def report_summary(offense_counts); end + + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#19 + def started(target_files); end + + # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#59 + def total_offense_count(offense_counts); end +end + +# source://rubocop//lib/rubocop/options.rb#8 +class RuboCop::IncorrectCopNameError < ::StandardError; end + +# Encapsulation of a lockfile for use when checking for gems. +# Does not actually resolve gems, just parses the lockfile. +# +# @api private +# +# source://rubocop//lib/rubocop/lockfile.rb#7 +class RuboCop::Lockfile + # Gems that the bundle depends on + # + # @api private + # + # source://rubocop//lib/rubocop/lockfile.rb#9 + def dependencies; end + + # All activated gems, including transitive dependencies + # + # @api private + # + # source://rubocop//lib/rubocop/lockfile.rb#16 + def gems; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/lockfile.rb#24 + def includes_gem?(name); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/lockfile.rb#30 + def parser; end +end + +# source://rubocop//lib/rubocop/lsp/logger.rb#13 +module RuboCop::Lsp; end + +# Log for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/logger.rb#16 +class RuboCop::Lsp::Logger + class << self + # @api private + # + # source://rubocop//lib/rubocop/lsp/logger.rb#17 + def log(message); end + end +end + +# Routes for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/routes.rb#18 +class RuboCop::Lsp::Routes + # @api private + # @return [Routes] a new instance of Routes + # + # source://rubocop//lib/rubocop/lsp/routes.rb#25 + def initialize(server); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#31 + def for(name); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#38 + def handle_initialize(request); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#61 + def handle_initialized(_request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#170 + def handle_method_missing(request); end + + # source://rubocop//lib/rubocop/lsp/routes.rb#67 + def handle_shutdown(request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#159 + def handle_unsupported_method(request, method = T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#208 + def diagnostic(file_uri, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#178 + def extract_initialization_options_from(request); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#188 + def format_file(file_uri, command: T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#222 + def remove_file_protocol_from(uri); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#226 + def to_diagnostic(offense); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#238 + def to_range(location); end + + class << self + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/routes.rb#19 + def handle(name, &block); end + end +end + +# Runtime for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/runtime.rb#16 +class RuboCop::Lsp::Runtime + # @api private + # @return [Runtime] a new instance of Runtime + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#19 + def initialize(config_store); end + + # This abuses the `--stdin` option of rubocop and reads the formatted text + # from the `options[:stdin]` that rubocop mutates. This depends on + # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup + # or reassign that options object. Risky business! + # + # Reassigning `options[:stdin]` is done here: + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131 + # Printing `options[:stdin]` + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95 + # Setting `parallel: true` would break this here: + # https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72 + # + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#38 + def format(path, text, command:); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#17 + def layout_mode=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#17 + def lint_mode=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#55 + def offenses(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#17 + def safe_autocorrect=(_arg0); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#77 + def config_only_options; end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#84 + def redirect_stdout(&block); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/runtime.rb#92 + def run_rubocop(options, path); end +end + +# Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/server.rb#21 +class RuboCop::Lsp::Server + # @api private + # @return [Server] a new instance of Server + # + # source://rubocop//lib/rubocop/lsp/server.rb#22 + def initialize(config_store); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#56 + def configure(options); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#48 + def format(path, text, command:); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#52 + def offenses(path, text); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#29 + def start; end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#62 + def stop(&block); end + + # @api private + # + # source://rubocop//lib/rubocop/lsp/server.rb#44 + def write(response); end +end + +# Severity for Language Server Protocol of RuboCop. +# +# @api private +# +# source://rubocop//lib/rubocop/lsp/severity.rb#7 +class RuboCop::Lsp::Severity + class << self + # @api private + # + # source://rubocop//lib/rubocop/lsp/severity.rb#17 + def find_by(rubocop_severity); end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/lsp/severity.rb#8 +RuboCop::Lsp::Severity::SEVERITIES = T.let(T.unsafe(nil), Hash) + +# Parse different formats of magic comments. +# +# @abstract parent of three different magic comment handlers +# +# source://rubocop//lib/rubocop/magic_comment.rb#7 +class RuboCop::MagicComment + # @return [MagicComment] a new instance of MagicComment + # + # source://rubocop//lib/rubocop/magic_comment.rb#32 + def initialize(comment); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#36 + def any?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#104 + def encoding_specified?; end + + # Expose the `frozen_string_literal` value coerced to a boolean if possible. + # + # @return [Boolean] if value is `true` or `false` + # @return [nil] if frozen_string_literal comment isn't found + # @return [String] if comment is found but isn't true or false + # + # source://rubocop//lib/rubocop/magic_comment.rb#86 + def frozen_string_literal; end + + # Does the magic comment enable the frozen string literal feature. + # + # Test whether the frozen string literal value is `true`. Cannot + # just return `frozen_string_literal` since an invalid magic comment + # `'yes'` does not actually enable the feature + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#55 + def frozen_string_literal?; end + + # Was a magic comment for the frozen string literal found? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#70 + def frozen_string_literal_specified?; end + + # Expose the `shareable_constant_value` value coerced to a boolean if possible. + # + # @return [String] for shareable_constant_value config + # + # source://rubocop//lib/rubocop/magic_comment.rb#100 + def shareable_constant_value; end + + # Was a shareable_constant_value specified? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#77 + def shareable_constant_value_specified?; end + + # source://rubocop//lib/rubocop/magic_comment.rb#115 + def typed; end + + # Was the Sorbet `typed` sigil specified? + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#111 + def typed_specified?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#43 + def valid?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#59 + def valid_literal_value?; end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#63 + def valid_shareable_constant_value?; end + + private + + # Match the entire comment string with a pattern and take the first capture. + # + # @param pattern [Regexp] + # @return [String] if pattern matched + # @return [nil] otherwise + # + # source://rubocop//lib/rubocop/magic_comment.rb#131 + def extract(pattern); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/magic_comment.rb#121 + def specified?(value); end + + class << self + # Detect magic comment format and pass it to the appropriate wrapper. + # + # @param comment [String] + # @return [RuboCop::MagicComment] + # + # source://rubocop//lib/rubocop/magic_comment.rb#23 + def parse(comment); end + end +end + +# Parent to Vim and Emacs magic comment handling. +# +# @abstract +# +# source://rubocop//lib/rubocop/magic_comment.rb#138 +class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment + # source://rubocop//lib/rubocop/magic_comment.rb#139 + def encoding; end + + # Rewrite the comment without a given token type + # + # source://rubocop//lib/rubocop/magic_comment.rb#144 + def without(type); end + + private + + # Find a token starting with the provided keyword and extract its value. + # + # @param keyword [String] + # @return [String] extracted value if it is found + # @return [nil] otherwise + # + # source://rubocop//lib/rubocop/magic_comment.rb#159 + def match(keyword); end + + # Individual tokens composing an editor specific comment string. + # + # @return [Array] + # + # source://rubocop//lib/rubocop/magic_comment.rb#174 + def tokens; end +end + +# Wrapper for Emacs style magic comments. +# +# @example Emacs style comment +# comment = RuboCop::MagicComment.parse( +# '# -*- encoding: ASCII-8BIT -*-' +# ) +# +# comment.encoding # => 'ascii-8bit' +# @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html +# @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y +# +# source://rubocop//lib/rubocop/magic_comment.rb#190 +class RuboCop::MagicComment::EmacsComment < ::RuboCop::MagicComment::EditorComment + private + + # source://rubocop//lib/rubocop/magic_comment.rb#198 + def extract_frozen_string_literal; end + + # source://rubocop//lib/rubocop/magic_comment.rb#202 + def extract_shareable_constant_value; end + + # Emacs comments cannot specify Sorbet typechecking behavior. + # + # source://rubocop//lib/rubocop/magic_comment.rb#207 + def extract_typed; end +end + +# source://rubocop//lib/rubocop/magic_comment.rb#192 +RuboCop::MagicComment::EmacsComment::FORMAT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/magic_comment.rb#194 +RuboCop::MagicComment::EmacsComment::OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/magic_comment.rb#191 +RuboCop::MagicComment::EmacsComment::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/magic_comment.rb#193 +RuboCop::MagicComment::EmacsComment::SEPARATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/magic_comment.rb#11 +RuboCop::MagicComment::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# Wrapper for regular magic comments not bound to an editor. +# +# Simple comments can only specify one setting per comment. +# +# @example frozen string literal comments +# comment1 = RuboCop::MagicComment.parse('# frozen_string_literal: true') +# comment1.frozen_string_literal # => true +# comment1.encoding # => nil +# @example encoding comments +# comment2 = RuboCop::MagicComment.parse('# encoding: utf-8') +# comment2.frozen_string_literal # => nil +# comment2.encoding # => 'utf-8' +# +# source://rubocop//lib/rubocop/magic_comment.rb#261 +class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment + # Match `encoding` or `coding` + # + # source://rubocop//lib/rubocop/magic_comment.rb#265 + def encoding; end + + # Rewrite the comment without a given token type + # + # source://rubocop//lib/rubocop/magic_comment.rb#270 + def without(type); end + + private + + # Extract `frozen_string_literal`. + # + # The `frozen_string_literal` magic comment only works if it + # is the only text in the comment. + # + # Case-insensitive and dashes/underscores are acceptable. + # + # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138 + # + # source://rubocop//lib/rubocop/magic_comment.rb#287 + def extract_frozen_string_literal; end + + # source://rubocop//lib/rubocop/magic_comment.rb#291 + def extract_shareable_constant_value; end + + # source://rubocop//lib/rubocop/magic_comment.rb#295 + def extract_typed; end +end + +# source://rubocop//lib/rubocop/magic_comment.rb#262 +RuboCop::MagicComment::SimpleComment::FSTRING_LITERAL_COMMENT = T.let(T.unsafe(nil), String) + +# IRB's pattern for matching magic comment tokens. +# +# @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5 +# +# source://rubocop//lib/rubocop/magic_comment.rb#10 +RuboCop::MagicComment::TOKEN = T.let(T.unsafe(nil), String) + +# Wrapper for Vim style magic comments. +# +# @example Vim style comment +# comment = RuboCop::MagicComment.parse( +# '# vim: filetype=ruby, fileencoding=ascii-8bit' +# ) +# +# comment.encoding # => 'ascii-8bit' +# +# source://rubocop//lib/rubocop/magic_comment.rb#218 +class RuboCop::MagicComment::VimComment < ::RuboCop::MagicComment::EditorComment + # For some reason the fileencoding keyword only works if there + # is at least one other token included in the string. For example + # + # # works + # # vim: foo=bar, fileencoding=ascii-8bit + # + # # does nothing + # # vim: foo=bar, fileencoding=ascii-8bit + # + # source://rubocop//lib/rubocop/magic_comment.rb#234 + def encoding; end + + # Vim comments cannot specify Sorbet typechecking behavior. + # + # source://rubocop//lib/rubocop/magic_comment.rb#245 + def extract_typed; end + + # Vim comments cannot specify frozen string literal behavior. + # + # source://rubocop//lib/rubocop/magic_comment.rb#239 + def frozen_string_literal; end + + # Vim comments cannot specify shareable constant values behavior. + # + # source://rubocop//lib/rubocop/magic_comment.rb#242 + def shareable_constant_value; end +end + +# source://rubocop//lib/rubocop/magic_comment.rb#220 +RuboCop::MagicComment::VimComment::FORMAT = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/magic_comment.rb#223 +RuboCop::MagicComment::VimComment::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/magic_comment.rb#222 +RuboCop::MagicComment::VimComment::OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/magic_comment.rb#219 +RuboCop::MagicComment::VimComment::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/magic_comment.rb#221 +RuboCop::MagicComment::VimComment::SEPARATOR = T.let(T.unsafe(nil), String) + +# Common functionality for finding names that are similar to a given name. +# +# @api private +# +# source://rubocop//lib/rubocop/name_similarity.rb#6 +module RuboCop::NameSimilarity + private + + # @api private + # + # source://rubocop//lib/rubocop/name_similarity.rb#9 + def find_similar_name(target_name, names); end + + # @api private + # + # source://rubocop//lib/rubocop/name_similarity.rb#15 + def find_similar_names(target_name, names); end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/name_similarity.rb#9 + def find_similar_name(target_name, names); end + + # @api private + # + # source://rubocop//lib/rubocop/name_similarity.rb#15 + def find_similar_names(target_name, names); end + end +end + +# source://rubocop//lib/rubocop/ast_aliases.rb#5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop//lib/rubocop/options.rb#10 +class RuboCop::OptionArgumentError < ::StandardError; end + +# This class handles command line options. +# +# @api private +# +# source://rubocop//lib/rubocop/options.rb#14 +class RuboCop::Options + # @api private + # @return [Options] a new instance of Options + # + # source://rubocop//lib/rubocop/options.rb#22 + def initialize; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#27 + def parse(command_line_args); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#228 + def add_additional_modes(opts); end + + # the autocorrect command-line arguments map to the autocorrect @options values like so: + # :fix_layout :autocorrect :safe_autocorrect :autocorrect_all + # -x, --fix-layout true true - - + # -a, --auto-correct - true true - + # --safe-auto-correct - true true - + # -A, --auto-correct-all - true - true + # + # @api private + # + # source://rubocop//lib/rubocop/options.rb#139 + def add_autocorrection_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#204 + def add_cache_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#73 + def add_check_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#162 + def add_config_generation_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#180 + def add_cop_selection_csv_option(option, opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#240 + def add_general_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#211 + def add_lsp_option(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#104 + def add_output_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#252 + def add_profile_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#217 + def add_server_options(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#195 + def add_severity_option(opts); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#53 + def define_options; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#262 + def handle_deprecated_option(old_option, new_option); end + + # Finds the option in `args` starting with -- and converts it to a symbol, + # e.g. [..., '--autocorrect', ...] to :autocorrect. + # + # @api private + # + # source://rubocop//lib/rubocop/options.rb#296 + def long_opt_symbol(args); end + + # Sets a value in the @options hash, based on the given long option and its + # value, in addition to calling the block if a block is given. + # + # @api private + # + # source://rubocop//lib/rubocop/options.rb#285 + def option(opts, *args); end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#267 + def rainbow; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#301 + def require_feature(file); end + + # Creates a section of options in order to separate them visually when + # using `--help`. + # + # @api private + # + # source://rubocop//lib/rubocop/options.rb#277 + def section(opts, heading, &_block); end +end + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#20 +RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer) + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#19 +RuboCop::Options::EXITING_OPTIONS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#15 +RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String) + +# This module contains help texts for command line options. +# +# @api private +# +# source://rubocop//lib/rubocop/options.rb#497 +module RuboCop::OptionsHelp; end + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#499 +RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#498 +RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/options.rb#501 +RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash) + +# Validates option arguments and the options' compatibility with each other. +# +# @api private +# +# source://rubocop//lib/rubocop/options.rb#311 +class RuboCop::OptionsValidator + # @api private + # @return [OptionsValidator] a new instance of OptionsValidator + # + # source://rubocop//lib/rubocop/options.rb#349 + def initialize(options); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/options.rb#471 + def boolean_or_empty_cache?; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#437 + def disable_parallel_when_invalid_option_combo; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/options.rb#463 + def display_only_fail_level_offenses_with_autocorrect?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/options.rb#467 + def except_syntax?; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#475 + def incompatible_options; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#450 + def invalid_arguments_for_parallel; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/options.rb#458 + def only_includes_redundant_disable?; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#384 + def validate_auto_gen_config; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#423 + def validate_autocorrect; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#487 + def validate_cache_enabled_for_cache_root; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#358 + def validate_compatibility; end + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#353 + def validate_cop_options; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#405 + def validate_display_only_correctable_and_autocorrect; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#397 + def validate_display_only_failed; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop//lib/rubocop/options.rb#414 + def validate_display_only_failed_and_display_only_correctable; end + + # @api private + # @raise [OptionParser::MissingArgument] + # + # source://rubocop//lib/rubocop/options.rb#479 + def validate_exclude_limit_option; end + + class << self + # Cop name validation must be done later than option parsing, so it's not + # called from within Options. + # + # @api private + # + # source://rubocop//lib/rubocop/options.rb#318 + def validate_cop_list(names); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/options.rb#335 + def format_message_from(name, cop_names); end + end +end + +# Common methods and behaviors for dealing with paths. +# +# source://rubocop//lib/rubocop/path_util.rb#5 +module RuboCop::PathUtil + private + + # Returns true for an absolute Unix or Windows path. + # + # source://rubocop//lib/rubocop/path_util.rb#72 + def absolute?(path); end + + # Returns true for a glob + # + # source://rubocop//lib/rubocop/path_util.rb#77 + def glob?(path); end + + # source://rubocop//lib/rubocop/path_util.rb#107 + def hidden_dir?(path); end + + # source://rubocop//lib/rubocop/path_util.rb#90 + def hidden_file?(path); end + + # source://rubocop//lib/rubocop/path_util.rb#81 + def hidden_file_in_not_hidden_dir?(pattern, path); end + + # source://rubocop//lib/rubocop/path_util.rb#48 + def match_path?(pattern, path); end + + # Loose check to reduce memory allocations + # + # source://rubocop//lib/rubocop/path_util.rb#97 + def maybe_hidden_file?(path); end + + # source://rubocop//lib/rubocop/path_util.rb#13 + def relative_path(path, base_dir = T.unsafe(nil)); end + + # source://rubocop//lib/rubocop/path_util.rb#34 + def smart_path(path); end + + class << self + # Returns true for an absolute Unix or Windows path. + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#72 + def absolute?(path); end + + # Returns true for a glob + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#77 + def glob?(path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#107 + def hidden_dir?(path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#90 + def hidden_file?(path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#81 + def hidden_file_in_not_hidden_dir?(pattern, path); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#48 + def match_path?(pattern, path); end + + # Loose check to reduce memory allocations + # + # @return [Boolean] + # + # source://rubocop//lib/rubocop/path_util.rb#97 + def maybe_hidden_file?(path); end + + # source://rubocop//lib/rubocop/path_util.rb#13 + def relative_path(path, base_dir = T.unsafe(nil)); end + + # Returns the value of attribute relative_paths_cache. + # + # source://rubocop//lib/rubocop/path_util.rb#7 + def relative_paths_cache; end + + # Sets the attribute relative_paths_cache + # + # @param value the value to set the attribute relative_paths_cache to. + # + # source://rubocop//lib/rubocop/path_util.rb#7 + def relative_paths_cache=(_arg0); end + + # source://rubocop//lib/rubocop/path_util.rb#34 + def smart_path(path); end + end +end + +# source://rubocop//lib/rubocop/path_util.rb#94 +RuboCop::PathUtil::HIDDEN_FILE_PATTERN = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/path_util.rb#31 +RuboCop::PathUtil::SMART_PATH_CACHE = T.let(T.unsafe(nil), Hash) + +# This module provides information on the platform that RuboCop is being run +# on. +# +# source://rubocop//lib/rubocop/platform.rb#6 +module RuboCop::Platform + class << self + # @return [Boolean] + # + # source://rubocop//lib/rubocop/platform.rb#7 + def windows?; end + end +end + +# source://rubocop//lib/rubocop/ast_aliases.rb#6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# Common methods and behaviors for dealing with remote config files. +# +# @api private +# +# source://rubocop//lib/rubocop/remote_config.rb#9 +class RuboCop::RemoteConfig + # @api private + # @return [RemoteConfig] a new instance of RemoteConfig + # + # source://rubocop//lib/rubocop/remote_config.rb#14 + def initialize(url, base_dir); end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#19 + def file; end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#32 + def inherit_from_remote(file, path); end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#10 + def uri; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#95 + def cache_name_from_uri; end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#78 + def cache_path; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/remote_config.rb#82 + def cache_path_exists?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/remote_config.rb#86 + def cache_path_expired?; end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#101 + def cloned_url; end + + # @api private + # @yield [request] + # + # source://rubocop//lib/rubocop/remote_config.rb#53 + def generate_request(uri); end + + # @api private + # + # source://rubocop//lib/rubocop/remote_config.rb#62 + def handle_response(response, limit, &block); end + + # @api private + # @raise [ArgumentError] + # + # source://rubocop//lib/rubocop/remote_config.rb#40 + def request(uri = T.unsafe(nil), limit = T.unsafe(nil), &block); end +end + +# @api private +# +# source://rubocop//lib/rubocop/remote_config.rb#12 +RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer) + +# Provides functionality for caching RuboCop runs. +# +# @api private +# +# source://rubocop//lib/rubocop/result_cache.rb#11 +class RuboCop::ResultCache + # @api private + # @return [ResultCache] a new instance of ResultCache + # + # source://rubocop//lib/rubocop/result_cache.rb#87 + def initialize(file, team, options, config_store, cache_root = T.unsafe(nil)); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#100 + def debug?; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#108 + def load; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#85 + def path; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#113 + def save(offenses); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#104 + def valid?; end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#146 + def any_symlink?(path); end + + # We combine team and options into a single "context" checksum to avoid + # making file names that are too long for some filesystems to handle. + # This context is for anything that's not (1) the RuboCop executable + # checksum or (2) the inspected file checksum. + # + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#236 + def context_checksum(team, options); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#189 + def digest(path); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#157 + def file_checksum(file, config_store); end + + # Return a hash of the options given at invocation, minus the ones that have + # no effect on which offenses and disabled line ranges are found, and thus + # don't affect caching. + # + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#220 + def relevant_options_digest(options); end + + # The checksum of the RuboCop program running the inspection. + # + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#174 + def rubocop_checksum; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#200 + def rubocop_extra_features; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#142 + def symlink_protection_triggered?(path); end + + # The external dependency checksums are cached per RuboCop team so that + # the checksums don't need to be recomputed for each file. + # + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#227 + def team_checksum(team); end + + class << self + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#81 + def allow_symlinks_in_cache_location?(config_store); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#75 + def cache_root(config_store); end + + # Remove old files so that the cache doesn't grow too big. When the + # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the + # files in the cache are removed. The reason for removing so much is that + # cleaning should be done relatively seldom, since there is a slight risk + # that some other RuboCop process was just about to read the file, when + # there's parallel execution and the cache is shared. + # + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#28 + def cleanup(config_store, verbose, cache_root = T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#170 + def inhibit_cleanup; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#170 + def inhibit_cleanup=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#42 + def rubocop_required_features; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#42 + def rubocop_required_features=(_arg0); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#170 + def source_checksum; end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#170 + def source_checksum=(_arg0); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#65 + def remove_files(files, dirs, remove_count); end + + # @api private + # + # source://rubocop//lib/rubocop/result_cache.rb#52 + def remove_oldest_files(files, dirs, cache_root, verbose); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/result_cache.rb#48 + def requires_file_removal?(file_count, config_store); end + end +end + +# @api private +# +# source://rubocop//lib/rubocop/result_cache.rb#16 +RuboCop::ResultCache::DL_EXTENSIONS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/result_cache.rb#12 +RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array) + +# This class handles the processing of files, which includes dealing with +# formatters and letting cops inspect the files. +# +# source://rubocop//lib/rubocop/runner.rb#8 +class RuboCop::Runner + # @return [Runner] a new instance of Runner + # + # source://rubocop//lib/rubocop/runner.rb#59 + def initialize(options, config_store); end + + # Sets the attribute aborting + # + # @param value the value to set the attribute aborting to. + # + # source://rubocop//lib/rubocop/runner.rb#57 + def aborting=(_arg0); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#83 + def aborting?; end + + # Returns the value of attribute errors. + # + # source://rubocop//lib/rubocop/runner.rb#56 + def errors; end + + # source://rubocop//lib/rubocop/runner.rb#67 + def run(paths); end + + # Returns the value of attribute warnings. + # + # source://rubocop//lib/rubocop/runner.rb#56 + def warnings; end + + private + + # source://rubocop//lib/rubocop/runner.rb#196 + def add_redundant_disables(file, offenses, source); end + + # source://rubocop//lib/rubocop/runner.rb#170 + def cached_result(file, team); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#250 + def cached_run?; end + + # Check whether a run created source identical to a previous run, which + # means that we definitely have an infinite loop. + # + # source://rubocop//lib/rubocop/runner.rb#328 + def check_for_infinite_loop(processed_source, offenses_by_iteration); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#222 + def check_for_redundant_disables?(source); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#423 + def considered_failure?(offense); end + + # source://rubocop//lib/rubocop/runner.rb#456 + def default_config(cop_name); end + + # source://rubocop//lib/rubocop/runner.rb#272 + def do_inspection_loop(file); end + + # source://rubocop//lib/rubocop/runner.rb#133 + def each_inspected_file(files); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#236 + def except_redundant_cop_disable_directive?; end + + # 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 + + # source://rubocop//lib/rubocop/runner.rb#240 + def file_started(file); end + + # source://rubocop//lib/rubocop/runner.rb#403 + def filter_cop_classes(cop_classes, config); end + + # source://rubocop//lib/rubocop/runner.rb#104 + def find_target_files(paths); end + + # 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 + + # source://rubocop//lib/rubocop/runner.rb#303 + def iterate_until_no_changes(source, offenses_by_iteration); end + + # source://rubocop//lib/rubocop/runner.rb#148 + def list_files(paths); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#452 + def mark_as_safe_by_config?(config); end + + # source://rubocop//lib/rubocop/runner.rb#460 + def minimum_severity_to_fail; end + + # source://rubocop//lib/rubocop/runner.rb#364 + def mobilize_team(processed_source); end + + # source://rubocop//lib/rubocop/runner.rb#369 + def mobilized_cop_classes(config); end + + # source://rubocop//lib/rubocop/runner.rb#432 + def offenses_to_report(offenses); end + + # source://rubocop//lib/rubocop/runner.rb#152 + def process_file(file); end + + # source://rubocop//lib/rubocop/runner.rb#393 + def qualify_option_cop_names; end + + # @yield [cop] + # + # source://rubocop//lib/rubocop/runner.rb#228 + def redundant_cop_disable_directive(file); end + + # source://rubocop//lib/rubocop/runner.rb#262 + def save_in_cache(cache, offenses); end + + # A Cop::Team instance is stateful and may change when inspecting. + # The "standby" team for a given config is an initialized but + # otherwise dormant team that can be used for config- and option- + # level caching in ResultCache. + # + # source://rubocop//lib/rubocop/runner.rb#492 + def standby_team(config); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#410 + def style_guide_cops_only?(config); end + + # @return [Boolean] + # + # source://rubocop//lib/rubocop/runner.rb#444 + def supports_safe_autocorrect?(offense); end + + # @yield [team] + # + # source://rubocop//lib/rubocop/runner.rb#211 + def team_for_redundant_disables(file, offenses, source); end + + # Warms up the RuboCop cache by forking a suitable number of RuboCop + # instances that each inspects its allotted group of files. + # + # source://rubocop//lib/rubocop/runner.rb#91 + def warm_cache(target_files); end + + class << self + # @return [Array<#call>] + # + # source://rubocop//lib/rubocop/runner.rb#29 + def ruby_extractors; end + + private + + # @return [#call] + # + # source://rubocop//lib/rubocop/runner.rb#36 + def default_ruby_extractor; end + end +end + +# An exception indicating that the inspection loop got stuck correcting +# offenses back and forth. +# +# source://rubocop//lib/rubocop/runner.rb#11 +class RuboCop::Runner::InfiniteCorrectionLoop < ::StandardError + # @return [InfiniteCorrectionLoop] a new instance of InfiniteCorrectionLoop + # + # source://rubocop//lib/rubocop/runner.rb#14 + def initialize(path, offenses_by_iteration, loop_start: T.unsafe(nil)); end + + # Returns the value of attribute offenses. + # + # source://rubocop//lib/rubocop/runner.rb#12 + def offenses; end +end + +# @api private +# +# source://rubocop//lib/rubocop/runner.rb#49 +RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer) + +# @api private +# +# source://rubocop//lib/rubocop/runner.rb#52 +RuboCop::Runner::REDUNDANT_COP_DISABLE_DIRECTIVE_RULES = T.let(T.unsafe(nil), Array) + +# Take a string with embedded escapes, and convert the escapes as the Ruby +# interpreter would when reading a double-quoted string literal. +# For example, "\\n" will be converted to "\n". +# +# source://rubocop//lib/rubocop/string_interpreter.rb#7 +class RuboCop::StringInterpreter + class << self + # source://rubocop//lib/rubocop/string_interpreter.rb#24 + def interpret(string); end + + private + + # source://rubocop//lib/rubocop/string_interpreter.rb#51 + def interpret_hex(escape); end + + # source://rubocop//lib/rubocop/string_interpreter.rb#55 + def interpret_octal(escape); end + + # source://rubocop//lib/rubocop/string_interpreter.rb#33 + def interpret_string_escape(escape); end + + # source://rubocop//lib/rubocop/string_interpreter.rb#43 + def interpret_unicode(escape); end + end +end + +# source://rubocop//lib/rubocop/string_interpreter.rb#8 +RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/string_interpreter.rb#12 +RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp) + +# This class finds target files to inspect by scanning the directory tree +# and picking ruby files. +# +# @api private +# +# source://rubocop//lib/rubocop/target_finder.rb#7 +class RuboCop::TargetFinder + # @api private + # @return [TargetFinder] a new instance of TargetFinder + # + # source://rubocop//lib/rubocop/target_finder.rb#10 + def initialize(config_store, options = T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#149 + def all_cops_include; end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#120 + def combined_exclude_glob_patterns(base_dir); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#176 + def configured_include?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#19 + def debug?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#23 + def fail_fast?; end + + # Generate a list of target files by expanding globbing patterns + # (if any). If args is empty, recursively find all Ruby source + # files under the current directory + # + # @api private + # @return [Array] array of file paths + # + # source://rubocop//lib/rubocop/target_finder.rb#31 + def find(args, mode); end + + # Search for files recursively starting at the given base directory using + # the given flags that determine how the match is made. Excluded files will + # be removed later by the caller, but as an optimization find_files removes + # the top level directories that are excluded in configuration in the + # normal way (dir/**/*). + # + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#83 + def find_files(base_dir, flags); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#15 + def force_exclusion?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#180 + def included_file?(file); end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#184 + def process_explicit_path(path, mode); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#153 + def ruby_executable?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#127 + def ruby_extension?(file); end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#131 + def ruby_extensions; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#172 + def ruby_file?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#138 + def ruby_filename?(file); end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#142 + def ruby_filenames; end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#164 + def ruby_interpreters(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#168 + def stdin?; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#112 + def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags); end + + # Finds all Ruby source files under the current or other supplied + # directory. A Ruby source file is defined as a file with the `.rb` + # extension or a file with no extension that has a ruby shebang line + # as its first line. + # It is possible to specify includes and excludes using the config file, + # so you can include other Ruby files like Rakefiles and gemspecs. + # + # @api private + # @param base_dir Root directory under which to search for + # ruby source files + # @return [Array] Array of filenames + # + # source://rubocop//lib/rubocop/target_finder.rb#56 + def target_files_in_dir(base_dir = T.unsafe(nil)); end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_finder.rb#69 + def to_inspect?(file, hidden_files, base_dir_config); end + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#96 + def wanted_dir_patterns(base_dir, exclude_pattern, flags); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_finder.rb#201 + def order; end +end + +# @api private +# +# source://rubocop//lib/rubocop/target_finder.rb#8 +RuboCop::TargetFinder::HIDDEN_PATH_SUBSTRING = T.let(T.unsafe(nil), String) + +# The kind of Ruby that code inspected by RuboCop is written in. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#6 +class RuboCop::TargetRuby + # @api private + # @return [TargetRuby] a new instance of TargetRuby + # + # source://rubocop//lib/rubocop/target_ruby.rb#252 + def initialize(config); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#268 + def rubocop_version_with_support; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#256 + def source; end + + # @api private + # @return [Boolean] + # + # source://rubocop//lib/rubocop/target_ruby.rb#264 + def supported?; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#260 + def version; end + + class << self + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#238 + def supported_versions; end + end +end + +# The lock file of Bundler may identify the target ruby version. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#107 +class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#108 + def name; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#141 + def bundler_lock_file_path; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#114 + def find_version; end +end + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#8 +RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float) + +# If all else fails, a default version will be picked. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#226 +class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#227 + def name; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#233 + def find_version; end +end + +# The target ruby version may be found in a .gemspec file. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#148 +class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop//lib/rubocop/target_ruby.rb#159 + def gem_requirement_versions(param0 = T.unsafe(nil)); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#165 + def name; end + + # source://rubocop//lib/rubocop/target_ruby.rb#154 + def required_ruby_version(param0); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#214 + def find_default_minimal_known_ruby(right_hand_side); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#171 + def find_version; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#181 + def gemspec_filename; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#188 + def gemspec_filepath; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#210 + def version_from_array(array); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#193 + def version_from_gemspec_file(file); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#198 + def version_from_right_hand_side(right_hand_side); end +end + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#151 +RuboCop::TargetRuby::GemspecFile::GEMSPEC_EXTENSION = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#7 +RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#10 +RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash) + +# The target ruby version may be configured in RuboCop's config. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#39 +class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#40 + def name; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#46 + def find_version; end +end + +# The target ruby version may be found in a .ruby-version file. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#53 +class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#57 + def name; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#63 + def filename; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#71 + def find_version; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#67 + def pattern; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#78 + def version_file; end +end + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#54 +RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#55 +RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#242 +RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array) + +# A place where information about a target ruby version is found. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#24 +class RuboCop::TargetRuby::Source + # @api private + # @return [Source] a new instance of Source + # + # source://rubocop//lib/rubocop/target_ruby.rb#27 + def initialize(config); end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#25 + def name; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#32 + def to_s; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#25 + def version; end +end + +# The target ruby version may be found in a .tool-versions file, in a line +# starting with `ruby`. +# +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#86 +class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#90 + def name; end + + private + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#96 + def filename; end + + # @api private + # + # source://rubocop//lib/rubocop/target_ruby.rb#100 + def pattern; end +end + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#87 +RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop//lib/rubocop/target_ruby.rb#88 +RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop//lib/rubocop/ast_aliases.rb#7 +RuboCop::Token = RuboCop::AST::Token + +# This module contains a collection of useful utility methods. +# +# source://rubocop//lib/rubocop/util.rb#5 +module RuboCop::Util + class << self + # source://rubocop//lib/rubocop/util.rb#6 + def silence_warnings; end + end +end + +# source://rubocop//lib/rubocop/error.rb#10 +class RuboCop::ValidationError < ::RuboCop::Error; end + +# This module holds the RuboCop version information. +# +# source://rubocop//lib/rubocop/version.rb#5 +module RuboCop::Version + class << self + # @api private + # + # source://rubocop//lib/rubocop/version.rb#93 + def document_version; end + + # @api private + # + # source://rubocop//lib/rubocop/version.rb#43 + def extension_versions(env); end + + # Returns feature version in one of two ways: + # + # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec) + # * Find by `bundle gem` version style (e.g. rubocop-rake) + # + # @api private + # + # source://rubocop//lib/rubocop/version.rb#77 + def feature_version(feature); end + + # @api private + # + # source://rubocop//lib/rubocop/version.rb#98 + def server_mode; end + + # @api private + # + # source://rubocop//lib/rubocop/version.rb#21 + def version(debug: T.unsafe(nil), env: T.unsafe(nil)); end + end +end + +# source://rubocop//lib/rubocop/version.rb#12 +RuboCop::Version::CANONICAL_FEATURE_NAMES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/version.rb#16 +RuboCop::Version::EXTENSION_PATH_NAMES = T.let(T.unsafe(nil), Hash) + +# source://rubocop//lib/rubocop/version.rb#8 +RuboCop::Version::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop//lib/rubocop/version.rb#6 +RuboCop::Version::STRING = T.let(T.unsafe(nil), String) + +# A Warning exception is different from an Offense with severity 'warning' +# When a Warning is raised, this means that RuboCop was unable to perform a +# requested operation (such as inspecting or correcting a source file) due to +# user error +# For example, a configuration value in .rubocop.yml might be malformed +# +# source://rubocop//lib/rubocop/warning.rb#9 +class RuboCop::Warning < ::StandardError; end + +# Find duplicated keys from YAML. +# +# @api private +# +# source://rubocop//lib/rubocop/yaml_duplication_checker.rb#6 +module RuboCop::YAMLDuplicationChecker + class << self + # @api private + # + # source://rubocop//lib/rubocop/yaml_duplication_checker.rb#7 + def check(yaml_string, filename, &on_duplicated); end + + private + + # @api private + # + # source://rubocop//lib/rubocop/yaml_duplication_checker.rb#21 + def traverse(tree, &on_duplicated); end + end +end + +# Extensions to the core String class +# +# source://rubocop//lib/rubocop/core_ext/string.rb#4 +class String + include ::Comparable + + # Checks whether a string is blank. A string is considered blank if it + # is either empty or contains only whitespace characters. + # + # @example + # ''.blank? #=> true + # @example + # ' '.blank? #=> true + # @example + # ' test'.blank? #=> false + # @return [Boolean] true is the string is blank, false otherwise + # + # source://rubocop//lib/rubocop/core_ext/string.rb#19 + def blank?; end +end diff --git a/updater/Gemfile.lock b/updater/Gemfile.lock index 8d35fac6e45..0b1851f6fbb 100644 --- a/updater/Gemfile.lock +++ b/updater/Gemfile.lock @@ -317,9 +317,17 @@ GEM unicode-display_width (>= 2.4.0, < 3.0) rubocop-ast (1.30.0) parser (>= 3.2.1.0) + rubocop-capybara (2.20.0) + rubocop (~> 1.41) + rubocop-factory_bot (2.25.1) + rubocop (~> 1.41) rubocop-performance (1.19.1) rubocop (>= 1.7.0, < 2.0) rubocop-ast (>= 0.4.0) + rubocop-rspec (2.27.1) + rubocop (~> 1.40) + rubocop-capybara (~> 2.17) + rubocop-factory_bot (~> 2.22) rubocop-sorbet (0.7.6) rubocop (>= 0.90.0) ruby-progressbar (1.13.0) @@ -394,6 +402,7 @@ DEPENDENCIES rspec-sorbet (~> 1.9.2) rubocop (~> 1.58.0) rubocop-performance (~> 1.19.0) + rubocop-rspec (~> 2.27.1) rubocop-sorbet (~> 0.7.3) sentry-opentelemetry (~> 5.16) sentry-ruby (~> 5.16)