rubocop 1.71.1 → 1.92.0

data/config/internal_affairs.yml

@@ -6,6 +6,26 @@ InternalAffairs/CopDescription:
   Include:
     - 'lib/rubocop/cop/**/*.rb'
 
+InternalAffairs/ExampleHeredocDelimiter:
+  Include:
+    - 'spec/rubocop/cop/**/*.rb'
+
+InternalAffairs/ExampleDescription:
+  Include:
+    - 'spec/rubocop/cop/**/*.rb'
+
+InternalAffairs/NodeTypeGroup:
+  Include:
+    - 'lib/rubocop/cop/**/*.rb'
+
+InternalAffairs/OnSendWithoutOnCSend:
+  Include:
+    - 'lib/rubocop/cop/**/*.rb'
+
+InternalAffairs/UndefinedConfig:
+  Include:
+    - 'lib/rubocop/cop/**/*.rb'
+
 InternalAffairs/UselessMessageAssertion:
   Include:
     - '**/*_spec.rb'

data/config/obsoletion.yml

@@ -31,6 +31,9 @@ renamed:
   Lint/UnneededRequireStatement: Lint/RedundantRequireStatement
   Lint/UnneededSplatExpansion: Lint/RedundantSplatExpansion
   Metrics/LineLength: Layout/LineLength
+  Naming/PredicateName:
+    new_name: Naming/PredicatePrefix
+    severity: warning
   Naming/UncommunicativeBlockParamName: Naming/BlockParameterName
   Naming/UncommunicativeMethodParamName: Naming/MethodParameterName
   Style/AccessorMethodName: Naming/AccessorMethodName
@@ -43,7 +46,9 @@ renamed:
   Style/MethodCallParentheses: Style/MethodCallWithoutArgsParentheses
   Style/MethodName: Naming/MethodName
   Style/OpMethod: Naming/BinaryOperatorParameterName
-  Style/PredicateName: Naming/PredicateName
+  Style/PredicateName:
+    new_name: Naming/PredicatePrefix
+    severity: warning
   Style/SingleSpaceBeforeFirstArg: Layout/SpaceBeforeFirstArg
   Style/UnneededCapitalW: Style/RedundantCapitalW
   Style/UnneededCondition: Style/RedundantCondition
@@ -75,6 +80,11 @@ removed:
       `Lint/BinaryOperatorWithIdenticalOperands`. Please use
       `Lint/BinaryOperatorWithIdenticalOperands` instead
   Style/BracesAroundHashParameters: true
+  Style/DoubleCopDisableDirective:
+    severity: warning
+    reason: >
+      it has been superseded by `Lint/CopDirectiveSyntax`. Please use
+      `Lint/CopDirectiveSyntax` instead
   Style/MethodMissingSuper:
     reason: >
       it has been superseded by `Lint/MissingSuper`. Please use
@@ -140,6 +150,14 @@ changed_parameters:
   - cops: Layout/CaseIndentation
     parameters: IndentWhenRelativeTo
     alternative: EnforcedStyle
+  - cops: Layout/LineLength
+    parameters: IgnoreCopDirectives
+    alternative: AllowCopDirectives
+    severity: warning
+  - cops: Style/DisableCopsWithinSourceCodeDirective
+    parameters: AllowTrailingComment
+    alternative: AllowWithReason
+    severity: warning
   - cops:
       - Lint/BlockAlignment
       - Layout/BlockAlignment
@@ -162,7 +180,7 @@ changed_parameters:
     reason: "`SafeMode` has been removed. Use `SafeAutoCorrect` instead."
   - cops: Bundler/GemComment
     parameters: Whitelist
-    alternative: IgnoredGems
+    alternative: AllowedGems
   - cops:
       - Lint/SafeNavigationChain
       - Lint/SafeNavigationConsistency
@@ -177,10 +195,10 @@ changed_parameters:
   - cops: Naming/HeredocDelimiterNaming
     parameters: Blacklist
     alternative: ForbiddenDelimiters
-  - cops: Naming/PredicateName
+  - cops: Naming/PredicatePrefix
     parameters: NamePrefixBlacklist
     alternative: ForbiddenPrefixes
