rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Checks that predicate method 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 listed in the `NamePrefix` configuration. The list
+      # defaults to `is_`, `has_`, and `have_` but may be overridden.
+      #
+      # Predicate methods must end with a question mark.
+      #
+      # When `ForbiddenPrefixes` is also set (as it is by default), predicate
+      # methods which begin with a forbidden prefix are not allowed, even if
+      # they end with a `?`. These methods should be changed to remove the
+      # prefix.
+      #
+      # When `UseSorbetSigs` set to true (optional), the cop will only report
+      # offenses if the method has a Sorbet `sig` with a return type of
+      # `T::Boolean`. Dynamic methods are not supported with this configuration.
+      #
+      # @example NamePrefix: ['is_', 'has_', 'have_'] (default)
+      #   # bad
+      #   def is_even(value)
+      #   end
+      #
+      #   # When ForbiddenPrefixes: ['is_', 'has_', 'have_'] (default)
+      #   # good
+      #   def even?(value)
+      #   end
+      #
+      #   # When ForbiddenPrefixes: []
+      #   # good
+      #   def is_even?(value)
+      #   end
+      #
+      # @example NamePrefix: ['seems_to_be_']
+      #   # bad
+      #   def seems_to_be_even(value)
+      #   end
+      #
+      #   # When ForbiddenPrefixes: ['seems_to_be_']
+      #   # good
+      #   def even?(value)
+      #   end
+      #
+      #   # When ForbiddenPrefixes: []
+      #   # good
+      #   def seems_to_be_even?(value)
+      #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # Despite starting with the `is_` prefix, this method is allowed
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
+      # @example AllowedMethods: ['is_even?']
+      #   # good
+      #   def is_even?(value)
+      #   end
+      #
+      # @example UseSorbetSigs: false (default)
+      #  # bad
+      #  sig { returns(String) }
+      #  def is_this_thing_on
+      #    "yes"
+      #  end
+      #
+      #  # good - Sorbet signature is not evaluated
+      #  sig { returns(String) }
+      #  def is_this_thing_on?
+      #    "yes"
+      #  end
+      #
+      # @example UseSorbetSigs: true
+      #   # bad
+      #   sig { returns(T::Boolean) }
+      #   def odd(value)
+      #   end
+      #
+      #   # good
+      #   sig { returns(T::Boolean) }
+      #   def odd?(value)
+      #   end
+      #
+      # @example MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)
+      #   # bad
+      #   define_method(:is_even) { |value| }
+      #
+      #   # good
+      #   define_method(:even?) { |value| }
+      #
+      # @example MethodDefinitionMacros: ['def_node_matcher']
+      #   # bad
+      #   def_node_matcher(:is_even) { |value| }
+      #
+      #   # good
+      #   def_node_matcher(:even?) { |value| }
+      #
+      class PredicatePrefix < Base
+        include AllowedMethods
+
+        # @!method dynamic_method_define(node)
+        def_node_matcher :dynamic_method_define, <<~PATTERN
+          (send nil? #method_definition_macro?
+            (sym $_)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          dynamic_method_define(node) do |method_name|
+            predicate_prefixes.each do |prefix|
+              next if allowed_method_name?(method_name.to_s, prefix)
+
+              add_offense(
+                node.first_argument,
+                message: message(method_name, expected_name(method_name.to_s, prefix))
+              )
+            end
+          end
+        end
+
+        def on_def(node)
+          predicate_prefixes.each do |prefix|
+            method_name = node.method_name.to_s
+
+            next if allowed_method_name?(method_name, prefix)
+            next if use_sorbet_sigs? && !sorbet_sig?(node, return_type: 'T::Boolean')
+
+            add_offense(
+              node.loc.name,
+              message: message(method_name, expected_name(method_name, prefix))
+            )
+          end
+        end
+        alias on_defs on_def
+
+        def validate_config
+          forbidden_prefixes.each do |forbidden_prefix|
+            next if predicate_prefixes.include?(forbidden_prefix)
+
+            raise ValidationError, <<~MSG.chomp
+              The `Naming/PredicatePrefix` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
+            MSG
+          end
+        end
+
+        private
+
+        # @!method sorbet_return_type(node)
+        def_node_matcher :sorbet_return_type, <<~PATTERN
+          (block (send nil? :sig) args (send _ :returns $_type))
+        PATTERN
+
+        def sorbet_sig?(node, return_type: nil)
+          return false unless (type = sorbet_return_type(node.left_sibling))
+
+          type.source == return_type
+        end
+
+        def allowed_method_name?(method_name, prefix)
+          !(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?('=') ||
+            allowed_method?(method_name)
+        end
+
+        def expected_name(method_name, prefix)
+          new_name = if forbidden_prefixes.include?(prefix)
+                       method_name.sub(prefix, '')
+                     else
+                       method_name.dup
+                     end
+          new_name << '?' unless method_name.end_with?('?')
+          new_name
+        end
+
+        def message(method_name, new_name)
+          "Rename `#{method_name}` to `#{new_name}`."
+        end
+
+        def forbidden_prefixes
+          cop_config['ForbiddenPrefixes']
+        end
+
+        def predicate_prefixes
+          cop_config['NamePrefix']
+        end
+
+        def use_sorbet_sigs?
+          cop_config['UseSorbetSigs']
+        end
+
+        def method_definition_macro?(macro_name)
+          cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,17 @@
 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
       # 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
@@ -62,20 +67,22 @@ module RuboCop
           offending_name = variable_name(node)
           return unless offending_name
 
+          # Handle nested rescues by only requiring the outer one to use the
+          # configured variable name, so that nested rescues don't use the same
+          # variable.
+          return if node.each_ancestor(:resbody).any?
+
           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)
-
-            node.body&.each_descendant(:lvar) do |var|
-              next unless var.children.first == offending_name
-
-              corrector.replace(var, preferred_name)
-            end
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -83,7 +90,58 @@ 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)
+          if node.masgn_type?
+            node.each_descendant(:lvasgn).any? do |lvasgn_node|
+              variable_name_matches?(lvasgn_node, name)
+            end
+          else
+            node.name == name
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def correct_node(corrector, node, offending_name, preferred_name)
+          return unless node
+
+          node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
+            next unless variable_name_matches?(child_node, offending_name)
+
+            if child_node.lvar_type?
+              parent_node = child_node.parent
+              if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
+                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+              else
+                corrector.replace(child_node, preferred_name)
+              end
+            end
+
+            if child_node.type?(:masgn, :lvasgn)
+              correct_reassignment(corrector, child_node, offending_name, preferred_name)
+              break
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # 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.
+        def correct_reassignment(corrector, node, offending_name, preferred_name)
+          correct_node(corrector, node.rhs, offending_name, preferred_name)
         end
 
         def preferred_name(variable_name)
