rubocop 0.74.0 → 0.78.0

data/lib/rubocop/cop/lint/{unneeded_cop_enable_directive.rb → redundant_cop_enable_directive.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-# The Lint/UnneededCopEnableDirective cop needs to be disabled so as
+# The Lint/RedundantCopEnableDirective cop needs to be disabled so as
 # to be able to provide a (bad) example of an unneeded enable.
 
-# rubocop:disable Lint/UnneededCopEnableDirective
+# rubocop:disable Lint/RedundantCopEnableDirective
 module RuboCop
   module Cop
     module Lint
@@ -15,24 +15,24 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
       #   # rubocop:enable all
       #   baz
-      class UnneededCopEnableDirective < Cop
+      class RedundantCopEnableDirective < Cop
         include RangeHelp
         include SurroundingSpace
 
@@ -94,16 +94,14 @@ module RuboCop
 
         def range_to_remove(begin_pos, end_pos, comma_pos, comment)
           start = comment_start(comment)
-          buffer = processed_source.buffer
-          range_class = Parser::Source::Range
 
           case comma_pos
           when :before
-            range_class.new(buffer, start + begin_pos - 1, start + end_pos)
+            range_between(start + begin_pos - 1, start + end_pos)
           when :after
-            range_class.new(buffer, start + begin_pos, start + end_pos + 1)
+            range_between(start + begin_pos, start + end_pos + 1)
           else
-            range_class.new(buffer, start, comment.loc.expression.end_pos)
+            range_between(start, comment.loc.expression.end_pos)
           end
         end
 

data/lib/rubocop/cop/lint/{unneeded_require_statement.rb → redundant_require_statement.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class UnneededRequireStatement < Cop
+      class RedundantRequireStatement < Cop
         include RangeHelp
 
         MSG = 'Remove unnecessary `require` statement.'

data/lib/rubocop/cop/lint/{unneeded_splat_expansion.rb → redundant_splat_expansion.rb}

@@ -49,7 +49,7 @@ module RuboCop
       #   else
       #     baz
       #   end
-      class UnneededSplatExpansion < Cop
+      class RedundantSplatExpansion < Cop
         MSG = 'Replace splat expansion with comma separated values.'
         ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
         PERCENT_W = '%w'
@@ -70,7 +70,7 @@ module RuboCop
         PATTERN
 
         def on_splat(node)
-          unneeded_splat_expansion(node) do
+          redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, message: ARRAY_PARAM_MSG)
@@ -90,7 +90,7 @@ module RuboCop
 
         private
 
-        def unneeded_splat_expansion(node)
+        def redundant_splat_expansion(node)
           literal_expansion(node) do |expanded_item|
             if expanded_item.send_type?
               return if array_new_inside_array_literal?(expanded_item)
@@ -119,7 +119,7 @@ module RuboCop
             [node.parent.loc.expression, variable.source]
           elsif !variable.array_type?
             [loc.expression, "[#{variable.source}]"]
-          elsif unneeded_brackets?(node)
+          elsif redundant_brackets?(node)
             [loc.expression, remove_brackets(variable)]
           else
             [loc.operator, '']
@@ -141,12 +141,12 @@ module RuboCop
           parent.array_type? && parent.loc.begin && parent.loc.end
         end
 
-        def unneeded_brackets?(node)
+        def redundant_brackets?(node)
           parent = node.parent
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent&.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
         include Interpolation
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -50,7 +50,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
                 corrector.remove(with_index_range(send))
@@ -63,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -51,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -42,9 +42,9 @@ module RuboCop
 
             method_chain = method_chain(node)
             location =
-              Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                        safe_nav.loc.expression.end_pos,
-                                        method_chain.loc.expression.end_pos)
+              Parser::Source::Range.new(node.source_range.source_buffer,
+                                        safe_nav.source_range.end_pos,
+                                        method_chain.source_range.end_pos)
             add_offense(node, location: location)
           end
         end
@@ -54,9 +54,8 @@ module RuboCop
         def method_chain(node)
           chain = node
           while chain.send_type?
