rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for memoized methods whose instance variable name
+      # does not match the method name.
+      #
+      # 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
+      #
+      #   # 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
+      #
+      # @example EnforcedStyleForLeadingUnderscores: required
+      #   # bad
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def _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
+      class MemoizedInstanceVariableName < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Memoized variable `%<var>s` does not match ' \
+          'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
+        UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
+          'with `_`. Use `@%<suggested_var>s` instead.'
+
+        def self.node_pattern
+          memo_assign = '(or_asgn $(ivasgn _) _)'
+          memoized_at_end_of_method = "(begin ... #{memo_assign})"
+          instance_method =
+            "(def $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
+          class_method =
+            "(defs self $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
+          "{#{instance_method} #{class_method}}"
+        end
+
+        private_class_method :node_pattern
+        def_node_matcher :memoized?, node_pattern
+
+        def on_def(node)
+          (method_name, ivar_assign) = memoized?(node)
+          return if matches?(method_name, ivar_assign)
+
+          msg = format(
+            message(ivar_assign.children.first.to_s),
+            var: ivar_assign.children.first.to_s,
+            suggested_var: suggested_var(method_name),
+            method: method_name
+          )
+          add_offense(node, location: ivar_assign.source_range, message: msg)
+        end
+        alias on_defs on_def
+
+        private
+
+        def style_parameter_name
+          'EnforcedStyleForLeadingUnderscores'
+        end
+
+        def matches?(method_name, ivar_assign)
+          return true if ivar_assign.nil? || method_name == :initialize
+
+          method_name = method_name.to_s.delete('!?')
+          variable = ivar_assign.children.first
+          variable_name = variable.to_s.sub('@', '')
+
+          variable_name_candidates(method_name).include?(variable_name)
+        end
+
+        def message(variable)
+          variable_name = variable.to_s.sub('@', '')
+
+          return UNDERSCORE_REQUIRED if style == :required &&
+                                        !variable_name.start_with?('_')
+
+          MSG
+        end
+
+        def suggested_var(method_name)
+          suggestion = method_name.to_s.delete('!?')
+
+          style == :required ? "_#{suggestion}" : suggestion
+        end
+
+        def variable_name_candidates(method_name)
+          no_underscore = method_name.sub(/\A_/, '')
+          with_underscore = "_#{method_name}"
+          case style
+          when :required
+            [with_underscore,
+             method_name.start_with?('_') ? method_name : nil].compact
+          when :disallowed
+            [method_name, no_underscore]
+          when :optional
+            [method_name, with_underscore, no_underscore]
+          else
+            raise 'Unreachable'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,29 +4,74 @@ module RuboCop
   module Cop
     module Naming
       # This cop makes sure that all methods use the configured style,
-      # snake_case or camelCase, for their names. Some special arrangements
-      # have to be made for operator methods.
-      class MethodName < Cop
+      # snake_case or camelCase, for their names.
+      #
+      # This cop has `IgnoredPatterns` configuration option.
+      #
+      #   Naming/MethodName:
+      #     IgnoredPatterns:
+      #       - '\A\s*onSelectionBulkChange\s*'
+      #       - '\A\s*onSelectionCleared\s*'
+      #
+      # 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
+      class MethodName < Base
         include ConfigurableNaming
+        include IgnoredPattern
+        include RangeHelp
 
-        def on_def(node)
-          name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
+        MSG = 'Use %<style>s for method names.'
+
+        def_node_matcher :sym_name, '(sym $_name)'
+        def_node_matcher :str_name, '(str $_name)'
+
+        def on_send(node)
+          return unless (attrs = node.attribute_accessor?)
+
+          attrs.last.each do |name_item|
+            name = attr_name(name_item)
+            next if !name || matches_ignored_pattern?(name)
+
+            check_name(node, name, range_position(node))
+          end
         end
 
-        def on_defs(node)
-          _object, name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
+        def on_def(node)
+          return if node.operator_method? ||
+                    matches_ignored_pattern?(node.method_name)
+
+          check_name(node, node.method_name, node.loc.name)
         end
+        alias on_defs on_def
 
         private
 
-        def message(style)
-          format('Use %s for method names.', style)
+        def attr_name(name_item)
+          sym_name(name_item) || str_name(name_item)
+        end
+
+        def range_position(node)
+          selector_end_pos = node.loc.selector.end_pos + 1
+          expr_end_pos = node.loc.expression.end_pos
+
+          range_between(selector_end_pos, expr_end_pos)
         end
 
-        def sanitize_name(name)
-          name.to_s.delete('@').to_sym
+        def message(style)
+          format(MSG, style: style)
         end
       end
     end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop 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 `MinArgNameLength` 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
+      class MethodParameterName < Cop
+        include UncommunicativeName
+
+        def on_def(node)
+          return unless node.arguments?
+
+          check(node, node.arguments)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -7,18 +7,30 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   def is_even?(value) ...
+      #   def is_even(value)
+      #   end
+      #
+      #   def is_even?(value)
+      #   end
       #
       #   # good
       #   def even?(value)
+      #   end
       #
       #   # bad
-      #   def has_value? ...
+      #   def has_value
+      #   end
+      #
+      #   def has_value?
+      #   end
       #
       #   # good
