rubocop 0.85.1 → 0.89.1

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,90 @@
+# 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(regexp)
+          return if contain_non_literal?(regexp)
+
+          tree = Regexp::Parser.parse(regexp.content)
+          @valid_ref = regexp_captures(tree)
+        end
+
+        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

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

@@ -27,16 +27,18 @@ 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
-          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
+          (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
-            (send (const ${cbase nil?} :Exception) :new ... ))
+            (send $(const ${cbase nil?} :Exception) :new ... ))
         PATTERN
 
         def on_send(node)
@@ -47,10 +49,18 @@ module RuboCop
         private
 
         def check(node)
-          lambda do |cbase|
+          lambda do |exception_class, cbase|
             return if cbase.nil? && implicit_namespace?(node)
 
-            add_offense(node)
+            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,16 +20,16 @@ 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`?'
 
         def_node_matcher :rand_one?, <<~PATTERN
-          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
+          (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
-          return unless rand_one?(node)
+          return unless node.method?(:rand) && rand_one?(node)
 
           add_offense(node)
         end

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

@@ -25,34 +25,33 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class RedundantCopDisableDirective < Cop
+      class RedundantCopDisableDirective < Base
         include RangeHelp
+        extend AutoCorrector
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
 
-        def check(offenses, cop_disabled_line_ranges, comments)
+        attr_accessor :offenses_to_check
+
+        def initialize(config = nil, options = nil, offenses = nil)
+          @offenses_to_check = offenses
+          super(config, options)
+        end
+
+        def on_new_investigation
+          return unless offenses_to_check
+
+          cop_disabled_line_ranges = processed_source.disabled_line_ranges
+
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
           each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses, comments) do |comment, redundant_cop|
+                                 offenses_to_check) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
           add_offenses(redundant_cops)
-        end
-
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
-
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
-
-            corrector.remove(range)
-          end
+          super
         end
 
         private
@@ -88,25 +87,25 @@ module RuboCop
                                        newlines: false)
         end
 
-        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+        def each_redundant_disable(cop_disabled_line_ranges, offenses,
                                    &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
             each_already_disabled(line_ranges,
-                                  disabled_ranges, comments) do |comment|
+                                  disabled_ranges) do |comment|
               yield comment, cop
             end
 
-            each_line_range(line_ranges, disabled_ranges, offenses, comments,
+            each_line_range(line_ranges, disabled_ranges, offenses,
                             cop, &block)
           end
         end
 
-        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
+        def each_line_range(line_ranges, disabled_ranges, offenses,
                             cop)
           line_ranges.each_with_index do |line_range, ix|
-            comment = comments.find { |c| c.loc.line == line_range.begin }
+            comment = processed_source.comment_at_line(line_range.begin)
             next if ignore_offense?(disabled_ranges, line_range)
 
             redundant_cop = find_redundant(comment, offenses, cop, line_range,
@@ -115,7 +114,7 @@ module RuboCop
           end
         end
 
-        def each_already_disabled(line_ranges, disabled_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
@@ -124,17 +123,16 @@ module RuboCop
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            redundant_comment = comments.find do |c|
-              c.loc.line == range.begin &&
-                # Comments disabling all cops don't count since it's reasonable
-                # to disable a few select cops first and then all cops further
-                # down in the code.
-                !all_disabled?(c)
-            end
-            yield redundant_comment if redundant_comment
+            comment = processed_source.comment_at_line(range.begin)
+
+            # Comments disabling all cops don't count since it's reasonable
+            # to disable a few select cops first and then all cops further
+            # down in the code.
+            yield comment if comment && !all_disabled?(comment)
           end
         end
 
+        # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_redundant(comment, offenses, cop, line_range, next_line_range)
           if all_disabled?(comment)
             # If there's a disable all comment followed by a comment
@@ -152,9 +150,10 @@ module RuboCop
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*(?:disable|todo)\s+all\b/
+          /rubocop\s*:\s*(?:disable|todo)\s+all\b/.match?(comment.text)
         end
 
         def ignore_offense?(disabled_ranges, line_range)
@@ -185,10 +184,12 @@ module RuboCop
           cop_list = cops.sort.map { |c| describe(c) }
 
           add_offense(
-            [[location], location],
-            location: location,
+            location,
             message: "Unnecessary disabling of #{cop_list.join(', ')}."
-          )
+          ) do |corrector|
+            range = comment_range_with_surrounding_space(location)
+            corrector.remove(range)
+          end
         end
 
         def add_offense_for_some_cops(comment, cops)
@@ -198,10 +199,12 @@ module RuboCop
 
           cop_ranges.each do |cop, range|
             add_offense(
-              [ranges, range],
-              location: range,
+              range,
               message: "Unnecessary disabling of #{describe(cop)}."
-            )
+            ) do |corrector|
+              range = directive_range_in_list(range, ranges)
+              corrector.remove(range)
+            end
           end
         end
 
@@ -225,7 +228,7 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
+            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
         end
 
         def describe(cop)
@@ -244,7 +247,7 @@ module RuboCop
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.registry.names
+          @all_cop_names ||= Registry.global.names
         end
 
         def ends_its_line?(range)

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

@@ -34,28 +34,24 @@ module RuboCop
       #   foo = "1"
       #   # rubocop:enable all
       #   baz
-      class RedundantCopEnableDirective < Cop
+      class RedundantCopEnableDirective < Base
         include RangeHelp
         include SurroundingSpace
+        extend AutoCorrector
 
         MSG = 'Unnecessary enabling of %<cop>s.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each do |comment, name|
             add_offense(
-              [comment, name],
-              location: range_of_offense(comment, name),
+              range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
-            )
-          end
-        end
-
-        def autocorrect(comment_and_name)
-          lambda do |corrector|
-            corrector.remove(range_with_comma(*comment_and_name))
+            ) do |corrector|
+              corrector.remove(range_with_comma(comment, name))
+            end
           end
         end
 

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

@@ -21,8 +21,9 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class RedundantRequireStatement < Cop
+      class RedundantRequireStatement < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
 
@@ -34,13 +35,9 @@ module RuboCop
         def on_send(node)
           return unless unnecessary_require_statement?(node)
 
-          add_offense(node)
-        end
+          add_offense(node) do |corrector|
+            range = range_with_surrounding_space(range: node.loc.expression, side: :right)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression,
-                                                 side: :right)
             corrector.remove(range)
           end
         end

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

@@ -49,7 +49,9 @@ module RuboCop
       #   else
       #     baz
       #   end
-      class RedundantSplatExpansion < Cop
+      class RedundantSplatExpansion < Base
+        extend AutoCorrector
+
         MSG = 'Replace splat expansion with comma separated values.'
         ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
         PERCENT_W = '%w'
@@ -60,8 +62,8 @@ module RuboCop
 
         def_node_matcher :array_new?, <<~PATTERN
           {
-            $(send (const nil? :Array) :new ...)
-            $(block (send (const nil? :Array) :new ...) ...)
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
           }
         PATTERN
 
@@ -73,23 +75,25 @@ module RuboCop
           redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
-              add_offense(node, message: ARRAY_PARAM_MSG)
+              add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
             else
-              add_offense(node)
+              add_offense(node) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           range, content = replacement_range_and_content(node)
 
-          lambda do |corrector|
-            corrector.replace(range, content)
-          end
+          corrector.replace(range, content)
         end
 
-        private
-
         def redundant_splat_expansion(node)
           literal_expansion(node) do |expanded_item|
             if expanded_item.send_type?