rubocop 0.82.0 → 1.18.4

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unintended or-assignment to a constant.
+      #
+      # Constants should always be assigned in the same location. And its value
+      # should always be the same. If constants are assigned in multiple
+      # locations, the result may vary depending on the order of `require`.
+      #
+      # Also, if you already have such an implementation, auto-correction may
+      # change the result.
+      #
+      # @example
+      #
+      #   # bad
+      #   CONST ||= 1
+      #
+      #   # good
+      #   CONST = 1
+      #
+      class OrAssignmentToConstant < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid using or-assignment with constants.'
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          return unless lhs&.casgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,13 +27,13 @@ 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.'
+        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 +43,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,96 @@
+# 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 = '$%<backref>s is out of range (%<count>s regexp capture %<group>s detected).'
+
+        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
+        RESTRICT_ON_SEND = REGEXP_CAPTURE_METHODS
+
+        def on_new_investigation
+          @valid_ref = 0
+        end
+
+        def on_match_with_lvasgn(node)
+          check_regexp(node.children.first)
+        end
+
+        def after_send(node)
+          @valid_ref = nil
+
+          if regexp_first_argument?(node)
+            check_regexp(node.first_argument)
+          elsif regexp_receiver?(node)
+            check_regexp(node.receiver)
+          end
+        end
+
+        def on_when(node)
+          regexp_conditions = node.conditions.select(&:regexp_type?)
+
+          @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
+        end
+
+        def on_nth_ref(node)
+          backref, = *node
+          return if @valid_ref.nil? || backref <= @valid_ref
+
+          message = format(
+            MSG,
+            backref: backref,
+            count: @valid_ref.zero? ? 'no' : @valid_ref,
+            group: @valid_ref == 1 ? 'group' : 'groups'
+          )
+
+          add_offense(node, message: message)
+        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
+
+        def regexp_first_argument?(send_node)
+          send_node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)
+        end
+
+        def regexp_receiver?(send_node)
+          send_node.receiver&.regexp_type?
+        end
+
+        def nth_ref_receiver?(send_node)
+          send_node.receiver&.nth_ref_type?
+        end
+      end
+    end
+  end
+end

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

@@ -9,36 +9,55 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
-      #   puts (x + y)
-      #
-      # @example
+      #   do_something (foo)
       #
       #   # good
-      #
-      #   puts(x + y)
-      class ParenthesesAsGroupedExpression < Cop
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
+      class ParenthesesAsGroupedExpression < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`(...)` interpreted as grouped expression.'
 
         def on_send(node)
-          return unless node.arguments.one?
-          return if node.operator_method? || node.setter_method?
-
-          return unless node.first_argument.source.start_with?('(')
+          return if valid_context?(node)
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length.positive?
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(nil, location: range)
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
         alias on_csend on_send
 
         private
 
+        def valid_context?(node)
+          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+            return true
+          end
+
+          node.operator_method? || node.setter_method? || chained_calls?(node) ||
+            operator_keyword?(node) || node.first_argument.hash_type?
+        end
+
+        def first_argument_starts_with_left_parenthesis?(node)
+          node.first_argument.source.start_with?('(')
+        end
+
+        def chained_calls?(node)
+          first_argument = node.first_argument
+          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+        end
+
+        def operator_keyword?(node)
+          first_argument = node.first_argument
+          first_argument.operator_keyword?
+        end
+
         def spaces_before_left_parenthesis(node)
           receiver = node.receiver
           receiver_length = if receiver

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

@@ -20,15 +20,16 @@ module RuboCop
       #   # good
       #
       #   %w(foo bar)
-      class PercentStringArray < Cop
+      class PercentStringArray < Base
         include PercentLiteral
