rubocop 1.91.0 → 1.92.2

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -59,15 +59,22 @@ module RuboCop
 
               plugin_config.make_excludes_absolute
 
-              # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin
-              # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` above
-              # carries such keys into each subsequent plugin's config, where `unset_nil: true`
-              # would delete them from the combined configuration.
-              ConfigLoader.merge_with_default(plugin_config, plugin_config_path, unset_nil: false)
+              merge_plugin_config_with_default(plugin_config, plugin_config_path)
             end
           end
         end
 
+        # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin
+        # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` carries
+        # such keys into each subsequent plugin's config, where `unset_nil: true` would
+        # delete them from the combined configuration. Preview is left to be applied when
+        # a project configuration is resolved against the defaults.
+        def merge_plugin_config_with_default(plugin_config, plugin_config_path)
+          ConfigLoader.merge_with_default(
+            plugin_config, plugin_config_path, unset_nil: false, resolve_preview: false
+          )
+        end
+
         def merge_plugin_config_into_all_cops!(rubocop_config, plugin_config)
           rubocop_config['AllCops'].merge!(plugin_config['AllCops'])
         end
@@ -98,18 +105,39 @@ module RuboCop
 
           case rules.type
           when :path
-            [ConfigLoader.load_file(rules.value, check: false), rules.value]
+            config = ConfigLoader.load_file(rules.value, check: false)
+            warn_about_obsolete_config(plugin, config)
+            [config, rules.value]
           when :object
             path = plugin.method(:rules).source_location[0]
             [Config.create(rules.value, path, check: true), path]
           when :error
-            plugin_name = plugin.about&.name || plugin.inspect
             error_message = rules.value.respond_to?(:message) ? rules.value.message : rules.value
 
-            raise "Plugin `#{plugin_name}' failed to load with error: #{error_message}"
+            raise "Plugin `#{plugin_name(plugin)}' failed to load with error: #{error_message}"
           end
         end
 
+        # Plugin configuration is loaded without validation, so an obsolete key in a plugin's
+        # defaults used to surface only later, against the user's own file, once the two had
+        # been merged. Report it here, while the path is still the plugin's, and name the
+        # plugin: the file lives inside an installed gem, so the fix is to report it upstream.
+        # It is a warning whatever the rule's severity: a stale plugin is not the user's
+        # mistake and must not stop the run.
+        def warn_about_obsolete_config(plugin, config)
+          messages = ConfigObsoletion.new(config).messages
+          return if messages.empty?
+
+          warn Rainbow(<<~WARNING).yellow
+            Warning: obsolete configuration found in the `#{plugin_name(plugin)}` plugin:
+            #{messages.join("\n")}
+          WARNING
+        end
+
+        def plugin_name(plugin)
+          plugin.about&.name || plugin.inspect
+        end
+
         # This is how we ensure "first-in wins": plugins can override AllCops settings that are
         # set by RuboCop's default configuration, but once a plugin sets an AllCop setting, they
         # have exclusive first-in-wins rights to that setting.

data/lib/rubocop/remote_config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'net/http'
 require 'time'
+require 'uri'
 
 module RuboCop
   # Common methods and behaviors for dealing with remote config files.
@@ -45,6 +45,9 @@ module RuboCop
     def request(uri = @uri, limit = 10, &block)
       raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
 
+      # Loaded here rather than at the top, since most runs never fetch a remote config.
+      require 'net/http'
+
       http = Net::HTTP.new(uri.hostname, uri.port)
       http.use_ssl = uri.instance_of?(URI::HTTPS)
 

data/lib/rubocop/result_cache.rb

@@ -59,9 +59,9 @@ module RuboCop
         puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, remove_count)
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EPERM, Errno::EROFS
         # This can happen if parallel RuboCop invocations try to remove the
-        # same files. No problem.
+        # same files, or if the cache can't be written to. No problem.
         puts $ERROR_INFO if verbose
       end
 
