rubocop 0.85.1 → 0.89.0

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

@@ -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,35 +63,88 @@ 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? :Dir) :glob ...)
+          (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
-          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+          (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

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,61 @@
+# 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.'
+
+        def on_new_investigation
+          @valid_ref = 0
+        end
+
+        def on_regexp(node)
+          @valid_ref = nil
+          return if contain_non_literal?(node)
+
+          tree = Regexp::Parser.parse(node.content)
+          @valid_ref = regexp_captures(tree)
+        end
+
+        def on_nth_ref(node)
+          backref, = *node
+          return if @valid_ref.nil?
+
+          add_offense(node) if backref > @valid_ref
+        end
+
+        private
+
+        def contain_non_literal?(node)
+          node.children.size != 2 || !node.children.first.str_type?
+        end
+
+        def regexp_captures(tree)
+          named_capture = numbered_capture = 0
+          tree.each_expression do |e|
+            if e.type?(:group)
+              e.respond_to?(:name) ? named_capture += 1 : numbered_capture += 1
+            end
+          end
+          named_capture.positive? ? named_capture : numbered_capture
+        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
 
@@ -48,17 +42,22 @@ module RuboCop
             return true
           end
 
-          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+          node.operator_method? || node.setter_method? || chained_calls?(node) ||
+            operator_keyword?(node)
         end
 
         def first_argument_starts_with_left_parenthesis?(node)
           node.first_argument.source.start_with?('(')
         end
 
-        def grouped_parentheses?(node)
+        def chained_calls?(node)
           first_argument = node.first_argument
+          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+        end
 
-          first_argument.send_type? && first_argument.receiver&.begin_type?
+        def operator_keyword?(node)
+          first_argument = node.first_argument
+          first_argument.operator_keyword?
         end
 
         def spaces_before_left_parenthesis(node)

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,24 +38,24 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_quotes_or_commas?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            node.each_value do |value|
-              range = value.loc.expression
+        private
+
+        def autocorrect(corrector, node)
+          node.each_value do |value|
+            range = value.loc.expression
 
-              match = range.source.match(TRAILING_QUOTE)
-              corrector.remove_trailing(range, match[0].length) if match
+            match = range.source.match(TRAILING_QUOTE)
+            corrector.remove_trailing(range, match[0].length) if match
 
-              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
-            end
+            corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
           end
         end
 
-        private
-
         def contains_quotes_or_commas?(node)
           node.values.any? do |value|
             literal = value.children.first.to_s.scrub
@@ -62,7 +63,7 @@ module RuboCop
             # To avoid likely false positives (e.g. a single ' or ")
             next if literal.gsub(/[^[[:alnum:]]]/, '').empty?
 
-            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+            QUOTES_AND_COMMAS.any? { |pat| literal.match?(pat) }
           end
         end
       end

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
@@ -61,7 +62,7 @@ module RuboCop
         end
 
         def non_alphanumeric_literal?(literal)
-          literal !~ /[[:alnum:]]/
+          !/[[:alnum:]]/.match?(literal)
         end
       end
     end