rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/lint/{unneeded_disable.rb → redundant_cop_disable_directive.rb}

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# The Lint/RedundantCopDisableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of a redundant disable.
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -12,34 +15,44 @@ module RuboCop
       # their work. Instead, it waits until it's called in a later stage of the
       # execution. The reason it can't be implemented as a normal cop is that
       # it depends on the results of all other cops to do its work.
-      class UnneededDisable < Cop
-        include NameSimilarity
-
-        COP_NAME = 'Lint/UnneededDisable'.freeze
-
-        def check(offenses, cop_disabled_line_ranges, comments)
-          unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
-
-          each_unneeded_disable(cop_disabled_line_ranges,
-                                offenses, comments) do |comment, unneeded_cop|
-            unneeded_cops[comment].add(unneeded_cop)
-          end
-
-          add_offenses(unneeded_cops)
+      #
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Layout/LineLength
+      #   x += 1
+      #   # rubocop:enable Layout/LineLength
+      #
+      #   # good
+      #   x += 1
+      class RedundantCopDisableDirective < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        COP_NAME = 'Lint/RedundantCopDisableDirective'
+
+        attr_accessor :offenses_to_check
+
+        def initialize(config = nil, options = nil, offenses = nil)
+          @offenses_to_check = offenses
+          super(config, options)
         end
 
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
+        def on_new_investigation
+          return unless offenses_to_check
 
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
+          comments = processed_source.comments
+          cop_disabled_line_ranges = processed_source.disabled_line_ranges
 
-            corrector.remove(range)
+          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|
+            redundant_cops[comment].add(redundant_cop)
           end
+
+          add_offenses(redundant_cops)
+          super
         end
 
         private
@@ -48,12 +61,15 @@ module RuboCop
           # 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, :left, true)
-          range_with_surrounding_space(range, :right,
+          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.
-                                       original_begin.zero?)
+                                       newlines: original_begin.zero?)
         end
 
         def directive_range_in_list(range, ranges)
@@ -61,21 +77,24 @@ module RuboCop
           # is NOT being removed?
           if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
             # Eat the comma on the left.
-            range = range_with_surrounding_space(range, :left)
+            range = range_with_surrounding_space(range: range, side: :left)
             range = range_with_surrounding_comma(range, :left)
           end
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range, :right, false)
+          range_with_surrounding_space(range: range,
+                                       side: :right,
+                                       newlines: false)
         end
 
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
-                                  &block)
+        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+                                   &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, comments) do |comment|
+            each_already_disabled(line_ranges,
+                                  disabled_ranges, comments) do |comment|
               yield comment, cop
             end
 
@@ -88,41 +107,40 @@ module RuboCop
                             cop)
           line_ranges.each_with_index do |line_range, ix|
             comment = comments.find { |c| c.loc.line == line_range.begin }
+            next if ignore_offense?(disabled_ranges, line_range)
 
-            unless all_disabled?(comment)
-              next if ignore_offense?(disabled_ranges, line_range)
-            end
-
-            unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
-                                         line_ranges[ix + 1])
-            yield comment, unneeded_cop if unneeded_cop
+            redundant_cop = find_redundant(comment, offenses, cop, line_range,
+                                           line_ranges[ix + 1])
+            yield comment, redundant_cop if redundant_cop
           end
         end
 
-        def each_already_disabled(line_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges, comments)
           line_ranges.each_cons(2) do |previous_range, range|
+            next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
 
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
-            # already disabled by an earlier comment. So it's unneeded
+            # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            unneeded_comment = comments.find do |c|
+            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 unneeded_comment if unneeded_comment
+            yield redundant_comment if redundant_comment
           end
         end
 
-        def find_unneeded(comment, offenses, cop, line_range, next_line_range)
+        # rubocop:todo Metrics/CyclomaticComplexity
+        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
             # specifically disabling `cop`, we don't report the `all`
-            # comment. If the disable all comment is truly unneeded, we will
+            # comment. If the disable all comment is truly redundant, we will
             # detect that when examining the comments of another cop, and we
             # get the full line range for the disable all.
             if (next_line_range.nil? ||
@@ -135,9 +153,10 @@ module RuboCop
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*disable\s+all\b/
+          /rubocop\s*:\s*(?:disable|todo)\s+all\b/.match?(comment.text)
         end
 
         def ignore_offense?(disabled_ranges, line_range)
@@ -152,8 +171,8 @@ module RuboCop
           cops_string.split(/,\s*/).size
         end
 
-        def add_offenses(unneeded_cops)
-          unneeded_cops.each do |comment, cops|
+        def add_offenses(redundant_cops)
+          redundant_cops.each do |comment, cops|
             if all_disabled?(comment) ||
                directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
@@ -168,10 +187,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)
@@ -181,10 +202,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
 
