rubocop 1.18.0 → 1.56.0

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks that your heredocs are using meaningful delimiters.
+      # Checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
       # forbidden listing additional delimiters.
       #
@@ -31,7 +31,9 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          range = node.children.empty? ? node : node.loc.heredoc_end
+
+          add_offense(range)
         end
 
         private

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Naming
-      # This cops recommends the use of inclusive language instead of problematic terms.
+      # Recommends the use of inclusive language instead of problematic terms.
       # The cop can check the following locations for offenses:
+      #
       # - identifiers
       # - constants
       # - variables
@@ -12,6 +13,7 @@ module RuboCop
       # - symbols
       # - comments
       # - file paths
+      #
       # Each of these locations can be individually enabled/disabled via configuration,
       # for example CheckIdentifiers = true/false.
       #
@@ -19,6 +21,11 @@ module RuboCop
       # 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
@@ -56,10 +63,21 @@ module RuboCop
       #   # 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
       class InclusiveLanguage < Base
         include RangeHelp
+        extend AutoCorrector
 
         EMPTY_ARRAY = [].freeze
+        MSG = "Consider replacing '%<term>s'%<suffix>s."
+        MSG_FOR_FILE_PATH = "Consider replacing '%<term>s' in file path%<suffix>s."
 
         WordLocation = Struct.new(:word, :position)
 
@@ -80,7 +98,7 @@ module RuboCop
         private
 
         def investigate_tokens
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next unless check_token?(token.type)
 
             word_locations = scan_for_words(token.text)
@@ -92,9 +110,16 @@ module RuboCop
 
         def add_offenses_for_token(token, word_locations)
           word_locations.each do |word_location|
-            start_position = token.pos.begin_pos + token.pos.source.index(word_location.word)
-            range = range_between(start_position, start_position + word_location.word.length)
-            add_offense(range, message: create_message(word_location.word))
+            word = word_location.word
+            range = offense_range(token, word)
+
+            add_offense(range, message: create_message(word)) do |corrector|
+              suggestions = find_flagged_term(word)['Suggestions']
+
+              next unless suggestions.is_a?(String)
+
+              corrector.replace(range, suggestions)
+            end
           end
         end
 
@@ -123,7 +148,7 @@ module RuboCop
             next if term_definition.nil?
 
             allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
-            regex_string = ensure_regex_string(term_definition['Regex'] || term)
+            regex_string = ensure_regex_string(extract_regexp(term, term_definition))
             flagged_term_strings << regex_string
 
             add_to_flagged_term_hash(regex_string, term, term_definition)
