rubocop 0.87.0 → 0.90.0

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

@@ -35,7 +35,25 @@ module RuboCop
       #     require file
       #   end
       #
-      class NonDeterministicRequireOrder < Cop
+      # @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))
+      #
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
@@ -45,29 +63,68 @@ 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
 
-        def autocorrect(node)
-          if unsorted_dir_block?(node)
-            lambda do |corrector|
-              corrector.replace(node, "#{node.source}.sort.each")
-            end
-          else
-            lambda do |corrector|
-              source = node.receiver.source
-              corrector.replace(node, "#{source}.sort.each")
+        def on_block_pass(node)
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(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
 
         private
 
+        def correct_block(corrector, node)
+          if unsorted_dir_block?(node)
+            corrector.replace(node, "#{node.source}.sort.each")
+          else
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
+          end
+        end
+
+        def correct_block_pass(corrector, node)
+          if unsorted_dir_glob_pass?(node)
+            block_arg = node.arguments.last
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+          else
+            corrector.replace(node.loc.selector, 'sort.each')
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.arguments.last.source_range.with(
+            begin_pos: node.arguments[-2].source_range.end_pos
+          )
+        end
+
         def unsorted_dir_loop?(node)
           unsorted_dir_block?(node) || unsorted_dir_each?(node)
         end
 
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
@@ -76,6 +133,20 @@ module RuboCop
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym :require)))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN

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)",
@@ -49,14 +51,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,80 @@
+# 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
+
+        def on_new_investigation
+          @valid_ref = 0
+        end
+
+        def on_match_with_lvasgn(node)
+          check_regexp(node.children.first)
+        end
+
+        def on_send(node)
+          return unless REGEXP_CAPTURE_METHODS.include?(node.method_name)
+
+          @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,7 +27,9 @@ module RuboCop
       #       raise Exception # This exception means `Gem::Exception`.
       #     end
       #   end
-      class RaiseException < Cop
+      class RaiseException < Base
+        extend AutoCorrector
+
         MSG = 'Use `StandardError` over `Exception`.'
 
         def_node_matcher :exception?, <<~PATTERN
@@ -44,21 +46,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