rubocop 0.88.0 → 0.91.1

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

@@ -54,7 +54,7 @@ module RuboCop
       #       end
       #     end
       #   end
-      class NestedMethodDefinition < Cop
+      class NestedMethodDefinition < Base
         MSG = 'Method definitions must not be nested. ' \
               'Use `lambda` instead.'
 

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

@@ -15,7 +15,7 @@ module RuboCop
       #     valid_attributes: %i[name content],
       #     nested_attributes: %i[name content %i[incorrectly nested]]
       #   }
-      class NestedPercentLiteral < Cop
+      class NestedPercentLiteral < Base
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \

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

@@ -22,7 +22,7 @@ module RuboCop
       #     next acc if i.odd?
       #     acc + i
       #   end
-      class NextWithoutAccumulator < Cop
+      class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
         def_node_matcher :on_body_of_reduce, <<~PATTERN

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

@@ -51,7 +51,9 @@ module RuboCop
       #   # good
       #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
       #
-      class NonDeterministicRequireOrder < Cop
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
@@ -61,7 +63,9 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node)
+            add_offense(node.send_node) do |corrector|
+              correct_block(corrector, node.send_node)
+            end
           end
         end
 
@@ -69,37 +73,37 @@ module RuboCop
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 
-          add_offense(node.parent)
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.arguments.last&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
+            end
+          end
         end
 
-        def autocorrect(node)
-          return correct_block_pass(node) if node.arguments.last&.block_pass_type?
+        private
 
+        def correct_block(corrector, node)
           if unsorted_dir_block?(node)
-            lambda do |corrector|
-              corrector.replace(node, "#{node.source}.sort.each")
-            end
+            corrector.replace(node, "#{node.source}.sort.each")
           else
-            lambda do |corrector|
-              source = node.receiver.source
-              corrector.replace(node, "#{source}.sort.each")
-            end
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
           end
         end
 
-        private
-
-        def correct_block_pass(node)
+        def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            lambda do |corrector|
-              block_arg = node.arguments.last
-              corrector.remove(last_arg_range(node))
-              corrector.insert_after(node, ".sort.each(#{block_arg.source})")
-            end
+            block_arg = node.arguments.last
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
           else
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, 'sort.each')
-            end
+            corrector.replace(node.loc.selector, 'sort.each')
           end
         end
 

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

@@ -38,7 +38,7 @@ module RuboCop
       #     end
       #   end
       #
-      class NonLocalExitFromIterator < Cop
+      class NonLocalExitFromIterator < Base
         MSG = 'Non-local exit from iterator, without return value. ' \
               '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
               'is preferred.'
@@ -57,7 +57,7 @@ module RuboCop
             next unless node.arguments?
 
             if chained_send?(node.send_node)
-              add_offense(return_node, location: :keyword)
+              add_offense(return_node.loc.keyword)
               break
             end
           end

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

@@ -20,7 +20,9 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
-      class NumberConversion < Cop
+      class NumberConversion < Base
+        extend AutoCorrector
+
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
           to_f: "#{Float.name}(%<number_object>s)",
@@ -30,6 +32,7 @@ module RuboCop
               'class parsing, instead of using '\
               '%<number_object>s.%<to_method>s, use stricter '\
               '%<corrected_method>s.'
+        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
 
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${:to_i :to_f :to_c})
@@ -49,14 +52,9 @@ module RuboCop
               to_method: to_method,
               corrected_method: correct_method(node, receiver)
             )
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node,
-                              correct_method(node, node.receiver))
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, correct_method(node, node.receiver))
+            end
           end
         end
 

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

@@ -27,13 +27,14 @@ module RuboCop
       #   # frozen_string_literal: true
       #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
       #
-      class OrderedMagicComments < Cop
+      class OrderedMagicComments < Base
         include FrozenStringLiteral
+        extend AutoCorrector
 
         MSG = 'The encoding magic comment should precede all other ' \
               'magic comments.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.buffer.source.empty?
 
           encoding_line, frozen_string_literal_line = magic_comment_lines
@@ -43,24 +44,21 @@ module RuboCop
 
           range = processed_source.buffer.line_range(encoding_line + 1)
 
-          add_offense(range, location: range)
+          add_offense(range) do |corrector|
+            autocorrect(corrector, encoding_line, frozen_string_literal_line)
+          end
         end
 
-        def autocorrect(_node)
-          encoding_line, frozen_string_literal_line = magic_comment_lines
+        private
 
+        def autocorrect(corrector, encoding_line, frozen_string_literal_line)
           range1 = processed_source.buffer.line_range(encoding_line + 1)
-          range2 =
-            processed_source.buffer.line_range(frozen_string_literal_line + 1)
+          range2 = processed_source.buffer.line_range(frozen_string_literal_line + 1)
 
-          lambda do |corrector|
-            corrector.replace(range1, range2.source)
-            corrector.replace(range2, range1.source)
-          end
+          corrector.replace(range1, range2.source)
+          corrector.replace(range2, range1.source)
         end
 