@@ -132,6 +157,13 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def extract_regexp(term, term_definition)
+          return term_definition['Regex'] if term_definition['Regex']
+          return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']
+
+          term
+        end
+
         def add_to_flagged_term_hash(regex_string, term, term_definition)
           @flagged_term_hash[Regexp.new(regex_string, Regexp::IGNORECASE)] =
             term_definition.merge('Term' => term,
@@ -180,35 +212,41 @@ module RuboCop
         end
 
         def create_single_word_message_for_file(word)
-          create_message(word).sub(/\.$/, ' in file path.')
+          create_message(word, MSG_FOR_FILE_PATH)
         end
 
         def create_multiple_word_message_for_file(words)
-          quoted_words = words.map { |word| "'#{word}'" }
-          "Consider replacing problematic terms #{quoted_words.join(', ')} in file path."
+          format(MSG_FOR_FILE_PATH, term: words.join("', '"), suffix: ' with other terms')
         end
 
         def scan_for_words(input)
-          mask_input(input).enum_for(:scan, @flagged_terms_regex).map do
+          masked_input = mask_input(input)
+          return EMPTY_ARRAY unless masked_input.match?(@flagged_terms_regex)
+
+          masked_input.enum_for(:scan, @flagged_terms_regex).map do
             match = Regexp.last_match
             WordLocation.new(match.to_s, match.offset(0).first)
           end
         end
 
         def mask_input(str)
-          return str if @allowed_regex.nil?
-
           safe_str = if str.valid_encoding?
                        str
                      else
                        str.encode('UTF-8', invalid: :replace, undef: :replace)
                      end
+
+          return safe_str if @allowed_regex.nil?
+
           safe_str.gsub(@allowed_regex) { |match| '*' * match.size }
         end
 
-        def create_message(word)
+        def create_message(word, message = MSG)
           flagged_term = find_flagged_term(word)
-          "Consider replacing problematic term '#{word}'#{flagged_term['SuggestionString']}."
+          suggestions = flagged_term['SuggestionString']
+          suggestions = ' with another term' if suggestions.blank?
+
+          format(message, term: word, suffix: suggestions)
         end
 
         def find_flagged_term(word)
@@ -218,10 +256,6 @@ module RuboCop
           flagged_term
         end
 
-        def create_message_for_file(word)
-          create_message(word).sub(/\.$/, ' in file path.')
-        end
-
         def preprocess_suggestions(suggestions)
           return '' if suggestions.nil? ||
                        (suggestions.is_a?(String) && suggestions.strip.empty?) || suggestions.empty?
@@ -243,6 +277,12 @@ module RuboCop
                            end
           " with #{suggestion_str}"
         end
+
+        def offense_range(token, word)
+          start_position = token.pos.begin_pos + token.pos.source.index(word)
+
+          range_between(start_position, start_position + word.length)
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for memoized methods whose instance variable name
+      # 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`).
@@ -14,6 +14,12 @@ module RuboCop
       # convention that is used to implicitly indicate that an ivar should not
       # be set or referenced outside of the memoization method.
       #
+      # @safety
+      #   This cop relies on the pattern `@instance_var ||= ...`,
+      #   but this is sometimes used for other purposes than memoization
+      #   so this cop is considered unsafe. Also, its autocorrection is unsafe
+      #   because it may conflict with instance variable names already in use.
+      #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
       #   # Method foo is memoized using an instance variable that is
@@ -139,11 +145,9 @@ module RuboCop
       #   define_method(:foo) do
       #     @_foo ||= calculate_expensive_thing
       #   end
-      #
-      # This cop relies on the pattern `@instance_var ||= ...`,
-      # but this is sometimes used for other purposes than memoization
-      # so this cop is considered unsafe.
       class MemoizedInstanceVariableName < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
@@ -162,6 +166,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
@@ -174,14 +179,18 @@ module RuboCop
 
           return if matches?(method_name, lhs)
 
+          suggested_var = suggested_var(method_name)
           msg = format(
             message(lhs.children.first.to_s),
             var: lhs.children.first.to_s,
-            suggested_var: suggested_var(method_name),
+            suggested_var: suggested_var,
             method: method_name
           )
-          add_offense(lhs, message: msg)
+          add_offense(lhs, message: msg) do |corrector|
+            corrector.replace(lhs.loc.name, "@#{suggested_var}")
+          end
         end
+        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -195,24 +204,31 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
           arg = node.arguments.first
-          return unless arg.ivar_type?
+          return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)
-          return unless method_node
+          return false unless method_node
 
           var_name = arg.children.first
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
-            return if matches?(method_name, ivar_assign)
+            return false if matches?(method_name, ivar_assign)
 
+            suggested_var = suggested_var(method_name)
             msg = format(
               message(var_name.to_s),
               var: var_name.to_s,
-              suggested_var: suggested_var(method_name),
+              suggested_var: suggested_var,
               method: method_name
             )
-            add_offense(defined_ivar, message: msg)
-            add_offense(return_ivar, message: msg)
-            add_offense(ivar_assign.loc.name, message: msg)
+            add_offense(defined_ivar, message: msg) do |corrector|
+              corrector.replace(defined_ivar, "@#{suggested_var}")
+            end
+            add_offense(return_ivar, message: msg) do |corrector|
+              corrector.replace(return_ivar, "@#{suggested_var}")
+            end
+            add_offense(ivar_assign.loc.name, message: msg) do |corrector|
+              corrector.replace(ivar_assign.loc.name, "@#{suggested_var}")
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength

data/lib/rubocop/cop/naming/method_name.rb

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all methods use the configured style,
+      # Makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
-      # This cop has `IgnoredPatterns` configuration option.
+      # This cop has `AllowedPatterns` configuration option.
       #
       #   Naming/MethodName:
-      #     IgnoredPatterns:
-      #       - '\A\s*onSelectionBulkChange\s*'
-      #       - '\A\s*onSelectionCleared\s*'
+      #     AllowedPatterns:
+      #       - '\AonSelectionBulkChange\z'
+      #       - '\AonSelectionCleared\z'
       #
       # Method names matching patterns are always allowed.
       #
@@ -30,7 +30,7 @@ module RuboCop
       #   def fooBar; end
       class MethodName < Base
         include ConfigurableNaming
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
 
         MSG = 'Use %<style>s for method names.'
@@ -46,14 +46,14 @@ module RuboCop
 
           attrs.last.each do |name_item|
             name = attr_name(name_item)
-            next if !name || matches_ignored_pattern?(name)
+            next if !name || matches_allowed_pattern?(name)
 
             check_name(node, name, range_position(node))
           end
         end
 
         def on_def(node)
-          return if node.operator_method? || matches_ignored_pattern?(node.method_name)
+          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end
@@ -67,7 +67,7 @@ module RuboCop
 
         def range_position(node)
           selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.loc.expression.end_pos