@@ -138,26 +138,17 @@ module RuboCop
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES, Errno::EROFS => e
+      rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache.\n  #{e.message}"
         return
       end
 
-      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
       # RuboCop must be in control of where its cached data is stored. A
       # symbolic link anywhere in the cache directory tree can be an
       # indication that a symlink attack is being waged.
       return if symlink_protection_triggered?(dir)
 
-      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
-        f.write(@cached_data.to_json(offenses))
-      end
-      # The preliminary path is used so that if there are multiple RuboCop
-      # processes trying to save data for the same inspected file
-      # simultaneously, the only problem we run in to is a competition who gets
-      # to write to the final file. The contents are the same, so no corruption
-      # of data should occur.
-      FileUtils.mv(preliminary_path, @path)
+      write_cache_file(offenses)
     end
 
     private
@@ -177,6 +168,22 @@ module RuboCop
       false
     end
 
+    def write_cache_file(offenses)
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
+      FileUtils.rm_f(preliminary_path)
+      warn "Couldn't write cache file. Continuing without cache.\n  #{e.message}"
+    end
+
     def file_checksum(file, config_store)
       stat = File.stat(file)
       return unavailable_checksum unless stat.file?

data/lib/rubocop/runner.rb

@@ -53,7 +53,7 @@ module RuboCop
       Lint/RedundantCopDisableDirective RedundantCopDisableDirective Lint
     ].freeze
 
-    attr_reader :errors, :warnings, :diffs
+    attr_reader :errors, :warnings
     attr_writer :aborting
 
     def initialize(options, config_store)
@@ -63,10 +63,20 @@ module RuboCop
       @warnings = []
       @aborting = false
       @inspected_files = []
-      @diffs = []
+      @diff_sources = {}
       @report_queue = {}
     end
 
+    # The `--diff` patches, one per file, from the source on disk (or stdin) to
+    # the source once every correction, redundant directive removal included,
+    # has been applied.
+    def diffs
+      @diffs ||= @diff_sources.filter_map do |file, (original_source, corrected_source)|
+        diff = UnifiedDiff.new(PathUtil.smart_path(file), original_source, corrected_source).to_s
+        diff unless diff.empty?
+      end
+    end
+
     def run(paths)
       @inspection_team_by_config = {}.compare_by_identity
 
@@ -101,9 +111,7 @@ module RuboCop
     def only_changed(target_files)
       return target_files unless @options[:changed]
 
-      changed = ChangedFiles.new(@options[:changed]).paths
-
-      target_files.select { |file| changed.include?(file) }.freeze
+      ChangedFiles.new(@options[:changed]).filter(target_files).freeze
     end
 
     def find_target_files(paths)
@@ -158,11 +166,12 @@ module RuboCop
 
     def inspect_files(files) # rubocop:disable Metrics/AbcSize
       formatter_set.started(files)
+      formatters_started = true
       file_iterator(files) do |file|
-        offenses = process_file(file)
+        offenses, problems = collect_problems { process_file(file) }
         succeeded = offenses.none? { |o| considered_failure?(o) && offense_displayed?(o) }
 
-        [offenses, succeeded]
+        [offenses, succeeded, problems]
       end
     ensure
       # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
@@ -171,17 +180,18 @@ module RuboCop
       if files.size > 1 && cached_run?
         ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
       end
-      formatter_set.finished(@inspected_files.freeze)
+      formatter_set.finished(@inspected_files.freeze) if formatters_started
       formatter_set.close_output_files
+      warn_about_elided_offenses
     end
 
     def file_iterator(files, &block)
       all_passed = true
 
       on_start = ->(file, _index) { file_started(file) }
-      on_finish = lambda do |file, index, (offenses, passed)|
+      on_finish = lambda do |file, index, (offenses, passed, problems)|
         all_passed &&= passed
-        finished_report(file, index, offenses)
+        finished_report(file, index, offenses, problems)
       end
 
       if run_in_parallel?(files)
@@ -195,8 +205,8 @@ module RuboCop
       all_passed
     end
 