-      #   def value? ...
+      #   def value?
+      #   end
       class PredicateName < Cop
-        def_node_matcher :dynamic_method_define, <<-PATTERN
+        include AllowedMethods
+
+        def_node_matcher :dynamic_method_define, <<~PATTERN
           (send nil? #method_definition_macros
             (sym $_)
             ...)
@@ -57,13 +69,14 @@ module RuboCop
         private
 
         def allowed_method_name?(method_name, prefix)
-          !method_name.start_with?(prefix) ||
+          !method_name.match?(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
-            predicate_whitelist.include?(method_name)
+            method_name.end_with?('=') ||
+            allowed_method?(method_name)
         end
 
         def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
+          new_name = if forbidden_prefixes.include?(prefix)
                        method_name.sub(prefix, '')
                      else
                        method_name.dup
@@ -76,18 +89,14 @@ module RuboCop
           "Rename `#{method_name}` to `#{new_name}`."
         end
 
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
+        def forbidden_prefixes
+          cop_config['ForbiddenPrefixes']
         end
 
         def predicate_prefixes
           cop_config['NamePrefix']
         end
 
-        def predicate_whitelist
-          cop_config['NameWhitelist']
-        end
-
         def method_definition_macros(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop 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`.
+      #
+      # @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
+      #
+      class RescuedExceptionsVariableName < Cop
+        MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'
+
+        def on_resbody(node)
+          name = variable_name(node)
+          return unless name
+          return if preferred_name(name).to_sym == name
+
+          add_offense(node, location: offense_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            offending_name = variable_name(node)
+            preferred_name = preferred_name(offending_name)
+            corrector.replace(offense_range(node), preferred_name)
+
+            node.body&.each_descendant(:lvar) do |var|
+              next unless var.children.first == offending_name
+
+              corrector.replace(var, preferred_name)
+            end
+          end
+        end
+
+        private
+
+        def offense_range(resbody)
+          variable = resbody.exception_variable
+          variable.loc.expression
+        end
+
+        def preferred_name(variable_name)
+          preferred_name = cop_config.fetch('PreferredName', 'e')
+          if variable_name.to_s.start_with?('_')
+            "_#{preferred_name}"
+          else
+            preferred_name
+          end
+        end
+
+        def variable_name(node)
+          asgn_node = node.exception_variable
+          return unless asgn_node
+
+          asgn_node.children.last
+        end
+
+        def message(node)
+          offending_name = variable_name(node)
+          preferred_name = preferred_name(offending_name)
+          format(MSG, preferred: preferred_name, bad: offending_name)
+        end
+      end
+    end
+  end
+end

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

@@ -5,15 +5,31 @@ module RuboCop
     module Naming
       # This cop makes sure that all variables use the configured style,
       # snake_case or camelCase, for their names.
-      class VariableName < Cop
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   fooBar = 1
+      #
+      #   # good
+      #   foo_bar = 1
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   foo_bar = 1
+      #
+      #   # good
+      #   fooBar = 1
+      class VariableName < Base
         include ConfigurableNaming
 
+        MSG = 'Use %<style>s for variable names.'
+
         def on_lvasgn(node)
           name, = *node
           return unless name
+
           check_name(node, name, node.loc.name)
         end
-
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
         alias on_arg       on_lvasgn
@@ -23,11 +39,12 @@ module RuboCop
         alias on_kwarg     on_lvasgn
         alias on_kwrestarg on_lvasgn
         alias on_blockarg  on_lvasgn
+        alias on_lvar      on_lvasgn
 
         private
 
         def message(style)
-          format('Use %s for variable names.', style)
+          format(MSG, style: style)
         end
       end
     end

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

@@ -4,12 +4,10 @@ module RuboCop
   module Cop
     module Naming
       # This cop makes sure that all numbered variables use the
-      # configured style, snake_case, normalcase or non_integer,
+      # configured style, snake_case, normalcase, or non_integer,
       # for their numbering.
       #
-      # @example
-      #   "EnforcedStyle => 'snake_case'"
-      #
+      # @example EnforcedStyle: snake_case
       #   # bad
       #
       #   variable1 = 1
@@ -18,9 +16,7 @@ module RuboCop
       #
       #   variable_1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'normalcase'"
-      #
+      # @example EnforcedStyle: normalcase (default)
       #   # bad
       #
       #   variable_1 = 1
@@ -29,48 +25,35 @@ module RuboCop
       #
       #   variable1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'non_integer'"
-      #
-      #   #bad
+      # @example EnforcedStyle: non_integer
+      #   # bad
       #
       #   variable1 = 1
       #
       #   variable_1 = 1
       #
-      #   #good
+      #   # good
       #
       #   variableone = 1
       #
       #   variable_one = 1
-      #
-      class VariableNumber < Cop
+      class VariableNumber < Base
         include ConfigurableNumbering
 
-        def on_lvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_ivasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_cvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
+        MSG = 'Use %<style>s for variable numbers.'
 
         def on_arg(node)
           name, = *node
           check_name(node, name, node.loc.name)
         end
+        alias on_lvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_cvasgn on_arg
 
         private
 
         def message(style)
-          format('Use %s for variable numbers.', style)
+          format(MSG, style: style)
         end
       end
     end