rubocop 0.76.0 → 1.50.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Sort globbed results by default in Ruby 3.0.
+      # This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`.
+      #
+      # @safety
+      #   This cop is unsafe, in case of having a file and a directory with
+      #   identical names, since directory will be loaded before the file, which
+      #   will break `exe/files.rb` that rely on `exe.rb` file.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob('./lib/**/*.rb').sort.each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].sort.each do |file|
+      #   end
+      #
+      #   # good
+      #   Dir.glob('./lib/**/*.rb').each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].each do |file|
+      #   end
+      #
+      class RedundantDirGlobSort < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Remove redundant `sort`.'
+        RESTRICT_ON_SEND = %i[sort].freeze
+        GLOB_METHODS = %i[glob []].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver)
+          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
+          return unless GLOB_METHODS.include?(receiver.method_name)
+          return if multiple_argument?(receiver)
+
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        private
+
+        def multiple_argument?(glob_method)
+          glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
+        end
+      end
+    end
+  end
+end

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

@@ -6,13 +6,23 @@ module RuboCop
       # Checks for unnecessary `require` statement.
       #
       # The following features are unnecessary `require` statement because
-      # they are already loaded.
+      # they are already loaded. e.g. Ruby 2.2:
       #
-      # ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
-      # ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
-      # ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
+      #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
+      #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
+      #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
-      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      # Below are the features that each `TargetRubyVersion` targets.
+      #
+      #   * 2.0+ ... `enumerator`
+      #   * 2.1+ ... `thread`
+      #   * 2.2+ ... Add `rational` and `complex` above
+      #   * 2.5+ ... Add `pp` above
+      #   * 2.7+ ... Add `ruby2_keywords` above
+      #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
+      #
+      # This cop target those features.
       #
       # @example
       #   # bad
@@ -21,29 +31,59 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class RedundantRequireStatement < Cop
+      class RedundantRequireStatement < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
+        RESTRICT_ON_SEND = %i[require].freeze
+        RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
+        PRETTY_PRINT_METHODS = %i[
+          pretty_inspect pretty_print pretty_print_cycle
+          pretty_print_inspect pretty_print_instance_variables
+        ].freeze
 
-        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+        # @!method redundant_require_statement?(node)
+        def_node_matcher :redundant_require_statement?, <<~PATTERN
           (send nil? :require
-            (str {"enumerator" "rational" "complex" "thread"}))
+            (str #redundant_feature?))
         PATTERN
 
         def on_send(node)
-          return unless unnecessary_require_statement?(node)
+          return unless redundant_require_statement?(node)
 
-          add_offense(node)
-        end
+          add_offense(node) do |corrector|
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.source_range, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression,
-                                                 side: :right)
             corrector.remove(range)
           end
         end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_feature?(feature_name)