-    def finished_report(file, index, offenses)
-      @report_queue[index] = [file, offenses]
+    def finished_report(file, index, offenses, problems)
+      @report_queue[index] = [file, offenses, problems]
       @next_index_to_report ||= 0
       while @report_queue.key?(@next_index_to_report)
         process_report_queue_entry(@next_index_to_report)
@@ -205,7 +215,10 @@ module RuboCop
     end
 
     def process_report_queue_entry(index)
-      file, offenses = @report_queue.delete(index)
+      file, offenses, (errors, warnings) = @report_queue.delete(index)
+      @errors.concat(errors)
+      @warnings.concat(warnings)
+      file_problems(file, errors, warnings) unless errors.empty? && warnings.empty?
       file_finished(file, offenses)
     end
 
@@ -269,6 +282,21 @@ module RuboCop
       paths.each { |path| puts PathUtil.relative_path(path) }
     end
 
+    # Keeps the errors and warnings a file causes apart from the rest of the
+    # run's. A parallel worker inspects files in a copy of the runner that is
+    # thrown away, so they have to travel back with the file's offenses.
+    def collect_problems
+      errors = @errors
+      warnings = @warnings
+      @errors = []
+      @warnings = []
+
+      [yield, [@errors, @warnings]]
+    ensure
+      @errors = errors
+      @warnings = warnings
+    end
+
     def process_file(file)
       file_offenses(file)
     rescue InfiniteCorrectionLoop => e
@@ -321,9 +349,11 @@ module RuboCop
         if redundant_updated
           # Do one extra inspection loop if any redundant disables were
           # removed. This is done in order to find rubocop:enable directives that
-          # have now become useless.
-          _source, new_offenses = do_inspection_loop(file)
-          offenses |= new_offenses
+          # have now become useless. It finds the offenses that are left again,
+          # located in the corrected source, so only the corrected ones are kept
+          # from before, as `inspect_and_correct` does.
+          _source, new_offenses = do_inspection_loop(file, team.updated_source)
+          offenses = offenses.select(&:corrected?) | new_offenses
         end
       end
       offenses
@@ -336,7 +366,9 @@ module RuboCop
       team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
       return if team.cops.empty?
 
-      team.cops.first.offenses_to_check = offenses
+      team.defer_corrections = @options[:diff]
+      team.cops.first.offenses_to_check = offenses.reject(&:corrected?)
+
       yield team
     end
 
@@ -369,6 +401,15 @@ module RuboCop
       formatter_set.file_started(file, cli_options: @options, config_store: @config_store)
     end
 
+    # Formatters get the messages without the colors added for the terminal.
+    def file_problems(file, errors, warnings)
+      formatter_set.file_problems(file, plain_messages(errors), plain_messages(warnings))
+    end
+
+    def plain_messages(problems)
+      problems.map { |problem| Rainbow::StringUtils.uncolor(problem.to_s) }
+    end
+
     def file_finished(file, offenses)
       @inspected_files << file
       offenses = offenses_to_report(offenses)
@@ -387,15 +428,15 @@ module RuboCop
       return unless cache
       # Caching results when a cop has crashed would prevent the crash in the
       # next run, since the cop would not be called then. We want crashes to
-      # show up the same in each run.
+      # show up the same in each run. Only this file's errors and warnings are
+      # visible here, see `collect_problems`.
       return if errors.any? || warnings.any?
 
       cache.save(offenses)
     end
 
-    def do_inspection_loop(file)
-      # We can reuse the prism result since the source did not change yet.
-      processed_source = get_processed_source(file, @prism_result)
+    def do_inspection_loop(file, source = nil)
+      processed_source = initial_processed_source(file, source)
       original_source = processed_source.raw_source
       # This variable is 2d array used to track corrected offenses after each
       # inspection iteration. This is used to output meaningful infinite loop
@@ -428,6 +469,15 @@ module RuboCop
       finalize_corrections(file, original_source, corrected_source)
     end
 