-            chain = chain.parent if chain.parent &&
-                                    %i[send csend].include?(chain.parent.type)
-            break
+            chain = chain.parent if chain.parent&.call_type?
+            break # FIXME: Unconditional break. Why while "loop" then?
           end
           chain
         end

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop 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
+      #
+      class SendWithMixinArgument < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
+        MIXIN_METHODS = %i[include prepend extend].freeze
+
+        def_node_matcher :send_with_mixin_argument?, <<~PATTERN
+          (send
+            (const _ _) {:send :public_send :__send__}
+            ({sym str} $#mixin_method?)
+              $(const _ _))
+        PATTERN
+
+        def on_send(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            message = message(
+              method, module_name.source, bad_location(node).source
+            )
+
+            add_offense(node, location: bad_location(node), message: message)
+          end
+        end
+
+        def autocorrect(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            lambda do |corrector|
+              corrector.replace(
+                bad_location(node), "#{method} #{module_name.source}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def bad_location(node)
+          loc = node.loc
+
+          range_between(loc.selector.begin_pos, loc.expression.end_pos)
+        end
+
+        def message(method, module_name, bad_method)
+          format(
+            MSG,
+            method: method, module_name: module_name, bad_method: bad_method
+          )
+        end
+
+        def mixin_method?(node)
+          MIXIN_METHODS.include?(node.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/{handle_exceptions.rb → suppressed_exception.rb}

@@ -74,7 +74,7 @@ module RuboCop
       #   rescue
       #     # do nothing but comment
       #   end
-      class HandleExceptions < Cop
+      class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -6,9 +6,7 @@ module RuboCop
       # This cop checks for unused block arguments.
       #
       # @example
-      #
       #   # bad
-      #
       #   do_something do |used, unused|
       #     puts used
       #   end
@@ -21,10 +19,7 @@ module RuboCop
       #     puts :baz
       #   end
       #
-      # @example
-      #
-      #   #good
-      #
+      #   # good
       #   do_something do |used, _unused|
       #     puts used
       #   end
@@ -36,6 +31,27 @@ module RuboCop
       #   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
+      #
       class UnusedBlockArgument < Cop
         include UnusedArgument
 

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -6,20 +6,38 @@ module RuboCop
       # This cop checks for unused method arguments.
       #
       # @example
-      #
       #   # bad
-      #
       #   def some_method(used, unused, _unused_but_allowed)
       #     puts used
       #   end
       #
-      # @example
-      #
       #   # 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
+      #
       class UnusedMethodArgument < Cop
         include UnusedArgument
 

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -9,23 +9,64 @@ module RuboCop
       # always being defined, and thus access modifiers guarding such methods
       # are not redundant.
       #
-      # @example
+      # 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
       #
-      #     private # this is not redundant (a method is defined)
-      #     def method2
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     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
       #
-      # @example
+      #   # 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)
@@ -35,31 +76,22 @@ module RuboCop
       #       def method
       #       end
       #     end
+      #   end
       #
-      #     protected # this is not redundant (method is defined)
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
       #
       #     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
-      #
-      #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
-      #
-      #     def self.method3
-      #     end
       #   end
       #
-      # @example
+      # @example ContextCreatingMethods: concerning
       #   # Lint/UselessAccessModifier:
       #   #   ContextCreatingMethods:
       #   #     - concerning
+      #
+      #   # good
       #   require 'active_support/concern'
       #   class Foo
       #     concerning :Bar do
@@ -79,10 +111,12 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
+      # @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
@@ -141,7 +175,7 @@ module RuboCop
 
         def access_modifier?(node)
           node.bare_access_modifier? ||
-            node.method_name == :private_class_method
+            node.method?(:private_class_method)
         end
 
         def check_scope(node)
@@ -169,7 +203,7 @@ module RuboCop
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
-          elsif node.method_name == :private_class_method && !node.arguments?
+          elsif node.method?(:private_class_method) && !node.arguments?
             add_offense(node, message: format(MSG, current: node.method_name))
             [cur_vis, unused]
           end