rubocop 1.8.0 → 1.11.0

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

@@ -80,6 +80,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method erb_new_with_non_keyword_arguments(node)
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)

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

@@ -92,6 +92,7 @@ module RuboCop
           end
         end
 
+        # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
           {(send {nil? const_type?} _ (str _) ...)
            (send (str ...) ...)}

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

@@ -24,6 +24,7 @@ module RuboCop
 
         MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
 
+        # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
           (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN

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

@@ -53,6 +53,7 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'
 
+        # @!method private_class_methods(node)
         def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN

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

@@ -58,6 +58,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method class_new_call?(node)
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new

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

@@ -11,14 +11,10 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   x < y < z
       #   10 <= x <= 20
       #
-      # @example
-      #
       #   # good
-      #
       #   x < y && y < z
       #   10 <= x && x <= 20
       class MultipleComparison < Base
@@ -26,14 +22,19 @@ module RuboCop
 
         MSG = 'Use the `&&` operator to compare multiple values.'
         COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
         RESTRICT_ON_SEND = COMPARISON_METHODS
 
+        # @!method multiple_compare?(node)
         def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)
           return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
 
           add_offense(node) do |corrector|
             new_center = "#{center.source} && #{center.source}"

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

@@ -81,14 +81,17 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
+        # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN

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

@@ -25,6 +25,7 @@ module RuboCop
       class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
+        # @!method on_body_of_reduce(node)
         def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN

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

@@ -129,32 +129,39 @@ module RuboCop
           unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
         end
 
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        # @!method method_require?(node)
         def_node_matcher :method_require?, <<~PATTERN
           (block-pass (send nil? :method (sym :require)))
         PATTERN
 
+        # @!method unsorted_dir_glob_pass?(node)
         def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method unsorted_dir_each_pass?(node)
         def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method loop_variable(node)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
           (send nil? :require (lvar %1))
         PATTERN

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

@@ -73,7 +73,10 @@ module RuboCop
           !return_node.children.empty?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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,35 @@ 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(' ')
 
+        # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
-          (send $_ ${:to_i :to_f :to_c})
+          (send $_ ${#{METHODS}})
+        PATTERN
+
+        # @!method to_method_symbol(node)
+        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 +95,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/raise_exception.rb

@@ -33,10 +33,12 @@ module RuboCop
         MSG = 'Use `StandardError` over `Exception`.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method exception?(node)
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
+        # @!method exception_new_with_message?(node)
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
             (send $(const ${cbase nil?} :Exception) :new ... ))

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

@@ -25,6 +25,7 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'
         RESTRICT_ON_SEND = %i[rand].freeze
 
+        # @!method rand_one?(node)
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN

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

@@ -34,11 +34,13 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver = node.receiver)
-          return unless receiver.receiver.const_type? && receiver.receiver.short_name == :Dir
+          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
           return unless GLOB_METHODS.include?(receiver.method_name)
 
-          add_offense(node.loc.selector) do |corrector|
-            corrector.remove(node.loc.selector)
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(selector)
             corrector.remove(node.loc.dot)
           end
         end

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

@@ -28,6 +28,7 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
 
+        # @!method unnecessary_require_statement?(node)
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
             (str {"enumerator" "rational" "complex" "thread"}))

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

@@ -43,6 +43,7 @@ module RuboCop
 
         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

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

@@ -79,6 +79,7 @@ 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? cbase} :Array) :new ...)
@@ -86,6 +87,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method literal_expansion(node)
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
@@ -140,13 +142,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.loc.expression 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

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'
 
+        # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
         def on_interpolation(begin_node)