+        extend AutoCorrector
 
         QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
         LEADING_QUOTE = /^['"]/.freeze
         TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
-          'unwanted in the resulting strings.'
+              'unwanted in the resulting strings.'
 
         def on_array(node)
           process(node, '%w', '%W')
@@ -37,20 +38,14 @@ 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
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              if LEADING_QUOTE.match?(range.source)
-                corrector.remove_leading(range, 1)
-              end
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
             end
           end
         end
@@ -64,7 +59,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,11 +20,12 @@ 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.'
+              'unwanted in the resulting symbols.'
 
         def on_array(node)
           process(node, '%i', '%I')
@@ -33,23 +34,21 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         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 +60,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,30 +27,42 @@ module RuboCop
       #       raise Exception # This exception means `Gem::Exception`.
       #     end
       #   end
-      class RaiseException < Cop
+      class RaiseException < Base
+        extend AutoCorrector
+
         MSG = 'Use `StandardError` over `Exception`.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method exception?(node)
         def_node_matcher :exception?, <<~PATTERN
-          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
+          (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
+        # @!method exception_new_with_message?(node)
         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)
-          exception?(node, &check(node)) ||
-            exception_new_with_message?(node, &check(node))
+          exception?(node, &check(node)) || exception_new_with_message?(node, &check(node))
         end
 
         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,12 +20,13 @@ module RuboCop
       #   # good
       #
       #   0 # just use 0 instead
-      class RandOne < Cop
-        MSG = '`%<method>s` always returns `0`. ' \
-              'Perhaps you meant `rand(2)` or `rand`?'
+      class RandOne < Base
+        MSG = '`%<method>s` always returns `0`. Perhaps you meant `rand(2)` or `rand`?'
+        RESTRICT_ON_SEND = %i[rand].freeze
 
+        # @!method rand_one?(node)
         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)

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

@@ -25,52 +25,68 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class RedundantCopDisableDirective < Cop
-        include NameSimilarity
+      class RedundantCopDisableDirective < Base # rubocop:todo Metrics/ClassLength
         include RangeHelp
+        extend AutoCorrector
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
+        DEPARTMENT_MARKER = 'DEPARTMENT'
+
+        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
 
-        def check(offenses, cop_disabled_line_ranges, comments)
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
-          each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses, comments) do |comment, redundant_cop|
+          each_redundant_disable do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
           add_offenses(redundant_cops)
+          super
         end
 
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
+        private
+
+        def cop_disabled_line_ranges
+          processed_source.disabled_line_ranges
+        end
 
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
+        def disabled_ranges
+          cop_disabled_line_ranges[COP_NAME] || [0..0]
+        end
 
-            corrector.remove(range)
-          end
+        def previous_line_blank?(range)
+          processed_source.buffer.source_line(range.line - 1).blank?
         end
 
-        private
+        def comment_range_with_surrounding_space(directive_comment_range, line_comment_range)
+          if previous_line_blank?(directive_comment_range) &&
+             processed_source.comment_config.comment_only_line?(directive_comment_range.line) &&
+             directive_comment_range.begin_pos == line_comment_range.begin_pos
+            # When the previous line is blank, it should be retained
+            range_with_surrounding_space(range: directive_comment_range, side: :right)
+          else
+            # Eat the entire comment, the preceding space, and the preceding
+            # newline if there is one.
+            original_begin = directive_comment_range.begin_pos
+            range = range_with_surrounding_space(
+              range: directive_comment_range, side: :left, newlines: true
+            )
 
-        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?)
+            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)
@@ -84,96 +100,102 @@ module RuboCop
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       newlines: false)
+          range_with_surrounding_space(range: range, side: :right, newlines: false)
         end
 
-        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
-                                   &block)
-          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
-
+        def each_redundant_disable(&block)
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges,
-                                  disabled_ranges, comments) do |comment|
-              yield comment, cop
-            end
-
-            each_line_range(line_ranges, disabled_ranges, offenses, comments,
-                            cop, &block)
+            each_already_disabled(cop, line_ranges, &block)
+            each_line_range(cop, line_ranges, &block)
           end
         end
 
-        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
-                            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)
+        def each_line_range(cop, line_ranges)
+          line_ranges.each_with_index do |line_range, line_range_index|
+            next if ignore_offense?(line_range)
+
+            comment = processed_source.comment_at_line(line_range.begin)
+            redundant = if all_disabled?(comment)
+                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
+                        elsif department_disabled?(cop, comment)
+                          find_redundant_department(cop, line_range)
+                        else
+                          find_redundant_cop(cop, line_range)
+                        end
 
-            redundant_cop = find_redundant(comment, offenses, cop, line_range,
-                                           line_ranges[ix + 1])
-            yield comment, redundant_cop if redundant_cop
+            yield comment, redundant if redundant
           end
         end
 
-        def each_already_disabled(line_ranges, disabled_ranges, comments)
+        def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
-            next if ignore_offense?(disabled_ranges, range)
-            next if previous_range.end != range.begin
+            next if ignore_offense?(range)
+            next unless followed_ranges?(previous_range, range)
 
             # 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 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, cop if comment && !all_disabled?(comment)
           end
         end
 
