rubocop 1.6.1 → 1.9.1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks uses of lambda without a literal block.
+      # It emulates the following warning in Ruby 3.0:
+      #
+      #   % ruby -vwe 'lambda(&proc {})'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: warning: lambda without a literal block is deprecated; use the proc without
+      #   lambda instead
+      #
+      # This way, proc object is never converted to lambda.
+      # Auto-correction replaces with compatible proc argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   lambda(&proc { do_something })
+      #   lambda(&Proc.new { do_something })
+      #
+      #   # good
+      #   proc { do_something }
+      #   Proc.new { do_something }
+      #   lambda { do_something } # If you use lambda.
+      #
+      class LambdaWithoutLiteralBlock < Base
+        extend AutoCorrector
+
+        MSG = 'lambda without a literal block is deprecated; use the proc without lambda instead.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
+
+        def on_send(node)
+          return if node.parent&.block_type? || !node.first_argument
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, node.first_argument.source.delete('&'))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,11 @@ module RuboCop
       # that are hard to debug. To ensure this doesn't happen,
       # always sort the list.
       #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
       # @example
       #
       #   # bad
@@ -23,8 +28,6 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
       #     require file
@@ -35,28 +38,28 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir['./lib/**/*.rb'].each(&method(:require))
       #
       #   # good
       #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
       #
       #   # good
       #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
       #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
       class NonDeterministicRequireOrder < Base
         extend AutoCorrector
 
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
+          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -70,6 +73,7 @@ module RuboCop
         end
 
         def on_block_pass(node)
+          return if target_ruby_version >= 3.0
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 

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

@@ -25,12 +25,18 @@ module RuboCop
       #   '10'.to_i
       #   '10.2'.to_f
       #   '10'.to_c
+      #   ['1', '2', '3'].map(&:to_i)
+      #   foo.try(:to_f)
+      #   bar.send(:to_c)
       #
       #   # good
       #
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #   ['1', '2', '3'].map { |i| Integer(i, 10) }
+      #   foo.try { |i| Float(i) }
+      #   bar.send { |i| Complex(i) }
       #
       # @example IgnoredMethods: [minutes]
       #
@@ -52,22 +58,33 @@ module RuboCop
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
-              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<current>s, use stricter '\
               '%<corrected_method>s.'
-        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
+        METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
         def_node_matcher :to_method, <<~PATTERN
-          (send $_ ${:to_i :to_f :to_c})
+          (send $_ ${#{METHODS}})
+        PATTERN
+
+        def_node_matcher :to_method_symbol, <<~PATTERN
+          {(send _ $_ ${(sym ${#{METHODS}})} ...)
+           (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
         PATTERN
 
         def on_send(node)
+          handle_conversion_method(node)
+          handle_as_symbol(node)
+        end
+
+        private
+
+        def handle_conversion_method(node)
           to_method(node) do |receiver, to_method|
             next if receiver.nil? || ignore_receiver?(receiver)
 
             message = format(
               MSG,
-              number_object: receiver.source,
-              to_method: to_method,
+              current: "#{receiver.source}.#{to_method}",
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
@@ -76,13 +93,31 @@ module RuboCop
           end
         end
 
-        private
+        def handle_as_symbol(node)
+          to_method_symbol(node) do |receiver, sym_node, to_method|
+            next if receiver.nil?
+
+            message = format(
+              MSG,
+              current: sym_node.source,
+              corrected_method: correct_sym_method(to_method)
+            )
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(sym_node, correct_sym_method(to_method))
+            end
+          end
+        end
 
         def correct_method(node, receiver)
           format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
                  number_object: receiver.source)
         end
 
+        def correct_sym_method(to_method)
+          body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
+          "{ |i| #{body} }"
+        end
+
         def ignore_receiver?(receiver)
           if receiver.send_type? && ignored_method?(receiver.method_name)
             true

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of numbered parameter assignment.
+      # It emulates the following warning in Ruby 2.7:
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
+      #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
+      #
+      # Assiging to numbered parameter (from `_1` to `_9`) cause an error in Ruby 3.0.
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: _1 is reserved for numbered parameter
+      #
+      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # as well to prevent confusion.
+      #
+      # @example
+      #
+      #   # bad
+      #   _1 = :value
+      #
+      #   # good
+      #   non_numbered_parameter_name = :value
+      #
+      class NumberedParameterAssignment < Base
+        NUM_PARAM_MSG = '`_%<number>s` is reserved for numbered parameter; consider another name.'
+        LVAR_MSG = '`_%<number>s` is similar to numbered parameter; consider another name.'
+        NUMBERED_PARAMETER_RANGE = (1..9).freeze
+
+        def on_lvasgn(node)
+          lhs, _rhs = *node
+          return unless /\A_(\d+)\z/ =~ lhs
+
+          number = Regexp.last_match(1).to_i
+          template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG
+
+          add_offense(node, message: format(template, number: number))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unintended or-assignment to a constant.
+      #
+      # Constants should always be assigned in the same location. And its value
+      # should always be the same. If constants are assigned in multiple
+      # locations, the result may vary depending on the order of `require`.
+      #
+      # Also, if you already have such an implementation, auto-correction may
+      # change the result.
+      #
+      # @example
+      #
+      #   # bad
+      #   CONST ||= 1
+      #
+      #   # good
+      #   CONST = 1
+      #
+      class OrAssignmentToConstant < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid using or-assignment with constants.'
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          return unless lhs&.casgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -61,7 +61,8 @@ module RuboCop
         end
 
         def comment_range_with_surrounding_space(range)
-          if previous_line_blank?(range)
+          if previous_line_blank?(range) &&
+             processed_source.comment_config.comment_only_line?(range.line)
             # When the previous line is blank, it should be retained
             range_with_surrounding_space(range: range, side: :right)
           else

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

@@ -0,0 +1,50 @@
+# 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[]`.
+      #
+      # @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)
+
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,47 +8,66 @@ module RuboCop
       # @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
+      #
+      # @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
 
@@ -75,6 +94,9 @@ module RuboCop
           redundant_splat_expansion(node) do
             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
@@ -170,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