+          feature_name == 'enumerator' ||
+            (target_ruby_version >= 2.1 && feature_name == 'thread') ||
+            (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
+            (target_ruby_version >= 2.5 && feature_name == 'pp' && !use_pretty_print_method?) ||
+            (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
+            (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
+            (target_ruby_version >= 3.2 && feature_name == 'set')
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def use_pretty_print_method?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            PRETTY_PRINT_METHODS.include?(node.method_name)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant safe navigation calls.
+      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
+      # are checked by default. These are customizable with `AllowedMethods` option.
+      #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
+      #
+      # In the example below, the safe navigation operator (`&.`) is unnecessary
+      # because `NilClass` has methods like `respond_to?` and `is_a?`.
+      #
+      # @safety
+      #   This cop is unsafe, because autocorrection can change the return type of
+      #   the expression. An offending expression that previously could return `nil`
+      #   will be autocorrected to never return `nil`.
+      #
+      # @example
+      #   # bad
+      #   do_something if attrs&.respond_to?(:[])
+      #
+      #   # good
+      #   do_something if attrs.respond_to?(:[])
+      #
+      #   # bad
+      #   while node&.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good
+      #   while node.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good - without `&.` this will always return `true`
+      #   foo&.respond_to?(:to_a)
+      #
+      # @example AllowedMethods: [nil_safe_method]
+      #   # bad
+      #   do_something if attrs&.nil_safe_method(:[])
+      #
+      #   # good
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
+      #
+      class RedundantSafeNavigation < Base
+        include AllowedMethods
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant safe navigation detected.'
+
+        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+
+        # @!method respond_to_nil_specific_method?(node)
+        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        PATTERN
+
+        def on_csend(node)
+          return unless check?(node) && allowed_method?(node.method_name)
+          return if respond_to_nil_specific_method?(node)
+
+          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
+        end
+
+        private
+
+        def check?(node)
+          parent = node.parent
+          return false unless parent
+
+          condition?(parent, node) ||
+            parent.and_type? ||
+            parent.or_type? ||
+            (parent.send_type? && parent.negation_method?)
+        end
+
+        def condition?(parent, node)
+          (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
+        end
+      end
+    end
+  end
+end

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

@@ -3,53 +3,74 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unneeded usages of splat expansion
+      # Checks for unneeded usages of splat expansion
       #
       # @example
       #
       #   # bad
-      #
       #   a = *[1, 2, 3]
       #   a = *'a'
       #   a = *1
-      #
-      #   begin
-      #     foo
-      #   rescue *[StandardError, ApplicationError]
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      #
-      # @example
+      #   ['a', 'b', *%w(c d e), 'f', 'g']
       #
       #   # good
-      #
       #   c = [1, 2, 3]
       #   a = *c
       #   a, b = *c
       #   a, *b = *c
       #   a = *1..10
       #   a = ['a']
+      #   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+      #
+      #   # bad
+      #   do_something(*['foo', 'bar', 'baz'])
+      #
+      #   # good
+      #   do_something('foo', 'bar', 'baz')
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
       #
+      #   # good
       #   begin
       #     foo
       #   rescue StandardError, ApplicationError
       #     bar
       #   end
       #
+      #   # bad
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
       #   case foo
       #   when 1, 2, 3
       #     bar
       #   else
       #     baz
       #   end
-      class RedundantSplatExpansion < Cop
+      #
+      # @example AllowPercentLiteralArrayArgument: true (default)
+      #
+      #   # good
+      #   do_something(*%w[foo bar baz])
+      #
+      # @example AllowPercentLiteralArrayArgument: false
+      #
+      #   # bad
+      #   do_something(*%w[foo bar baz])
+      #
+      class RedundantSplatExpansion < Base
+        extend AutoCorrector
+
         MSG = 'Replace splat expansion with comma separated values.'
         ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
         PERCENT_W = '%w'
@@ -58,46 +79,49 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
+        # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
           {
-            $(send (const nil? :Array) :new ...)
-            $(block (send (const nil? :Array) :new ...) ...)
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
           }
         PATTERN
 
+        # @!method literal_expansion(node)
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
 
         def on_splat(node)
           redundant_splat_expansion(node) do
-            if array_splat?(node) &&
-               (method_argument?(node) || part_of_an_array?(node))
-              add_offense(node, message: ARRAY_PARAM_MSG)
+            if array_splat?(node) && (method_argument?(node) || part_of_an_array?(node))
+              return if allow_percent_literal_array_argument? &&
+                        use_percent_literal_array_argument?(node)
+
+              add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
             else
-              add_offense(node)
+              add_offense(node) { |corrector| autocorrect(corrector, node) }
             end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           range, content = replacement_range_and_content(node)
 
-          lambda do |corrector|
-            corrector.replace(range, content)
-          end
+          corrector.replace(range, content)
         end
 
-        private
-
         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)
 
               grandparent = node.parent.parent
-              return if grandparent &&
-                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
             end
 
             yield
@@ -114,13 +138,15 @@ module RuboCop
         def replacement_range_and_content(node)
           variable, = *node
           loc = node.loc
+          expression = loc.expression
 
           if array_new?(variable)
-            [node.parent.loc.expression, variable.source]
+            expression = node.parent.source_range if node.parent.array_type?
+            [expression, variable.source]
           elsif !variable.array_type?
-            [loc.expression, "[#{variable.source}]"]
+            [expression, "[#{variable.source}]"]
           elsif redundant_brackets?(node)
-            [loc.expression, remove_brackets(variable)]
+            [expression, remove_brackets(variable)]
           else
             [loc.operator, '']
           end
@@ -146,7 +172,7 @@ module RuboCop
           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)
@@ -166,6 +192,17 @@ module RuboCop
             elements.join(', ')
           end
         end
+
+        def use_percent_literal_array_argument?(node)
+          argument = node.children.first
+
+          node.parent.send_type? &&
+            (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
+        end
+
+        def allow_percent_literal_array_argument?
+          cop_config.fetch('AllowPercentLiteralArrayArgument', true)
+        end
       end
     end
   end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments,
+      # which is redundant.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{something.to_s}"
+      #   print something.to_s
+      #   puts something.to_s
+      #   warn something.to_s
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{something}"
+      #   print something
+      #   puts something
+      #   warn something
+      #
+      class RedundantStringCoercion < Base
+        include Interpolation
+        extend AutoCorrector
+
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in %<context>s.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in %<context>s.'
+        RESTRICT_ON_SEND = %i[print puts warn].freeze
+
+        # @!method to_s_without_args?(node)
+        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+
+          return unless to_s_without_args?(final_node)
+
+          register_offense(final_node, 'interpolation')
+        end
+
+        def on_send(node)
+          return if node.receiver
+
+          node.each_child_node(:send) do |child|
+            next unless child.method?(:to_s)
+
+            register_offense(child, "`#{node.method_name}`")
+          end
+        end
+
+        private
+
+        def register_offense(node, context)
+          receiver = node.receiver
+          template = receiver ? MSG_DEFAULT : MSG_SELF
+          message = format(template, context: context)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = receiver ? receiver.source : 'self'
+
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant `with_index`.
+      # Checks for redundant `with_index`.
       #
       # @example
       #   # bad
@@ -26,44 +26,45 @@ module RuboCop
       #     v
       #   end
       #
-      class RedundantWithIndex < Cop
+      class RedundantWithIndex < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        def_node_matcher :redundant_with_index?, <<~PATTERN
-          (block
-            $(send
-              _ {:each_with_index :with_index} ...)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
-          redundant_with_index?(node) do |send|
-            add_offense(node, location: with_index_range(send))
-          end
-        end
+          return unless (send = redundant_with_index?(node))
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
-                corrector.replace(send.loc.selector, 'each')
-              else
-                corrector.remove(with_index_range(send))
-                corrector.remove(send.loc.dot)
-              end
+          range = with_index_range(send)
+
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_index)
+              corrector.replace(send.loc.selector, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
             end
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_index?(node)
+        def_node_matcher :redundant_with_index?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_index :with_index} ...)
+              (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_index :with_index} ...) 1 ...)
+          }
+        PATTERN
+
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX
@@ -71,10 +72,7 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(
-            send.loc.selector.begin_pos,
-            send.loc.expression.end_pos
-          )
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
         end
       end
     end