rubocop 0.88.0 → 0.91.1

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

@@ -41,13 +41,12 @@ module RuboCop
         def on_new_investigation
           return unless offenses_to_check
 
-          comments = processed_source.comments
           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_to_check, comments) do |comment, redundant_cop|
+                                 offenses_to_check) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
@@ -57,19 +56,29 @@ module RuboCop
 
         private
 
+        def previous_line_blank?(range)
+          processed_source.buffer.source_line(range.line - 1).blank?
+        end
+
         def comment_range_with_surrounding_space(range)
-          # Eat the entire comment, the preceding space, and the preceding
-          # newline if there is one.
-          original_begin = range.begin_pos
-          range = range_with_surrounding_space(range: range,
-                                               side: :left,
-                                               newlines: true)
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       # Special for a comment that
-                                       # begins the file: remove
-                                       # the newline at the end.
-                                       newlines: original_begin.zero?)
+          if previous_line_blank?(range)
+            # When the previous line is blank, it should be retained
+            range_with_surrounding_space(range: range, side: :right)
+          else
+            # Eat the entire comment, the preceding space, and the preceding
+            # newline if there is one.
+            original_begin = range.begin_pos
+            range = range_with_surrounding_space(range: range,
+                                                 side: :left,
+                                                 newlines: true)
+
+            range_with_surrounding_space(range: range,
+                                         side: :right,
+                                         # Special for a comment that
+                                         # begins the file: remove
+                                         # the newline at the end.
+                                         newlines: original_begin.zero?)
+          end
         end
 
         def directive_range_in_list(range, ranges)
@@ -88,25 +97,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 +124,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,18 +133,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
+        # 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
@@ -153,7 +160,7 @@ module RuboCop
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def all_disabled?(comment)
           /rubocop\s*:\s*(?:disable|todo)\s+all\b/.match?(comment.text)
@@ -250,7 +257,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,33 +34,39 @@ 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),
-              message: format(MSG, cop: all_or_name(name))
-            )
-          end
+          offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
         end
 
-        def autocorrect(comment_and_name)
-          lambda do |corrector|
-            corrector.remove(range_with_comma(*comment_and_name))
+        private
+
+        def register_offense(comment, cop_names)
+          directive = DirectiveComment.new(comment)
+
+          cop_names.each do |name|
+            add_offense(
+              range_of_offense(comment, name),
+              message: format(MSG, cop: all_or_name(name))
+            ) do |corrector|
+              if directive.match?(cop_names)
+                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+              else
+                corrector.remove(range_with_comma(comment, name))
+              end
+            end
           end
         end
 
-        private
-
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -21,10 +21,12 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class RedundantRequireStatement < Cop
+      class RedundantRequireStatement < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
+        RESTRICT_ON_SEND = %i[require].freeze
 
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
@@ -34,13 +36,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'
@@ -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?

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

@@ -17,8 +17,9 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class RedundantStringCoercion < Cop
+      class RedundantStringCoercion < Base
         include Interpolation
+        extend AutoCorrector
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
@@ -31,14 +32,12 @@ module RuboCop
 
           return unless to_s_without_args?(final_node)
 
-          add_offense(final_node, location: :selector)
-        end
+          message = final_node.receiver ? MSG_DEFAULT : MSG_SELF
 
-        def autocorrect(node)
-          lambda do |corrector|
-            receiver = node.receiver
+          add_offense(final_node.loc.selector, message: message) do |corrector|
+            receiver = final_node.receiver
             corrector.replace(
-              node,
+              final_node,
               if receiver
                 receiver.source
               else
@@ -47,12 +46,6 @@ module RuboCop
             )
           end
         end
-
-        private
-
-        def message(node)
-          node.receiver ? MSG_DEFAULT : MSG_SELF
-        end
       end
     end
   end

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

@@ -26,8 +26,9 @@ module RuboCop
       #     v
       #   end
       #
-      class RedundantWithIndex < Cop
+      class RedundantWithIndex < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
@@ -42,20 +43,16 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          redundant_with_index?(node) do |send|
-            add_offense(node, location: with_index_range(send))
-          end
-        end
+          return unless (send = redundant_with_index?(node))
+
+          range = with_index_range(send)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_with_index?(node) do |send|
-              if send.method?(:each_with_index)
-                corrector.replace(send.loc.selector, 'each')
-              else
-                corrector.remove(with_index_range(send))
-                corrector.remove(send.loc.dot)
-              end
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_index)
+              corrector.replace(send.loc.selector, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
             end
           end
         end

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

@@ -26,8 +26,9 @@ module RuboCop
       #     v
       #   end
       #
-      class RedundantWithObject < Cop
+      class RedundantWithObject < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
 
@@ -43,20 +44,16 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          redundant_with_object?(node) do |send|
-            add_offense(node, location: with_object_range(send))
-          end
-        end
+          return unless (send = redundant_with_object?(node))
+
+          range = with_object_range(send)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_with_object?(node) do |send|
-              if send.method?(:each_with_object)
-                corrector.replace(with_object_range(send), 'each')
-              else
-                corrector.remove(with_object_range(send))
-                corrector.remove(send.loc.dot)
-              end
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_object)
+              corrector.replace(range, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
             end
           end
         end

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

@@ -16,16 +16,14 @@ module RuboCop
       #   if /foo/ =~ $_
       #     do_something
       #   end
-      class RegexpAsCondition < Cop
+      class RegexpAsCondition < Base
+        extend AutoCorrector
+
         MSG = 'Do not use regexp literal as a condition.' \
               ' The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(node, "#{node.source} =~ $_")
           end
         end

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

@@ -27,7 +27,7 @@ module RuboCop
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end
-      class RequireParentheses < Cop
+      class RequireParentheses < Base
         include RangeHelp
 
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
@@ -52,7 +52,7 @@ module RuboCop
           range = range_between(node.source_range.begin_pos,
                                 ternary.condition.source_range.end_pos)
 
-          add_offense(range, location: range)
+          add_offense(range)
         end
 
         def check_predicate(predicate, node)

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

@@ -24,7 +24,7 @@ module RuboCop
       #   rescue ArgumentError
       #     handle_exception
       #   end
-      class RescueException < Cop
+      class RescueException < Base
         MSG = 'Avoid rescuing the `Exception` class. ' \
               'Perhaps you meant to rescue `StandardError`?'
 

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

@@ -34,8 +34,8 @@ module RuboCop
       #   rescue NameError
       #     baz
       #   end
-      class RescueType < Cop
-        include RescueNode
+      class RescueType < Base
+        extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
               '`TypeError` instead of catching the actual exception.'
@@ -50,24 +50,23 @@ module RuboCop
           return if invalid_exceptions.empty?
 
           add_offense(
-            node,
-            location: node.loc.keyword.join(rescued.loc.expression),
+            node.loc.keyword.join(rescued.loc.expression),
             message: format(
               MSG, invalid_exceptions: invalid_exceptions.map(&:source)
                                                          .join(', ')
             )
-          )
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           rescued, _, _body = *node
           range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                             node.loc.keyword.end_pos,
                                             rescued.loc.expression.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(range, correction(*rescued))
-          end
+          corrector.replace(range, correction(*rescued))
         end
 
         private