+    # `source` is the corrected source to continue from when the corrections
+    # are kept in memory rather than written to the file (`--diff`).
+    def initial_processed_source(file, source)
+      return get_processed_source(file, nil, source: source) if source
+
+      # We can reuse the prism result since the source did not change yet.
+      get_processed_source(file, @prism_result)
+    end
+
     def inspect_and_correct(processed_source, offenses_by_iteration)
       # The offenses that couldn't be corrected will be found again so we
       # only keep the corrected ones in order to avoid duplicate reporting.
@@ -445,24 +495,26 @@ module RuboCop
       if @options[:diff]
         record_diff(file, original_source, corrected_source)
       elsif corrected_source
-        File.write(file, corrected_source)
+        Util.replace_file_contents(file, corrected_source)
       end
     end
 
     # `--diff` reports what autocorrection would do instead of doing it. With
     # `--stdin` the corrected source is handed back through the options rather
-    # than deferred, so that is where the new source comes from.
+    # than deferred, so that is where the new source comes from. A file can go
+    # through more than one inspection loop, so the diff runs from the source
+    # the first loop started with to the one the last loop ended with.
     def record_diff(file, original_source, corrected_source)
-      new_source = @options[:stdin] || corrected_source
-      return unless original_source && new_source
+      return unless original_source
 
+      new_source = @options[:stdin] || corrected_source
       # The original source is the file as it is on disk, so the corrected one
       # has to go through the same line ending conversion `File.write` would
       # apply, or on Windows every single line reads as changed.
-      new_source = emulate_write_read_cycle(new_source)
+      new_source = new_source ? Util.emulate_write_read_cycle(new_source) : original_source
 
-      diff = UnifiedDiff.new(PathUtil.smart_path(file), original_source, new_source).to_s
-      @diffs << diff unless diff.empty?
+      sources = (@diff_sources[file] ||= [original_source])
+      sources[1] = new_source
     end
 
     def inspect_iteration(processed_source)
@@ -472,17 +524,6 @@ module RuboCop
       [team, offenses, updated_source_file]
     end
 
-    # When corrections were written to disk and read back between iterations,
-    # the text-mode write converted LF to CRLF on Windows, and cops like
-    # `Layout/EndOfLine` rely on seeing the source as it would be on disk.
-    # Apply the same conversion to the in-memory source. The final `File.write`
-    # still performs it for the file itself.
-    def emulate_write_read_cycle(source)
-      return source unless Platform.windows?
-
-      source.encode(source.encoding, crlf_newline: true)
-    end
-
     # Custom ruby extractors may derive their fragments from the file on
     # disk rather than from the passed processed source, so corrections can
     # only be kept in memory when the default extractor is used.
@@ -573,6 +614,12 @@ module RuboCop
       end
     end
 
+    # Lets a runner that is reused from run to run pick up a different `--only`
+    # or `--except`.
+    def forget_mobilized_cops
+      @mobilized_cop_classes = nil
+    end
+
     def mobilize_cop_badge?(badge, config)
       return false if badge.department == :Test
       return false if badge.match_name?(@options[:except])
@@ -589,7 +636,7 @@ module RuboCop
       %i[only except].each do |option|
         next unless @options[option]
 
-        @options[option].map! do |cop_name|
+        @options[option] = @options[option].map do |cop_name|
           Cop::Registry.qualified_cop_name(cop_name, "--#{option} option")
         end
       end
@@ -630,7 +677,28 @@ module RuboCop
     end
 
     def offenses_to_report(offenses)
-      offenses.select { |o| offense_displayed?(o) }
+      offenses = offenses.select { |o| offense_displayed?(o) }
+      offenses = offense_limit.filter(offenses) if offense_limit
+      offenses
+    end
+
+    # Files are reported in order, so which offenses survive the limit does not
+    # depend on how the run was parallelized.
+    def offense_limit
+      return @offense_limit if defined?(@offense_limit)
+
+      max = @options[:max_offenses_per_cop]
+      @offense_limit = (OffenseLimit.new(max.to_i) if max)
+    end
+
+    def warn_about_elided_offenses
+      elided = offense_limit&.elided_per_cop
+      return unless elided&.any?
+
+      warn Rainbow(
+        "#{elided.values.sum} more offenses were not reported because of " \
+        "--max-offenses-per-cop=#{offense_limit.max} (#{elided.keys.join(', ')})."
+      ).yellow
     end
 
     def supports_safe_autocorrect?(offense)