-        private
-
         def magic_comment_lines
           lines = [nil, nil]
 

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cops looks for references of Regexp captures that are out of range
+      # and thus always returns nil.
+      #
+      # @example
+      #
+      #   /(foo)bar/ =~ 'foobar'
+      #
+      #   # bad - always returns nil
+      #
+      #   puts $2 # => nil
+      #
+      #   # good
+      #
+      #   puts $1 # => foo
+      #
+      class OutOfRangeRegexpRef < Base
+        MSG = 'Do not use out of range reference for the Regexp.'
+
+        REGEXP_RECEIVER_METHODS = %i[=~ === match].to_set.freeze
+        REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
+                                     scan partition rpartition start_with? end_with?].to_set.freeze
+        REGEXP_CAPTURE_METHODS = (REGEXP_RECEIVER_METHODS + REGEXP_ARGUMENT_METHODS).freeze
+        RESTRICT_ON_SEND = REGEXP_CAPTURE_METHODS
+
+        def on_new_investigation
+          @valid_ref = 0
+        end
+
+        def on_match_with_lvasgn(node)
+          check_regexp(node.children.first)
+        end
+
+        def on_send(node)
+          @valid_ref = nil
+
+          if node.receiver&.regexp_type?
+            check_regexp(node.receiver)
+          elsif node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(node.method_name)
+            check_regexp(node.first_argument)
+          end
+        end
+
+        def on_when(node)
+          regexp_conditions = node.conditions.select(&:regexp_type?)
+
+          @valid_ref = regexp_conditions.map do |condition|
+            check_regexp(condition)
+          end.compact.max
+        end
+
+        def on_nth_ref(node)
+          backref, = *node
+          return if @valid_ref.nil?
+
+          add_offense(node) if backref > @valid_ref
+        end
+
+        private
+
+        def check_regexp(node)
+          return if node.interpolation?
+
+          named_capture = node.each_capture(named: true).count
+          @valid_ref = if named_capture.positive?
+                         named_capture
+                       else
+                         node.each_capture(named: false).count
+                       end
+        end
+      end
+    end
+  end
+end

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

@@ -15,8 +15,9 @@ module RuboCop
       #   do_something(foo)
       #   do_something (2 + 3) * 4
       #   do_something (foo * bar).baz
-      class ParenthesesAsGroupedExpression < Cop
+      class ParenthesesAsGroupedExpression < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`(...)` interpreted as grouped expression.'
 
@@ -28,18 +29,11 @@ module RuboCop
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(node, location: range)
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          space_length = spaces_before_left_parenthesis(node)
-          range = space_range(node.first_argument.source_range, space_length)
-
-          lambda do |corrector|
+          add_offense(range) do |corrector|
             corrector.remove(range)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -20,8 +20,9 @@ module RuboCop
       #   # good
       #
       #   %w(foo bar)
-      class PercentStringArray < Cop
+      class PercentStringArray < Base
         include PercentLiteral
+        extend AutoCorrector
 
         QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
         LEADING_QUOTE = /^['"]/.freeze
@@ -37,11 +38,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_quotes_or_commas?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             node.each_value do |value|
               range = value.loc.expression
 

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

@@ -20,8 +20,9 @@ module RuboCop
       #   # good
       #
       #   %i(foo bar)
-      class PercentSymbolArray < Cop
+      class PercentSymbolArray < Base
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
           'unwanted in the resulting symbols.'
@@ -33,23 +34,23 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
+        private
+
+        def autocorrect(corrector, node)
+          node.children.each do |child|
+            range = child.loc.expression
 
-              corrector.remove_trailing(range, 1) if range.source.end_with?(',')
-              corrector.remove_leading(range, 1) if
-                range.source.start_with?(':')
-            end
+            corrector.remove_trailing(range, 1) if range.source.end_with?(',')
+            corrector.remove_leading(range, 1) if
+              range.source.start_with?(':')
           end
         end
 
-        private
-
         def contains_colons_or_commas?(node)
           node.children.any? do |child|
             literal = child.children.first.to_s

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

@@ -27,8 +27,11 @@ module RuboCop
       #       raise Exception # This exception means `Gem::Exception`.
       #     end
       #   end
-      class RaiseException < Cop
+      class RaiseException < Base
+        extend AutoCorrector
+
         MSG = 'Use `StandardError` over `Exception`.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
@@ -44,21 +47,21 @@ module RuboCop
             exception_new_with_message?(node, &check(node))
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            exception_class = node.children.first&.cbase_type? ? '::StandardError' : 'StandardError'
-
-            corrector.replace(node, exception_class)
-          end
-        end
-
         private
 
         def check(node)
           lambda do |exception_class, cbase|
             return if cbase.nil? && implicit_namespace?(node)
 
-            add_offense(exception_class)
+            add_offense(exception_class) do |corrector|
+              prefer_exception = if exception_class.children.first&.cbase_type?
+                                   '::StandardError'
+                                 else
+                                   'StandardError'
+                                 end
+
+              corrector.replace(exception_class, prefer_exception)
+            end
           end
         end
 

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

@@ -20,9 +20,10 @@ module RuboCop
       #   # good
       #
       #   0 # just use 0 instead
-      class RandOne < Cop
+      class RandOne < Base
         MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'
+        RESTRICT_ON_SEND = %i[rand].freeze
 
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})