@@ -96,10 +154,7 @@ module RuboCop
         end
 
         def variable_name(node)
-          asgn_node = node.exception_variable
-          return unless asgn_node
-
-          asgn_node.children.last
+          node.exception_variable.name if node.exception_variable.respond_to?(:name)
         end
 
         def message(node)
@@ -107,6 +162,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,8 +3,15 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
+      # Checks that the configured style (snake_case or camelCase) is used for all variable names.
+      # This includes local variables, instance variables, class variables, method arguments
+      # (positional, keyword, rest or block), and block arguments.
+      #
+      # The cop can also be configured to forbid using specific names for variables, using
+      # `ForbiddenIdentifiers` or `ForbiddenPatterns`. In addition to the above, this applies
+      # to global variables as well.
+      #
+      # Method definitions and method calls are not affected by this cop.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -19,16 +26,52 @@ 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 = true
+      #
+      # @example ForbiddenIdentifiers: ['fooBar']
+      #   # bad (in all cases)
+      #   fooBar = 1
+      #   @fooBar = 1
+      #   @@fooBar = 1
+      #   $fooBar = 1
+      #
+      # @example ForbiddenPatterns: ['_v\d+\z']
+      #   # bad (in all cases)
+      #   release_v1 = true
+      #   @release_v1 = true
+      #   @@release_v1 = true
+      #   $release_v1 = true
+      #
       class VariableName < Base
+        include AllowedIdentifiers
         include ConfigurableNaming
+        include AllowedPattern
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for variable names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another name instead.'
+
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
 
         def on_lvasgn(node)
-          name, = *node
-          return unless name
+          return unless (name = node.name)
+          return if allowed_identifier?(name)
 
-          check_name(node, name, node.loc.name)
+          if forbidden_name?(name)
+            register_forbidden_name(node)
+          else
+            check_name(node, name, node.loc.name)
+          end
         end
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
@@ -41,11 +84,28 @@ module RuboCop
         alias on_blockarg  on_lvasgn
         alias on_lvar      on_lvasgn
 