@@ -662,7 +730,7 @@ module RuboCop
 
       processed_source = if source
                            ProcessedSource.new(
-                             emulate_write_read_cycle(source),
+                             Util.emulate_write_read_cycle(source),
                              ruby_version,
                              file,
                              parser_engine: parser_engine

data/lib/rubocop/server/cache.rb

@@ -51,9 +51,9 @@ module RuboCop
             Pathname(project_dir).join(lockfile_name)
           end.find(&:exist?)
           version_data = lockfile_path&.read || RuboCop::Version::STRING
-          config_data = Pathname(
-            args_config_file_path || ConfigFinder.find_config_path(Dir.pwd)
-          ).read
+          config_path = Pathname(args_config_file_path || ConfigFinder.find_config_path(Dir.pwd))
+          # NOTE: A missing config file is reported by `RuboCop::CLI` with a friendly message.
+          config_data = config_path.exist? ? config_path.read : ''
           yaml = load_erb_templated_yaml(config_data)
 
           inherit_from_data = inherit_from_data(yaml)
@@ -112,8 +112,8 @@ module RuboCop
 
         def pid_running?
           Process.kill(0, pid_path(create_dir: false).read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG,
-               Errno::ENOTDIR
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EPERM, Errno::EROFS,
+               Errno::ENAMETOOLONG, Errno::ENOTDIR
           false
         end
 
@@ -181,7 +181,7 @@ module RuboCop
           yaml_code = ERB.new(content).result
 
           require 'yaml'
-          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true) || {}
         end
       end
     end

data/lib/rubocop/target_ruby.rb

@@ -100,15 +100,23 @@ module RuboCop
       def gemspec_filepath
         return @gemspec_filepath if defined?(@gemspec_filepath)
 
-        @gemspec_filepath =
-          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
-            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
-            # https://github.com/jruby/jruby/issues/8358
-            candidates = Pathname.glob("#{dir}/*.gemspec")
-            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
-            # the folder.
-            break candidates.first if candidates.one?
-          end
+        @gemspec_filepath = @config.traverse_directories_upwards(
+          @config.base_dir_for_path_parameters, ConfigFinder.project_root
+        ) do |dir|
+          candidates = gemspec_candidates(dir)
+
+          # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+          # the folder.
+          break candidates.first if candidates.one?
+        end
+      end
+
+      def gemspec_candidates(dir)
+        # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/8358
+        Pathname.glob("#{dir}/*.gemspec")
+      rescue SystemCallError
+        []
       end
 
       def version_from_gemspec_file(file)
@@ -179,6 +187,8 @@ module RuboCop
         return unless file && File.file?(file)
 
         File.read(file).match(pattern) { |md| md[:version].to_f }
+      rescue SystemCallError
+        nil
       end
 
       def version_file
@@ -250,6 +260,8 @@ module RuboCop
           result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
           return result.captures.first.to_f if result
         end
+      rescue SystemCallError
+        nil
       end
 
       def bundler_lock_file_path

data/lib/rubocop/util.rb

@@ -12,5 +12,74 @@ module RuboCop
     ensure
       $VERBOSE = old_verbose
     end
+
+    # The source as it reads back after `File.write`, which in text mode turns
+    # each LF into CRLF on Windows. Cops like `Layout/EndOfLine` have to see
+    # corrected code that way between correction passes, and so does anything
+    # that compares it with what a write leaves on disk. The final `File.write`
+    # still performs the conversion for the file itself.
+    def self.emulate_write_read_cycle(source)
+      return source unless Platform.windows?
+
+      source.encode(source.encoding, crlf_newline: true)
+    end
+
+    # Replaces the contents of `path` without a window in which the file is truncated
+    # but not yet rewritten, so that an interrupted run or a full disk cannot lose
+    # the original: the new contents are written next to the file and renamed over it,
+    # like `ResultCache#save`. `File.write` is used for the temporary file so text-mode
+    # semantics (the CRLF conversion on Windows) stay identical to a direct write.
+    # Where the temporary file cannot be created or renamed for lack of permission,
+    # a direct write is used as before.
+    def self.replace_file_contents(path, contents)
+      # Write through symlinks so that the rename replaces the real file and
+      # the symlink survives.
+      path = File.realpath(path)
+
+      # Opening a read-only file fails without truncating it, keeping the behavior
+      # a direct write always had.
+      return File.write(path, contents) unless File.writable?(path)
+
+      temp_path = "#{path}.#{Process.pid}.#{rand(1_000_000_000)}.rubocop.tmp"
+      begin
+        replace_via_temporary_file(path, temp_path, contents)
+      ensure
+        FileUtils.rm_f(temp_path)
+      end
+    rescue Errno::ENOENT
+      # The file vanished mid-run or is a dangling symlink: recreate it the way
+      # a direct write always has.
+      File.write(path, contents)
+    end
+
+    def self.replace_via_temporary_file(path, temp_path, contents)
+      # The directory refuses new files even though the file itself is writable,
+      # so a direct write is the only option left.
+      return File.write(path, contents) unless write_temporary_file(temp_path, contents)
+
+      begin
+        # A fresh file would get umask-default permissions on rename;
+        # keep the original's.
+        File.chmod(File.stat(path).mode, temp_path)
+        File.rename(temp_path, path)
+      rescue SystemCallError
+        # The replacement was refused, e.g. the file is open in another process on Windows.
+        # The contents already fit on disk, so a direct write is safe once the temporary copy
+        # no longer takes up that space.
+        FileUtils.rm_f(temp_path)
+        File.write(path, contents)
+      end
+    end
+    private_class_method :replace_via_temporary_file
+
+    # Space errors such as `ENOSPC` must propagate: a direct write would then
+    # truncate the file and fail, which is exactly the loss being avoided.
+    def self.write_temporary_file(temp_path, contents)
+      File.write(temp_path, contents)
+      true
+    rescue Errno::EACCES, Errno::EPERM
+      false
+    end
+    private_class_method :write_temporary_file
   end
 end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.91.0'
+    STRING = '1.92.2'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/lib/rubocop.rb

@@ -55,6 +55,8 @@ require_relative 'rubocop/cop/base'
 require_relative 'rubocop/cop/cop'
 require_relative 'rubocop/cop/commissioner'
 require_relative 'rubocop/cop/documentation'
+require_relative 'rubocop/cop/cop_documentation'
+require_relative 'rubocop/cop/cop_explanation'
 require_relative 'rubocop/cop/corrector'
 require_relative 'rubocop/cop/correctors'
 require_relative 'rubocop/cop/force'
@@ -117,12 +119,15 @@ require_relative 'rubocop/comment_config/disable_next'
 require_relative 'rubocop/comment_config/push_pop'
 require_relative 'rubocop/comment_config'
 require_relative 'rubocop/result_cache'
+require_relative 'rubocop/offense_limit'
 require_relative 'rubocop/runner'
 require_relative 'rubocop/cli'
 require_relative 'rubocop/cli/command'
 require_relative 'rubocop/cli/environment'
 require_relative 'rubocop/cli/command/base'
 require_relative 'rubocop/cli/command/auto_generate_config'
+require_relative 'rubocop/cli/command/cop_names'
+require_relative 'rubocop/cli/command/explain'
 require_relative 'rubocop/cli/command/execute_runner'
 require_relative 'rubocop/cli/command/init_dotfile'
 require_relative 'rubocop/cli/command/lsp'