@@ -195,8 +218,9 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          offset = haystack.source.index(needle)
           return unless offset
+
           offset += haystack.begin_pos
           Parser::Source::Range.new(haystack.source_buffer, offset,
                                     offset + needle.size)
@@ -206,8 +230,8 @@ module RuboCop
           ranges
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
-            .map { |r1, r2| r1.end.join(r2.begin).source }
-            .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
+            .map { |range1, range2| range1.end.join(range2.begin).source }
+            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
         end
 
         def describe(cop)
@@ -216,7 +240,7 @@ module RuboCop
           elsif all_cop_names.include?(cop)
             "`#{cop}`"
           else
-            similar = find_similar_name(cop, [])
+            similar = NameSimilarity.find_similar_name(cop, all_cop_names)
             if similar
               "`#{cop}` (did you mean `#{similar}`?)"
             else
@@ -225,14 +249,16 @@ module RuboCop
           end
         end
 
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
-        end
-
         def all_cop_names
           @all_cop_names ||= Cop.registry.names
         end
+
+        def ends_its_line?(range)
+          line = range.source_buffer.source_line(range.last_line)
+          (line =~ /\s*\z/) == range.last_column
+        end
       end
     end
   end
 end
+# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
+
+# rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop detects instances of rubocop:enable comments that can be
+      # removed.
+      #
+      # When comment enables all cops at once `rubocop:enable all`
+      # that cop checks whether any cop was actually enabled.
+      # @example
+      #   # bad
+      #   foo = 1
+      #   # rubocop:enable Layout/LineLength
+      #
+      #   # good
+      #   foo = 1
+      # @example
+      #   # bad
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
+      #   baz
+      #   # rubocop:enable all
+      #
+      #   # good
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable all
+      #   baz
+      class RedundantCopEnableDirective < Cop
+        include RangeHelp
+        include SurroundingSpace
+
+        MSG = 'Unnecessary enabling of %<cop>s.'
+
+        def investigate(processed_source)
+          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
+        end
+
+        def autocorrect(comment_and_name)
+          lambda do |corrector|
+            corrector.remove(range_with_comma(*comment_and_name))
+          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)
+        end
+
+        def comment_start(comment)
+          comment.loc.expression.begin_pos
+        end
+
+        def cop_name_indention(comment, name)
+          comment.text.index(name)
+        end
+
+        def range_with_comma(comment, name)
+          source = comment.loc.expression.source
+
+          begin_pos = cop_name_indention(comment, name)
+          end_pos = begin_pos + name.size
+          begin_pos = reposition(source, begin_pos, -1)
+          end_pos = reposition(source, end_pos, 1)
+
+          comma_pos =
+            if source[begin_pos - 1] == ','
+              :before
+            elsif source[end_pos] == ','
+              :after
+            else
+              :none
+            end
+
+          range_to_remove(begin_pos, end_pos, comma_pos, comment)
+        end
+
+        def range_to_remove(begin_pos, end_pos, comma_pos, comment)
+          start = comment_start(comment)
+
+          case comma_pos
+          when :before
+            range_between(start + begin_pos - 1, start + end_pos)
+          when :after
+            range_between(start + begin_pos, start + end_pos + 1)
+          else
+            range_between(start, comment.loc.expression.end_pos)
+          end
+        end
+
+        def all_or_name(name)
+          name == 'all' ? 'all cops' : name
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

data/lib/rubocop/cop/lint/{unneeded_require_statement.rb → redundant_require_statement.rb}

@@ -8,9 +8,9 @@ module RuboCop
       # The following features are unnecessary `require` statement because
       # they are already loaded.
       #
-      # ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
-      # ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
-      # ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
+      #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
+      #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
+      #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
       # This cop targets Ruby 2.2 or higher containing these 4 features.
       #
@@ -21,26 +21,26 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class UnneededRequireStatement < Cop
-        extend TargetRubyVersion
+      class RedundantRequireStatement < Cop
+        include RangeHelp
 
-        minimum_target_ruby_version 2.2
+        MSG = 'Remove unnecessary `require` statement.'
 
-        MSG = 'Remove unnecessary `require` statement.'.freeze
-
-        def_node_matcher :unnecessary_require_statement?, <<-PATTERN
+        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
             (str {"enumerator" "rational" "complex" "thread"}))
         PATTERN
 
         def on_send(node)
           return unless unnecessary_require_statement?(node)