-  - cops: Naming/PredicateName
+  - cops: Naming/PredicatePrefix
     parameters: NameWhitelist
     alternative: AllowedMethods
   - cops:
@@ -229,6 +247,26 @@ changed_parameters:
     reason: "`AllowOnlyRestArgument` has no effect with TargetRubyVersion >= 3.2."
     severity: warning
     minimum_ruby_version: 3.2
+  - cops: Bundler/GemComment
+    parameters: IgnoredGems
+    alternative: AllowedGems
+    severity: warning
+  - cops: Lint/NumberConversion
+    parameters: IgnoredClasses
+    alternative: AllowedClasses
+    severity: warning
+  - cops: Lint/MissingCopEnableDirective
+    parameters: MaximumRangeSize
+    alternative: MaxRangeSize
+    severity: warning
+  - cops: Metrics/CollectionLiteralLength
+    parameters: LengthThreshold
+    alternative: Max
+    severity: warning
+  - cops: Style/FetchEnvVar
+    parameters: AllowedVars
+    alternative: AllowedVariables
+    severity: warning
 
 # Enforced styles that have been removed or replaced
 changed_enforced_styles:
@@ -236,3 +274,8 @@ changed_enforced_styles:
     parameters: EnforcedStyle
     value: rails
     alternative: indented_internal_methods
+  - cops: Style/EmptyClassDefinition
+    parameters: EnforcedStyle
+    value: class_definition
+    alternative: class_keyword
+    severity: warning

data/exe/rubocop

@@ -8,17 +8,10 @@ server_cli = RuboCop::Server::CLI.new
 exit_status = server_cli.run
 exit exit_status if server_cli.exit?
 
-if RuboCop::Server.running?
+if RuboCop::Server.forward_to_server?
   exit_status = RuboCop::Server::ClientCommand::Exec.new.run
 else
   require 'rubocop'
-
-  cli = RuboCop::CLI.new
-
-  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  exit_status = cli.run
-  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
-
-  puts "Finished in #{elapsed_time} seconds" if cli.options[:debug] || cli.options[:display_time]
+  exit_status = RuboCop::CLI.new.run
 end
 exit exit_status

data/lib/rubocop/cache_config.rb

@@ -25,5 +25,34 @@ module RuboCop
 
       File.join(root, 'rubocop_cache')
     end
+
+    # Lightweight cache root computation that reads CacheRootDirectory from
+    # the toplevel config file and environment variables without going through
+    # the full ConfigStore/ConfigLoader. This method can be used, for example,
+    # before loading configuration files. Please note that this method doesn't
+    # take into account any `inherit_from` dependencies.
+    def self.root_dir_from_toplevel_config(cache_root_override = nil)
+      root_dir do
+        next cache_root_override if cache_root_override
+
+        config_path = ConfigFinder.find_config_path(PathUtil.pwd)
+        file_contents = File.read(config_path)
+
+        # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
+        next unless file_contents.include?('CacheRootDirectory')
+
+        require 'erb'
+        require 'yaml'
+        yaml_code = ERB.new(file_contents).result
+        config_yaml = YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+
+        # For compatibility with Ruby 3.0 or lower.
+        if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
+          config_yaml == false ? nil : config_yaml
+        end
+
+        config_yaml&.dig('AllCops', 'CacheRootDirectory')
+      end
+    end
   end
 end

data/lib/rubocop/cached_data.rb

@@ -22,7 +22,7 @@ module RuboCop
 
     def serialize_offense(offense)
       status = :uncorrected if %i[corrected corrected_with_todo].include?(offense.status)