+        # Only forbidden names are checked for global variable assignment
+        def on_gvasgn(node)
+          return unless (name = node.name)
+          return unless forbidden_name?(name)
+
+          register_forbidden_name(node)
+        end
+
         private
 
+        def forbidden_name?(name)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
+
         def message(style)
           format(MSG, style: style)
         end
+
+        def register_forbidden_name(node)
+          message = format(MSG_FORBIDDEN, identifier: node.name)
+          add_offense(node.loc.name, message: message)
+        end
       end
     end
   end

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

@@ -3,57 +3,151 @@
 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.
       #
-      # @example EnforcedStyle: snake_case
+      # 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
       #
-      #   variable1 = 1
+      #   def some_method_1; end
+      #
+      #   def some_method1(arg_1); end
       #
       #   # good
+      #   :some_sym1
+      #   variable1 = 1
       #
-      #   variable_1 = 1
+      #   def some_method1; end
       #
-      # @example EnforcedStyle: normalcase (default)
+      #   def some_method1(arg1); end
+      #
+      # @example EnforcedStyle: snake_case
       #   # bad
+      #   :some_sym1
+      #   variable1 = 1
       #
-      #   variable_1 = 1
+      #   def some_method1; end
+      #
+      #   def some_method_1(arg1); end
       #
       #   # good
+      #   :some_sym_1
+      #   variable_1 = 1
       #
-      #   variable1 = 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
+      #
       class VariableNumber < Base
+        include AllowedIdentifiers
         include ConfigurableNumbering
+        include AllowedPattern
+
+        MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
-        MSG = 'Use %<style>s for variable numbers.'
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
 
         def on_arg(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
+          @node = node
+          return if allowed_identifier?(node.name)
+
+          check_name(node, node.name, node.loc.name)
         end
         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
+          return if allowed_identifier?(node.method_name)
+
+          check_name(node, node.method_name, node.loc.name) if cop_config['CheckMethodNames']
+        end
+        alias on_defs on_def
+
+        def on_sym(node)
+          @node = node
+          return if allowed_identifier?(node.value)
+
+          check_name(node, node.value, node) if cop_config['CheckSymbols']
+        end
 
         private
 
         def message(style)
-          format(MSG, style: style)
+          identifier_type =
+            case @node.type
+            when :def, :defs then 'method name'
+            when :sym        then 'symbol'
+            else                  'variable'
+            end
+
+          format(MSG, style: style, identifier_type: identifier_type)
         end
       end
     end

data/lib/rubocop/cop/offense.rb

@@ -7,8 +7,7 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = %i[line column cop_name
-                                 message severity].freeze
+      COMPARISON_ATTRIBUTES = %i[line column cop_name message severity].freeze
 
       # @api public
       #
@@ -44,11 +43,10 @@ module RuboCop
       # @!attribute [r] cop_name
       #
       # @return [String]
-      #   a cop class name without department.
-      #   i.e. type of the violation.
+      #   the cop name as a String for which this offense is for.
       #
       # @example
-      #   'LineLength'
+      #   'Layout/LineLength'
       attr_reader :cop_name
 
       # @api private
@@ -98,8 +96,8 @@ module RuboCop
       # @!attribute [r] correctable?
       #
       # @return [Boolean]
-      #   whether this offense can be automatically corrected via
-      #   autocorrect or a todo.
+      #   whether this offense can be automatically corrected via autocorrect.
+      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
       def correctable?
         @status != :unsupported
       end
@@ -141,9 +139,7 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        Parser::Source::Range.new(source_line,
-                                  column,
-                                  column + column_length)
+        Parser::Source::Range.new(source_line, column, column + column_length)
       end
 
       # @api private
@@ -213,16 +209,14 @@ module RuboCop
       #   returns `true` if two offenses contain same attributes
       def ==(other)
         COMPARISON_ATTRIBUTES.all? do |attribute|
-          send(attribute) == other.send(attribute)
+          public_send(attribute) == other.public_send(attribute)
         end
       end
 
       alias eql? ==
 
       def hash
-        COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|
-          hash ^ send(attribute).hash
-        end
+        COMPARISON_ATTRIBUTES.map { |attribute| public_send(attribute) }.hash
       end
 
       # @api public
@@ -234,7 +228,7 @@ module RuboCop
       #   comparison result
       def <=>(other)
         COMPARISON_ATTRIBUTES.each do |attribute|
-          result = send(attribute) <=> other.send(attribute)
+          result = public_send(attribute) <=> other.public_send(attribute)
           return result unless result.zero?
         end
         0