+          expr_end_pos = node.source_range.end_pos
 
           range_between(selector_end_pos, expr_end_pos)
         end

data/lib/rubocop/cop/naming/method_parameter_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks method parameter names for how descriptive they
+      # Checks method parameter names for how descriptive they
       # are. It is highly configurable.
       #
       # The `MinNameLength` config option takes an integer. It represents
@@ -26,7 +26,7 @@ module RuboCop
       #     num1 * num2
       #   end
       #
-      #   # With `MinArgNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   def baz(a, b, c)
       #     do_stuff(a, b, c)
       #   end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -3,7 +3,30 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that predicates are named properly.
+      # 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
@@ -27,6 +50,12 @@ module RuboCop
       #   # good
       #   def value?
       #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
       class PredicateName < Base
         include AllowedMethods
 
@@ -43,7 +72,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.loc.expression,
+                node.first_argument.source_range,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end
@@ -70,7 +99,7 @@ module RuboCop
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') ||
+            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
             allowed_method?(method_name)
         end
 
@@ -80,7 +109,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?')
+          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
           new_name
         end
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that rescued exceptions variables are named as
+      # Makes sure that rescued exceptions variables are named as
       # expected.
       #
       # The `PreferredName` config option takes a `String`. It represents
@@ -75,13 +75,14 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           return if preferred_name.to_sym == offending_name
 
+          # check variable shadowing for exception variable
+          return if shadowed_variable_name?(node)
+
           range = offense_range(node)
           message = message(node)
 
           add_offense(range, message: message) do |corrector|
-            corrector.replace(range, preferred_name)
-
-            correct_node(corrector, node.body, offending_name, preferred_name)
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -89,7 +90,17 @@ module RuboCop
 
         def offense_range(resbody)
           variable = resbody.exception_variable
-          variable.loc.expression
+          variable.source_range
+        end
+
+        def autocorrect(corrector, node, range, offending_name, preferred_name)
+          corrector.replace(range, preferred_name)
+          correct_node(corrector, node.body, offending_name, preferred_name)
+          return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
+
+          kwbegin_node.right_siblings.each do |child_node|
+            correct_node(corrector, child_node, offending_name, preferred_name)
+          end
         end
 
         def variable_name_matches?(node, name)
@@ -150,6 +161,10 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           format(MSG, preferred: preferred_name, bad: offending_name)
         end
+
+        def shadowed_variable_name?(node)
+          node.each_descendant(:lvar).any? { |n| n.children.first.to_s == preferred_name(n) }
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all variables use the configured style,
+      # Makes sure that all variables use the configured style,
       # snake_case or camelCase, for their names.
       #
       # @example EnforcedStyle: snake_case (default)
@@ -19,12 +19,26 @@ module RuboCop
       #
       #   # good
       #   fooBar = 1
+      #
+      # @example AllowedIdentifiers: ['fooBar']
+      #   # good (with EnforcedStyle: snake_case)
+      #   fooBar = 1
+      #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good (with EnforcedStyle: camelCase)
+      #   :release_v1
+      #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming
+        include AllowedPattern
 
         MSG = 'Use %<style>s for variable names.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_lvasgn(node)
           name, = *node
           return unless name

data/lib/rubocop/cop/naming/variable_number.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all numbered variables use the
+      # Makes sure that all numbered variables use the
       # configured style, snake_case, normalcase, or non_integer,
       # for their numbering.
       #
@@ -11,23 +11,6 @@ module RuboCop
       # can be used to specify whether method names and symbols should be checked.
       # Both are enabled by default.
       #
-      # @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: normalcase (default)
       #   # bad
       #   :some_sym_1
@@ -45,6 +28,23 @@ module RuboCop
       #
       #   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
@@ -96,12 +96,21 @@ module RuboCop
       #   # good
       #   expect(Open3).to receive(:capture3)
       #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good
+      #   :some_sym_v1
+      #
       class VariableNumber < Base
         include AllowedIdentifiers
         include ConfigurableNumbering
+        include AllowedPattern
 
         MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_arg(node)
           @node = node
           name, = *node
@@ -112,6 +121,7 @@ module RuboCop
         alias on_lvasgn on_arg
         alias on_ivasgn on_arg
         alias on_cvasgn on_arg
+        alias on_gvasgn on_arg
 
         def on_def(node)
           @node = node

data/lib/rubocop/cop/offense.rb

@@ -217,7 +217,7 @@ module RuboCop
       alias eql? ==
 
       def hash
-        COMPARISON_ATTRIBUTES.reduce(0) { |hash, attribute| hash ^ public_send(attribute).hash }
+        COMPARISON_ATTRIBUTES.map { |attribute| public_send(attribute) }.hash
       end
 
       # @api public