-        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 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? ||
-                line_range.last != next_line_range.first) &&
-               offenses.none? { |o| line_range.cover?(o.line) }
-              'all'
-            end
-          else
-            cop_offenses = offenses.select { |o| o.cop_name == cop }
-            cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
-          end
+        def find_redundant_cop(cop, range)
+          cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }
+          cop if range_with_offense?(range, cop_offenses)
+        end
+
+        def find_redundant_all(range, next_range)
+          # 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 redundant, we will
+          # detect that when examining the comments of another cop, and we
+          # get the full line range for the disable all.
+          has_no_next_range = next_range.nil? || !followed_ranges?(range, next_range)
+          'all' if has_no_next_range && range_with_offense?(range)
+        end
+
+        def find_redundant_department(cop, range)
+          department = cop.split('/').first
+          offenses = offenses_to_check.select { |offense| offense.cop_name.start_with?(department) }
+          add_department_marker(department) if range_with_offense?(range, offenses)
+        end
+
+        def followed_ranges?(range, next_range)
+          range.end == next_range.begin
+        end
+
+        def range_with_offense?(range, offenses = offenses_to_check)
+          offenses.none? { |offense| range.cover?(offense.line) }
         end
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*(?:disable|todo)\s+all\b/
+          DirectiveComment.new(comment).disabled_all?
         end
 
-        def ignore_offense?(disabled_ranges, line_range)
+        def ignore_offense?(line_range)
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def department_disabled?(cop, comment)
+          directive = DirectiveComment.new(comment)
+          directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)
+        end
+
         def directive_count(comment)
-          match = comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          _, cops_string = match.captures
-          cops_string.split(/,\s*/).size
+          DirectiveComment.new(comment).directive_count
         end
 
         def add_offenses(redundant_cops)
           redundant_cops.each do |comment, cops|
-            if all_disabled?(comment) ||
-               directive_count(comment) == cops.size
+            if all_disabled?(comment) || directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
             else
               add_offense_for_some_cops(comment, cops)
@@ -182,14 +204,13 @@ module RuboCop
         end
 
         def add_offense_for_entire_comment(comment, cops)
-          location = comment.loc.expression
-          cop_list = cops.sort.map { |c| describe(c) }
+          location = DirectiveComment.new(comment).range
+          cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
-          add_offense(
-            [[location], location],
-            location: location,
-            message: "Unnecessary disabling of #{cop_list.join(', ')}."
-          )
+          add_offense(location, message: message(cop_names)) do |corrector|
+            range = comment_range_with_surrounding_space(location, comment.loc.expression)
+            corrector.remove(range)
+          end
         end
 
         def add_offense_for_some_cops(comment, cops)
@@ -198,15 +219,16 @@ module RuboCop
           ranges = cop_ranges.map { |_, r| r }
 
           cop_ranges.each do |cop, range|
-            add_offense(
-              [ranges, range],
-              location: range,
-              message: "Unnecessary disabling of #{describe(cop)}."
-            )
+            cop_name = describe(cop)
+            add_offense(range, message: message(cop_name)) do |corrector|
+              range = directive_range_in_list(range, ranges)
+              corrector.remove(range)
+            end
           end
         end
 
         def cop_range(comment, cop)
+          cop = remove_department_marker(cop)
           matching_range(comment.loc.expression, cop) ||
             matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
@@ -217,8 +239,7 @@ module RuboCop
           return unless offset
 
           offset += haystack.begin_pos
-          Parser::Source::Range.new(haystack.source_buffer, offset,
-                                    offset + needle.size)
+          Parser::Source::Range.new(haystack.source_buffer, offset, offset + needle.size)
         end
 
         def trailing_range?(ranges, range)
@@ -226,36 +247,42 @@ 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)
-          if cop == 'all'
-            'all cops'
-          elsif all_cop_names.include?(cop)
-            "`#{cop}`"
-          else
-            similar = find_similar_name(cop, [])
-            if similar
-              "`#{cop}` (did you mean `#{similar}`?)"
-            else
-              "`#{cop}` (unknown cop)"
-            end
-          end
+          return 'all cops' if cop == 'all'
+          return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
+          return "`#{cop}`" if all_cop_names.include?(cop)
+
+          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
+        def message(cop_names)
+          "Unnecessary disabling of #{cop_names}."
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.registry.names
+          @all_cop_names ||= Registry.global.names
         end
 
         def ends_its_line?(range)
           line = range.source_buffer.source_line(range.last_line)
           (line =~ /\s*\z/) == range.last_column
         end
+
+        def department_marker?(department)
+          department.start_with?(DEPARTMENT_MARKER)
+        end
+
+        def remove_department_marker(department)
+          department.gsub(DEPARTMENT_MARKER, '')
+        end
+
+        def add_department_marker(department)
+          DEPARTMENT_MARKER + department
+        end
       end
     end
   end