+
           add_offense(node)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            range = range_with_surrounding_space(node.loc.expression, :right)
+            range = range_with_surrounding_space(range: node.loc.expression,
+                                                 side: :right)
             corrector.remove(range)
           end
         end

data/lib/rubocop/cop/lint/{unneeded_splat_expansion.rb → redundant_splat_expansion.rb}

@@ -44,31 +44,33 @@ module RuboCop
       #   end
       #
       #   case foo
-      #   when *[1, 2, 3]
+      #   when 1, 2, 3
       #     bar
       #   else
       #     baz
       #   end
-      class UnneededSplatExpansion < Cop
-        MSG = 'Unnecessary splat expansion.'.freeze
-        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'.freeze
-        PERCENT_W = '%w'.freeze
-        PERCENT_CAPITAL_W = '%W'.freeze
-        PERCENT_I = '%i'.freeze
-        PERCENT_CAPITAL_I = '%I'.freeze
-        ARRAY_NEW_PATTERN = '$(send (const nil? :Array) :new ...)'.freeze
+      class RedundantSplatExpansion < Cop
+        MSG = 'Replace splat expansion with comma separated values.'
+        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
+        PERCENT_W = '%w'
+        PERCENT_CAPITAL_W = '%W'
+        PERCENT_I = '%i'
+        PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :literal_expansion?, <<-PATTERN
-          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
+          }
         PATTERN
 
-        def on_splat(node)
-          literal_expansion?(node) do |object|
-            if object.send_type?
-              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
-            end
+        def_node_matcher :literal_expansion, <<~PATTERN
+          (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
+        PATTERN
 
+        def on_splat(node)
+          redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, message: ARRAY_PARAM_MSG)
@@ -78,20 +80,49 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          range, content = replacement_range_and_content(node)
+
+          lambda do |corrector|
+            corrector.replace(range, content)
+          end
+        end
+
         private
 
-        def autocorrect(node)
+        def redundant_splat_expansion(node)
+          literal_expansion(node) do |expanded_item|
+            if expanded_item.send_type?
+              return if array_new_inside_array_literal?(expanded_item)
+
+              grandparent = node.parent.parent
+              return if grandparent &&
+                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+            end
+
+            yield
+          end
+        end
+
+        def array_new_inside_array_literal?(array_new_node)
+          return false unless array_new?(array_new_node)
+
+          grandparent = array_new_node.parent.parent
+          grandparent.array_type? && grandparent.children.size > 1
+        end
+
+        def replacement_range_and_content(node)
           variable, = *node
           loc = node.loc
 
-          lambda do |corrector|
-            if !variable.array_type?
-              corrector.replace(loc.expression, "[#{variable.source}]")
-            elsif unneeded_brackets?(node)
-              corrector.replace(loc.expression, remove_brackets(variable))
-            else
-              corrector.remove(loc.operator)
-            end
+          if array_new?(variable)
+            [node.parent.loc.expression, variable.source]
+          elsif !variable.array_type?
+            [loc.expression, "[#{variable.source}]"]
+          elsif redundant_brackets?(node)
+            [loc.expression, remove_brackets(variable)]
+          else
+            [loc.operator, '']
           end
         end
 
@@ -110,12 +141,12 @@ module RuboCop
           parent.array_type? && parent.loc.begin && parent.loc.end
         end
 
-        def unneeded_brackets?(node)
+        def redundant_brackets?(node)
           parent = node.parent
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent && grandparent.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,33 +17,28 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
-        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'.freeze
+      class RedundantStringCoercion < Cop
+        include Interpolation
+
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
-                   'interpolation.'.freeze
+                   'interpolation.'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
+        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
-            next unless final_node && final_node.send_type? &&
-                        final_node.method?(:to_s) && !final_node.arguments?
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
 
-            add_offense(final_node, location: :selector)
-          end
-        end
+          return unless to_s_without_args?(final_node)
 
-        private
-
-        def message(node)
-          node.receiver ? MSG_DEFAULT : MSG_SELF
+          add_offense(final_node, location: :selector)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, _method_name, *_args = *node
+            receiver = node.receiver
             corrector.replace(
-              node.source_range,
+              node,
               if receiver
                 receiver.source
               else
@@ -52,6 +47,12 @@ module RuboCop
             )
           end
         end
+
+        private
+
+        def message(node)
+          node.receiver ? MSG_DEFAULT : MSG_SELF
+        end
       end
     end
   end