-      {
+      hash = {
         # Calling #to_s here ensures that the serialization works when using
         # other json serializers such as Oj. Some of these gems do not call
         # #to_s implicitly.
@@ -35,19 +35,64 @@ module RuboCop
         cop_name: offense.cop_name,
         status:   status || offense.status
       }
+      add_justification(hash, offense)
+      add_corrections(hash, offense)
+      hash
     end
 
     def message(offense)
-      # JSON.dump will fail if the offense message contains text which is not
-      # valid UTF-8
-      offense.message.dup.force_encoding(::Encoding::UTF_8).scrub
+      encode_to_utf8(offense.message)
+    end
+
+    def encode_to_utf8(value)
+      string = value.to_s
+
+      if string.encoding == ::Encoding::BINARY
+        string.dup.force_encoding(::Encoding::UTF_8).scrub
+      else
+        string.encode(::Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+    end
+
+    # Only offenses suppressed by a directive can carry one, so keep the key out of the
+    # common case rather than writing a null for every cached offense.
+    def add_justification(hash, offense)
+      return unless offense.justification
+
+      hash[:justification] = encode_to_utf8(offense.justification)
+    end
+
+    # A corrector cannot be serialized, so the edits it would make are cached
+    # separately; without this a cache hit would report no corrections.
+    def add_corrections(hash, offense)
+      return if offense.corrections.empty?
+
+      hash[:corrections] = offense.corrections.map do |correction|
+        { begin_pos: correction.begin_pos,
+          end_pos: correction.end_pos,
+          replacement: encode_to_utf8(correction.replacement) }
+      end
+      hash[:correction_safe] = offense.correction_safe
     end
 
     # Restore an offense object loaded from a JSON file.
     def deserialize_offenses(offenses)
       offenses.map! do |o|
         location = location_from_source_buffer(o)
-        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'], o['status'].to_sym)
+        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'], o['status'].to_sym,
+                         justification: o['justification'],
+                         corrections: corrections_from_cache(o),
+                         correction_safe: o.fetch('correction_safe', true))
+      end
+    end
+
+    def corrections_from_cache(offense)
+      cached = offense['corrections']
+      return [] unless cached
+
+      cached.map do |correction|
+        Cop::Offense::Correction.new(correction['begin_pos'], correction['end_pos'],
+                                     correction['replacement']).freeze
       end
     end
 

data/lib/rubocop/changed_files.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RuboCop
+  # Lists the files that differ from a git revision, for `--changed`.
+  #
+  # Shelling out to `git` keeps RuboCop free of a version control dependency,
+  # and means the answer is exactly what git would give on the command line.
+  #
+  # @api private
+  class ChangedFiles
+    DEFAULT_REVISION = 'HEAD'
+    FILESYSTEM_ENCODING = Encoding.find('filesystem')
+
+    # Whether git can resolve `name` to a commit in the current repository.
+    def self.revision?(name)
+      _stdout, _stderr, status =
+        Open3.capture3('git', 'rev-parse', '--verify', '--quiet', "#{name}^{commit}")
+      status.success?
+    rescue Errno::ENOENT
+      false
+    end
+
+    def initialize(revision = nil)
+      @revision = revision || DEFAULT_REVISION
+    end
+
+    # Files that were added or modified since the revision, as absolute paths.
+    # Deleted files are left out - there is nothing left to inspect - and
+    # untracked files are included, since a file that is new to the working
+    # tree has changed as surely as one git already knows about.
+    #
+    # @return [Set<String>]
+    def paths
+      root = repository_root
+
+      (modified_paths + untracked_paths).to_set { |path| File.expand_path(path, root) }
+    end
+
+    # @return [Array<String>] the files among these that changed
+    def filter(files)
+      changed = paths
+      files.select { |file| changed.include?(file) }
+    end
+
+    private
+
+    def repository_root
+      filesystem_path(git('rev-parse', '--show-toplevel').b.chomp)
+    end
+
+    def modified_paths(revision = @revision)
+      # `diff.relative` would make git report paths relative to the current
+      # directory rather than to the repository root.
+      split_paths(
+        git('-c', 'diff.relative=false', 'diff', '--name-only', '--diff-filter=d', '-z', revision)
+      )
+    rescue Error
+      raise unless revision == DEFAULT_REVISION && unborn_head?
+
+      # A repository without commits has no `HEAD` to diff against, but files
+      # can already be staged in it. Against the empty tree every one of them
+      # counts as changed, which is what the caller wants to hear rather than
+      # an error about `HEAD` not resolving.
+      modified_paths(empty_tree)
+    end
+
+    def unborn_head?
+      !self.class.revision?(DEFAULT_REVISION)
+    end
+
+    # Hashed rather than hardcoded, since its id depends on the repository's
+    # object format (SHA-1 or SHA-256).
+    def empty_tree
+      git('hash-object', '-t', 'tree', '--stdin').chomp
+    end
+
+    def untracked_paths
+      # Unlike `git diff`, `ls-files` only looks under the current directory, so
+      # the `:/` pathspec widens it to the whole repository, and `--full-name`
+      # anchors the paths to the repository root the way `git diff` does.
+      split_paths(
+        git('ls-files', '--others', '--exclude-standard', '--full-name', '-z', '--', ':/')
+      )
+    end
+
+    # The `-z` above is what makes these usable: without it git wraps any path
+    # that is not plain ASCII in quotes and octal escapes, and those files drop
+    # out of the comparison without a word.
+    def split_paths(output)
+      output.b.split("\0").reject(&:empty?).map { |path| filesystem_path(path) }
+    end
+
+    # git hands back bytes, which Ruby tags with the encoding the process
+    # happens to have been started in - splitting those bytes as US-ASCII raises
+    # on any path that is not. They have to end up in the encoding `Dir.glob`
+    # uses, or a path with a non-ASCII character in it never matches the file
+    # list it is compared against.
+    #
+    # On POSIX those bytes are already the filesystem's own, so the encoding is
+    # simply corrected. Windows is the exception: git converts paths to UTF-8 on
+    # the way out, while Ruby reports file names in the local code page, so the
+    # two have to be reconciled.
+    def filesystem_path(path)
+      path = path.dup
+
+      return path.force_encoding(FILESYSTEM_ENCODING) unless Platform.windows?
+
+      path.force_encoding(Encoding::UTF_8).encode(FILESYSTEM_ENCODING)
+    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+      # A name the local code page cannot represent. Nothing good is left to do
+      # with it, and dropping it would be worse than reporting it as-is.
+      path.force_encoding(FILESYSTEM_ENCODING)
+    end
+
+    def git(*args)
+      stdout, stderr, status = Open3.capture3('git', *args)
+
+      raise Error, git_error_message(stderr) unless status.success?
+
+      stdout
+    rescue Errno::ENOENT
+      raise Error, '--changed requires git to be installed and on your PATH.'
+    end
+
+    def git_error_message(stderr)
+      message = stderr.strip
+      message = 'git failed with no output on standard error.' if message.empty?
+
+      "--changed could not ask git which files changed: #{message}"
+    end
+  end
+end

data/lib/rubocop/cli/command/auto_generate_config.rb

@@ -24,13 +24,45 @@ module RuboCop
 
         def run
           add_formatter
+          use_temporary_cache
+          reset_auto_gen_tmp_dir
           reset_config_and_auto_gen_file
           line_length_contents = maybe_run_line_length_cop
-          run_all_cops(line_length_contents)
+          result = run_all_cops(line_length_contents)
+          reset_auto_gen_tmp_dir
+          result
+        ensure
+          # `auto_gen_tmp_dir` points `ExcludeLimit.tmp_dir` at this command's
+          # tmp directory. Clear that process-global state on the way out so
+          # later in-process callers (e.g. other specs in the same test worker)
+          # don't read this run's leftover directory.
+          RuboCop::ExcludeLimit.tmp_dir = nil
         end
 
         private
 
+        def use_temporary_cache
+          # Use a separate cache directory to ensure MinDigits and Max values are calculated.
+          # This allows parallel execution (which requires cache) while ensuring MinDigits
+          # and Max values are computed, since the cache starts empty.
+          @options[:cache_root] = auto_gen_tmp_dir.join('cache').to_s
+        end
+
+        def reset_auto_gen_tmp_dir
+          auto_gen_tmp_dir.rmtree if auto_gen_tmp_dir.exist?
+          auto_gen_tmp_dir.mkpath
+        end
+
+        def auto_gen_tmp_dir
+          @auto_gen_tmp_dir ||= Pathname.new(
+            RuboCop::CacheConfig.root_dir_from_toplevel_config
+          ).join('auto-gen-tmp').tap do |path|
+            path.mkpath
+            # Set the temp directory path for ExcludeLimit to use
+            RuboCop::ExcludeLimit.tmp_dir = path
+          end
+        end
+
         def maybe_run_line_length_cop
           if only_exclude?
             skip_line_length_cop(PHASE_1_SKIPPED_ONLY_EXCLUDE)
@@ -83,7 +115,7 @@ module RuboCop
           execute_runner
           @options.delete(:only)
           @config_store = ConfigStore.new
-          @config_store.options_config = @options[:config] if @options[:config]
+          @config_store.apply_options!(@options)
           # Save the todo configuration of the LineLength cop.
           File.read(AUTO_GENERATED_FILE).lines.drop_while { |line| line.start_with?('#') }.join
         end
@@ -99,7 +131,7 @@ module RuboCop
 
         def reset_config_and_auto_gen_file
           @config_store = ConfigStore.new
-          @config_store.options_config = @options[:config] if @options[:config]
+          @config_store.apply_options!(@options)
           File.open(AUTO_GENERATED_FILE, 'w') {} # create or truncate if exists
           add_inheritance_from_auto_generated_file(@options[:config])
         end
@@ -153,7 +185,7 @@ module RuboCop
         def relative_path_to_todo_from_options_config
           return AUTO_GENERATED_FILE unless @options[:config]
 
-          base = Pathname.new(Dir.pwd)
+          base = Pathname.new(PathUtil.pwd)
           config_dir = Pathname.new(@options[:config]).realpath.dirname
 
           # Don't have the path start with `/`

data/lib/rubocop/cli/command/cop_names.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Shared handling for commands that take a list of cop names.
+      #
+      # Validation happens here rather than during option parsing because the
+      # registry is not complete until the configuration has been loaded, which
+      # is also why `--only` and `--except` are validated from the runner.
+      # @api private
+      module CopNames
+        private
+
+        # The cops among `names` that exist, so a command can report on what it
+        # understood before {#validate_cop_names!} objects to the rest.
+        def known_cop_classes(names)
+          names.filter_map { |name| cop_class_for(name) }
+        end
+
+        # @raise [IncorrectCopNameError] if any name is not a cop
+        def validate_cop_names!(names)
+          unknown = names.reject { |name| cop_class_for(name) }
+          return if unknown.empty?
+
+          raise IncorrectCopNameError, unknown.map { |name| unknown_cop_message(name) }.join("\n")
+        end
+
+        # Not memoized: the MCP server lives long enough for a plugin to register
+        # a cop after a lookup has missed it.
+        def cop_class_for(name)
+          Cop::Registry.global.find_by_cop_name(name)
+        end
+
+        def unknown_cop_message(name)
+          return department_message(name) if department?(name)
+
+          message = "Unrecognized cop: #{name}."
+          similar = NameSimilarity.find_similar_names(name, Cop::Registry.global.names)
+          return message if similar.empty?
+
+          "#{message}\nDid you mean? #{similar.join(', ')}"
+        end
+
+        def department?(name)
+          Cop::Registry.global.departments.any? { |department| department.to_s == name }
+        end
+
+        def department_message(name)
+          example = Cop::Registry.global.names.find { |cop| cop.start_with?("#{name}/") }
+
+          "#{name} is a department, not a cop. Name one of its cops, such as #{example}."
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/execute_runner.rb

@@ -9,7 +9,7 @@ module RuboCop
         include Formatter::TextUtil
 
         # Combination of short and long formatter names.
-        INTEGRATION_FORMATTERS = %w[h html j json ju junit].freeze
+        INTEGRATION_FORMATTERS = %w[h html j json ju junit sa sarif].freeze
 
         self.command_name = :execute_runner
 
@@ -28,8 +28,21 @@ module RuboCop
             all_passed || @options[:auto_gen_config]
           end
 
-          maybe_print_corrected_source
+          if @options[:diff]
+            print_diffs(runner.diffs)
+          else
+            maybe_print_corrected_source
+          end
+
+          # A diff means autocorrectable offenses are still in the working
+          # tree, so the run has not passed even though they were "corrected"
+          # in memory.
+          all_pass_or_excluded &&= runner.diffs.empty?
+
+          merge_todo_audit_status(runner_status(runner, all_pass_or_excluded))
+        end
 
+        def runner_status(runner, all_pass_or_excluded)
           if runner.aborting?
             STATUS_INTERRUPTED
           elsif all_pass_or_excluded && runner.errors.empty?
@@ -39,6 +52,33 @@ module RuboCop
           end
         end
 
+        def merge_todo_audit_status(status)
+          return status if status == STATUS_INTERRUPTED || !@options[:report_unused_todo_entries]
+
+          audit_status = report_unused_todo_entries
+          status == STATUS_SUCCESS ? audit_status : status
+        end
+
+        def report_unused_todo_entries
+          audit = TodoAudit.new(@config_store, @options)
+          unused = audit.unused_entries
+
+          if unused.nil?
+            warn Rainbow("No `#{audit.todo_file}` found; nothing to audit.").yellow
+            return STATUS_SUCCESS
+          end
+          return STATUS_SUCCESS if unused.empty?
+
+          print_unused_todo_entries(audit.todo_file, unused)
+          STATUS_OFFENSES
+        end
+
+        def print_unused_todo_entries(todo_file, unused)
+          noun = unused.size == 1 ? 'entry' : 'entries'
+          warn Rainbow("\n#{unused.size} unused todo #{noun} found in `#{todo_file}`:").red
+          unused.each { |entry| warn "  #{entry.cop_name}: #{entry.path}" }
+        end
+
         def with_redirect
           if @options[:stderr]
             orig_stdout = $stdout
@@ -88,9 +128,20 @@ module RuboCop
           "#{Gem.loaded_specs['rubocop'].metadata['bug_tracker_uri']}\n"
         end
 
+        def print_diffs(diffs)
+          return if diffs.empty?
+          # Integration tools own stdout when they ask for a machine-readable
+          # format, so the diff would only corrupt their input.
+          return if INTEGRATION_FORMATTERS.include?(@options[:format])
+
+          output = @options[:stderr] ? $stderr : $stdout
+          output.puts
+          diffs.each { |diff| output.print(diff) }
+        end
+
         def maybe_print_corrected_source
           # Integration tools (like RubyMine) expect to have only the JSON result
-          # when specifying JSON format. Similar HTML and JUnit are targeted as well.
+          # when specifying JSON format. Similar HTML, JUnit and SARIF are targeted as well.
           # See: https://github.com/rubocop/rubocop/issues/8673
           return if INTEGRATION_FORMATTERS.include?(@options[:format])
 

data/lib/rubocop/cli/command/explain.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Explains what cops do, as described by {Cop::CopExplanation}.
+      # @api private
+      class Explain < Base
+        include CopNames
+
+        self.command_name = :explain
+
+        def initialize(env)
+          super
+
+          @config = @config_store.for(PathUtil.pwd)
+        end
+
+        def run
+          names = @options[:explain]
+
+          known_cop_classes(names).each_with_index do |cop_class, index|
+            puts if index.positive?
+            puts Cop::CopExplanation.new(cop_class, @config)
+          end
+
+          # Checked after printing, so a typo in a list does not cost you the
+          # explanations you asked for alongside it.
+          validate_cop_names!(names)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/list_enabled_cops_for.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Lists the cops that will inspect the given file or directory.
+      # @api private
+      class ListEnabledCopsFor < Base
+        self.command_name = :list_enabled_cops_for
+
+        def initialize(env)
+          super
+
+          # Load the configs so the require()s are done for custom cops
+          @config = @config_store.for(@options[:list_enabled_cops_for])
+        end
+
+        def run
+          print_available_cops
+        end
+
+        private
+
+        def print_available_cops
+          registry = Cop::Registry.global
+
+          registry.departments.sort.each do |department|
+            puts cops_of_department(registry, department).sort
+          end
+        end
+
+        def cops_of_department(registry, department)
+          registry.with_department(department)
+                  .map(&:cop_name)
+                  .select { |cop_name| @config.cop_enabled?(cop_name) }
+        end
+      end
+    end
+  end
+end