rubocop 0.73.0 → 0.77.0

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def correct_visibility?(node, modifier, ignored_methods)
-          return true if modifier.nil? || modifier.method_name == :public
+          return true if modifier.nil? || modifier.method?(:public)
 
           ignored_methods.include?(node.method_name)
         end

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

@@ -17,21 +17,20 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
+        include Interpolation
         include RangeHelp
         include PercentLiteral
 
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
 
-            add_offense(final_node)
-          end
+          add_offense(final_node)
         end
 
         def autocorrect(node)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -81,4 +81,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

data/lib/rubocop/cop/lint/{multiple_compare.rb → multiple_comparison.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
+      class MultipleComparison < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN

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

@@ -41,7 +41,7 @@ module RuboCop
 
         def on_send(node)
           to_method(node) do |receiver, to_method|
-            next if date_time_object?(receiver)
+            next if receiver.nil? || date_time_object?(receiver)
 
             message = format(
               MSG,

data/lib/rubocop/cop/lint/{unneeded_cop_disable_directive.rb → redundant_cop_disable_directive.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-# The Lint/UnneededCopDisableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded disable.
-# rubocop:disable Lint/UnneededCopDisableDirective
+# The Lint/RedundantCopDisableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of a redundant disable.
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -25,21 +25,21 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class UnneededCopDisableDirective < Cop
+      class RedundantCopDisableDirective < Cop
         include NameSimilarity
         include RangeHelp
 
-        COP_NAME = 'Lint/UnneededCopDisableDirective'
+        COP_NAME = 'Lint/RedundantCopDisableDirective'
 
         def check(offenses, cop_disabled_line_ranges, comments)
-          unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
+          redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
-          each_unneeded_disable(cop_disabled_line_ranges,
-                                offenses, comments) do |comment, unneeded_cop|
-            unneeded_cops[comment].add(unneeded_cop)
+          each_redundant_disable(cop_disabled_line_ranges,
+                                 offenses, comments) do |comment, redundant_cop|
+            redundant_cops[comment].add(redundant_cop)
           end
 
-          add_offenses(unneeded_cops)
+          add_offenses(redundant_cops)
         end
 
         def autocorrect(args)
@@ -89,8 +89,8 @@ module RuboCop
                                        newlines: false)
         end
 
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
-                                  &block)
+        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+                                   &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
@@ -110,9 +110,9 @@ module RuboCop
             comment = comments.find { |c| c.loc.line == line_range.begin }
             next if ignore_offense?(disabled_ranges, line_range)
 
-            unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
-                                         line_ranges[ix + 1])
-            yield comment, unneeded_cop if unneeded_cop
+            redundant_cop = find_redundant(comment, offenses, cop, line_range,
+                                           line_ranges[ix + 1])
+            yield comment, redundant_cop if redundant_cop
           end
         end
 
@@ -123,24 +123,24 @@ module RuboCop
 
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
-            # already disabled by an earlier comment. So it's unneeded
+            # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            unneeded_comment = comments.find do |c|
+            redundant_comment = comments.find do |c|
               c.loc.line == range.begin &&
                 # Comments disabling all cops don't count since it's reasonable
                 # to disable a few select cops first and then all cops further
                 # down in the code.
                 !all_disabled?(c)
             end
-            yield unneeded_comment if unneeded_comment
+            yield redundant_comment if redundant_comment
           end
         end
 
-        def find_unneeded(comment, offenses, cop, line_range, next_line_range)
+        def find_redundant(comment, offenses, cop, line_range, next_line_range)
           if all_disabled?(comment)
             # If there's a disable all comment followed by a comment
             # specifically disabling `cop`, we don't report the `all`
-            # comment. If the disable all comment is truly unneeded, we will
+            # comment. If the disable all comment is truly redundant, we will
             # detect that when examining the comments of another cop, and we
             # get the full line range for the disable all.
             if (next_line_range.nil? ||
@@ -155,7 +155,7 @@ module RuboCop
         end
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*disable\s+all\b/
+          comment.text =~ /rubocop\s*:\s*(?:disable|todo)\s+all\b/
         end
 
         def ignore_offense?(disabled_ranges, line_range)
@@ -170,8 +170,8 @@ module RuboCop
           cops_string.split(/,\s*/).size
         end
 
-        def add_offenses(unneeded_cops)
-          unneeded_cops.each do |comment, cops|
+        def add_offenses(redundant_cops)
+          redundant_cops.each do |comment, cops|
             if all_disabled?(comment) ||
                directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
@@ -260,4 +260,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective
+# rubocop:enable Lint/RedundantCopDisableDirective

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
@@ -32,7 +32,7 @@ module RuboCop
       #   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'
@@ -58,14 +58,19 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :array_new?, '$(send (const nil? :Array) :new ...)'
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const nil? :Array) :new ...)
+            $(block (send (const nil? :Array) :new ...) ...)
+          }
+        PATTERN
 
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         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)
@@ -85,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)
@@ -114,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, '']
@@ -136,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,21 +17,21 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
+        include Interpolation
+
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'
 
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
 
-            next unless to_s_without_args?(final_node)
+          return unless to_s_without_args?(final_node)
 
-            add_offense(final_node, location: :selector)
-          end
+          add_offense(final_node, location: :selector)
         end
 
         def autocorrect(node)

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