rubocop 1.71.2 → 1.72.1

data/lib/rubocop/lsp/server.rb

@@ -22,8 +22,6 @@ module RuboCop
       def initialize(config_store)
         $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
 
-        RuboCop::LSP.enable
-
         @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
         @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
         @runtime = RuboCop::LSP::Runtime.new(config_store)

data/lib/rubocop/options.rb

@@ -243,6 +243,7 @@ module RuboCop
         option(opts, '--init')
         option(opts, '-c', '--config FILE')
         option(opts, '-d', '--debug')
+        option(opts, '--plugin FILE') { |f| plugin_feature(f) }
         option(opts, '-r', '--require FILE') { |f| require_feature(f) }
         option(opts, '--[no-]color')
         option(opts, '-v', '--version')
@@ -299,11 +300,25 @@ module RuboCop
       long_opt[2..].sub('[no-]', '').sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
 
-    def require_feature(file)
-      # If any features were added on the CLI from `--require`,
+    def plugin_feature(file)
+      # If any features were added on the CLI from `--plugin`,
       # add them to the config.
-      ConfigLoader.add_loaded_features(file)
-      require file
+      ConfigLoaderResolver.new.resolve_plugins(Config.new, file)
+    end
+
+    def require_feature(file)
+      if Plugin.plugin_capable?(file)
+        # NOTE: Compatibility for before plugins style.
+        warn Rainbow(<<~MESSAGE).yellow
+          #{file} gem supports plugin, use `--plugin` instead of `--require`.
+        MESSAGE
+        plugin_feature(file)
+      else
+        # If any features were added on the CLI from `--require`,
+        # add them to the config.
+        require file
+        ConfigLoader.add_loaded_features(file)
+      end
     end
   end
 
@@ -397,7 +412,7 @@ module RuboCop
       return if @options[:format] == 'junit'
 
       raise OptionArgumentError,
-            format('--display-only-failed can only be used together with --format junit.')
+            '--display-only-failed can only be used together with --format junit.'
     end
 
     def validate_display_only_correctable_and_autocorrect
@@ -415,14 +430,13 @@ module RuboCop
                 !@options.key?(:display_only_safe_correctable)
 
       raise OptionArgumentError,
-            format('--display-only-failed cannot be used together with other display options.')
+            '--display-only-failed cannot be used together with other display options.'
     end
 
     def validate_lsp_and_editor_mode
       return if !@options.key?(:lsp) || !@options.key?(:editor_mode)
 
-      raise OptionArgumentError,
-            format('Do not specify `--editor-mode` as it is redundant in `--lsp`.')
+      raise OptionArgumentError, 'Do not specify `--editor-mode` as it is redundant in `--lsp`.'
     end
 
     def validate_autocorrect
@@ -436,7 +450,7 @@ module RuboCop
       return unless @options.key?(:disable_uncorrectable)
 
       raise OptionArgumentError,
-            format('--disable-uncorrectable can only be used together with --autocorrect.')
+            '--disable-uncorrectable can only be used together with --autocorrect.'
     end
 
     def disable_parallel_when_invalid_option_combo
@@ -504,6 +518,7 @@ module RuboCop
       only_guide_cops:                  ['Run only cops for rules that link to a',
                                          'style guide.'],
       except:                           'Exclude the given cop(s).',
+      plugin:                           'Load a RuboCop plugin.',
       require:                          'Require Ruby file.',
       config:                           'Specify configuration file.',
       auto_gen_config:                  ['Generate a configuration file acting as a',
@@ -542,8 +557,8 @@ module RuboCop
       only_recognized_file_types:       ['Inspect files given on the command line only if',
                                          'they are listed in `AllCops/Include` parameters',
                                          'of user configuration or default configuration.'],
-      ignore_disable_comments:          ['Run cops even when they are disabled locally',
-                                         'by a `rubocop:disable` directive.'],
+      ignore_disable_comments:          ['Report offenses even if they have been manually disabled',
+                                         'with a `rubocop:disable` or `rubocop:todo` directive.'],
       ignore_parent_exclusion:          ['Prevent from inheriting `AllCops/Exclude` from',
                                          'parent folders.'],
       ignore_unrecognized_cops:         ['Ignore unrecognized cops or departments in the config.'],

data/lib/rubocop/path_util.rb

@@ -28,6 +28,10 @@ module RuboCop
         end
     end
 
+    def remote_file?(uri)
+      uri.start_with?('http://', 'https://')
+    end
+
     SMART_PATH_CACHE = {} # rubocop:disable Style/MutableConstant
     private_constant :SMART_PATH_CACHE
 

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'lint_roller/context'
+require_relative 'not_supported_error'
+
+module RuboCop
+  module Plugin
+    # A class for integrating plugin configurations into RuboCop.
+    # Handles configuration merging, validation, and compatibility for plugins.
+    # @api private
+    class ConfigurationIntegrator
+      class << self
+        def integrate_plugins_into_rubocop_config(rubocop_config, plugins)
+          default_config = ConfigLoader.default_configuration
+          runner_context = create_context(rubocop_config)
+
+          validate_plugins!(plugins, runner_context)
+
+          plugin_config = combine_rubocop_configs(default_config, runner_context, plugins).to_h
+
+          merge_plugin_config_into_all_cops!(default_config, plugin_config)
+          merge_plugin_config_into_default_config!(default_config, plugin_config)
+        end
+
+        private
+
+        def create_context(rubocop_config)
+          LintRoller::Context.new(
+            runner: :rubocop,
+            runner_version: Version.version,
+            engine: :rubocop,
+            engine_version: Version.version,
+            target_ruby_version: rubocop_config.target_ruby_version
+          )
+        end
+
+        def validate_plugins!(plugins, runner_context)
+          unsupported_plugins = plugins.reject { |plugin| plugin.supported?(runner_context) }
+          return if unsupported_plugins.none?
+
+          raise Plugin::NotSupportedError, unsupported_plugins
+        end
+
+        def combine_rubocop_configs(default_config, runner_context, plugins)
+          fake_out_rubocop_default_configuration(default_config) do |fake_config|
+            all_cop_keys_configured_by_plugins = []
+
+            plugins.reduce(fake_config) do |combined_config, plugin|
+              RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, combined_config)
+
+              print 'Plugin ' if ConfigLoader.debug
+
+              plugin_config, plugin_config_path = load_plugin_rubocop_config(plugin, runner_context)
+
+              plugin_config['AllCops'], all_cop_keys_configured_by_plugins = merge_all_cop_settings(
+                combined_config['AllCops'], plugin_config['AllCops'],
+                all_cop_keys_configured_by_plugins
+              )
+
+              ConfigLoader.merge_with_default(plugin_config, plugin_config_path)
+            end
+          end
+        end
+
+        def merge_plugin_config_into_all_cops!(rubocop_config, plugin_config)
+          rubocop_config['AllCops'].merge!(plugin_config['AllCops'])
+        end
+
+        def merge_plugin_config_into_default_config!(default_config, plugin_config)
+          plugin_config.each do |key, value|
+            default_config[key] = if default_config[key].is_a?(Hash)
+                                    resolver.merge(default_config[key], value)
+                                  else
+                                    value
+                                  end
+          end
+        end
+
+        def fake_out_rubocop_default_configuration(default_config)
+          orig_default_config = ConfigLoader.instance_variable_get(:@default_configuration)
+
+          result = yield default_config
+
+          ConfigLoader.instance_variable_set(:@default_configuration, orig_default_config)
+
+          result
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def load_plugin_rubocop_config(plugin, runner_context)
+          rules = plugin.rules(runner_context)
+
+          case rules.type
+          when :path
+            [ConfigLoader.load_file(rules.value, check: false), 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}"
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # 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.
+        #
+        # The one exception to this are array fields, because we don't want to
+        # overwrite the AllCops defaults but rather munge the arrays (`existing |
+        # new`) to allow plugins to add to the array, for example Include and
+        # Exclude paths and patterns.
+        def merge_all_cop_settings(existing_all_cops, new_all_cops, already_configured_keys)
+          return [existing_all_cops, already_configured_keys] unless new_all_cops.is_a?(Hash)
+
+          combined_all_cops = existing_all_cops.dup
+          combined_configured_keys = already_configured_keys.dup
+
+          new_all_cops.each do |key, value|
+            if combined_all_cops[key].is_a?(Array) && value.is_a?(Array)
+              combined_all_cops[key] |= value
+              combined_configured_keys |= [key]
+            elsif !combined_configured_keys.include?(key)
+              combined_all_cops[key] = value
+              combined_configured_keys << key
+            end
+          end
+
+          [combined_all_cops, combined_configured_keys]
+        end
+
+        def resolver
+          @resolver ||= ConfigLoaderResolver.new
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/load_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Plugin
+    # An exception raised when a plugin fails to load.
+    # @api private
+    class LoadError < Error
+      def initialize(plugin_name)
+        super
+
+        @plugin_name = plugin_name
+      end
+
+      def message
+        <<~MESSAGE
+          Failed to load plugin `#{@plugin_name}` because the corresponding plugin class could not be determined for instantiation.
+          Try upgrading it first (e.g., `bundle update #{@plugin_name}`).
+          If `#{@plugin_name}` is not yet a plugin, use `require: #{@plugin_name}` instead of `plugins: `#{@plugin_name}` in your configuration.
+
+          For further assistance, check with the developer regarding the following points:
+          https://docs.rubocop.org/rubocop/plugin_migration_guide.html
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/loader.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../feature_loader'
+require_relative 'load_error'
+
+module RuboCop
+  module Plugin
+    # A class for loading and resolving plugins.
+    # @api private
+    class Loader
+      # rubocop:disable Layout/LineLength
+      DEFAULT_PLUGIN_CONFIG = {
+        'enabled' => true,
+        'require_path' => nil, # If not set, will be set to the plugin name
+        'plugin_class_name' => nil # If not set, looks for gemspec `spec.metadata["default_lint_roller_plugin"]`
+      }.freeze
+
+      # rubocop:enable Layout/LineLength
+      class << self
+        def load(plugins)
+          normalized_plugin_configs = normalize(plugins)
+          normalized_plugin_configs.filter_map do |plugin_name, plugin_config|
+            next unless plugin_config['enabled']
+
+            plugin_class = constantize_plugin_from(plugin_name, plugin_config)
+
+            plugin_class.new(plugin_config)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def normalize(plugin_configs)
+          plugin_configs.to_h do |plugin_config|
+            if plugin_config == Plugin::OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+              warn Rainbow(<<~MESSAGE).yellow
+                Specify `rubocop-internal_affairs` instead of `rubocop/cop/internal_affairs` in your configuration.
+              MESSAGE
+              plugin_config = Plugin::INTERNAL_AFFAIRS_PLUGIN_NAME
+            end
+
+            if plugin_config.is_a?(Hash)
+              plugin_name = plugin_config.keys.first
+
+              [
+                plugin_name, DEFAULT_PLUGIN_CONFIG.merge(
+                  { 'require_path' => plugin_name }, plugin_config.values.first
+                )
+              ]
+            # NOTE: Compatibility is maintained when `require: rubocop/cop/internal_affairs` remains
+            # specified in `.rubocop.yml`.
+            elsif (builtin_plugin_config = Plugin::BUILTIN_INTERNAL_PLUGINS[plugin_config])
+              [plugin_config, builtin_plugin_config]
+            else
+              [plugin_config, DEFAULT_PLUGIN_CONFIG.merge('require_path' => plugin_config)]
+            end
+          end
+        end
+
+        def constantize_plugin_from(plugin_name, plugin_config)
+          if plugin_name.is_a?(String) || plugin_name.is_a?(Symbol)
+            constantize(plugin_name, plugin_config)
+          else
+            plugin_name
+          end
+        end
+
+        # rubocop:enable Metrics/MethodLength
+        def constantize(plugin_name, plugin_config)
+          require_plugin(plugin_config['require_path'])
+
+          if (constant_name = plugin_config['plugin_class_name'])
+            begin
+              Kernel.const_get(constant_name)
+            rescue StandardError
+              raise <<~MESSAGE
+                Failed while configuring plugin `#{plugin_name}': no constant with name `#{constant_name}' was found.
+              MESSAGE
+            end
+          else
+            constantize_plugin_from_gemspec_metadata(plugin_name)
+          end
+        end
+
+        def require_plugin(require_path)
+          FeatureLoader.load(config_directory_path: Dir.pwd, feature: require_path)
+        end
+
+        def constantize_plugin_from_gemspec_metadata(plugin_name)
+          plugin_class_name = Gem.loaded_specs[plugin_name].metadata['default_lint_roller_plugin']
+
+          Kernel.const_get(plugin_class_name)
+        rescue LoadError, StandardError
+          raise Plugin::LoadError, plugin_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/not_supported_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Plugin
+    # An exception raised when a plugin is not supported by the RuboCop engine.
+    # @api private
+    class NotSupportedError < Error
+      def initialize(unsupported_plugins)
+        super
+
+        @unsupported_plugins = unsupported_plugins
+      end
+
+      def message
+        if @unsupported_plugins.one?
+          about = @unsupported_plugins.first.about
+
+          "#{about.name} #{about.version} is not a plugin supported by RuboCop engine."
+        else
+          unsupported_plugin_names = @unsupported_plugins.map do |plugin|
+            "#{plugin.about.name} #{plugin.about.version}"
+          end.join(', ')
+
+          "#{unsupported_plugin_names} are not plugins supported by RuboCop engine."
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'plugin/configuration_integrator'
+require_relative 'plugin/loader'
+
+module RuboCop
+  # Provides a plugin for RuboCop extensions that conform to lint_roller.
+  # https://github.com/standardrb/lint_roller
+  # @api private
+  module Plugin
+    BUILTIN_INTERNAL_PLUGINS = {
+      'rubocop-internal_affairs' => {
+        'enabled' => true,
+        'require_path' => 'rubocop/cop/internal_affairs/plugin',
+        'plugin_class_name' => 'RuboCop::InternalAffairs::Plugin'
+      }
+    }.freeze
+    INTERNAL_AFFAIRS_PLUGIN_NAME = Plugin::BUILTIN_INTERNAL_PLUGINS.keys.first
+    OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME = 'rubocop/cop/internal_affairs'
+
+    class << self
+      def plugin_capable?(feature_name)
+        return true if BUILTIN_INTERNAL_PLUGINS.key?(feature_name)
+        return true if feature_name == OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+        return false unless (gem = Gem.loaded_specs[feature_name])
+
+        !!gem.metadata['default_lint_roller_plugin']
+      end
+
+      def integrate_plugins(rubocop_config, plugins)
+        plugins = Plugin::Loader.load(plugins)
+
+        ConfigurationIntegrator.integrate_plugins_into_rubocop_config(rubocop_config, plugins)
+
+        plugins
+      end
+    end
+  end
+end

data/lib/rubocop/rake_task.rb

@@ -12,7 +12,8 @@ module RuboCop
   # Use global Rake namespace here to avoid namespace issues with custom
   # rubocop-rake tasks
   class RakeTask < ::Rake::TaskLib
-    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :plugins, :requires,
+                  :options
 
     def initialize(name = :rubocop, *args, &task_block)
       super()
@@ -54,6 +55,7 @@ module RuboCop
 
     def full_options
       formatters.map { |f| ['--format', f] }.flatten
+                .concat(plugins.map { |plugin| ['--plugin', plugin] }.flatten)
                 .concat(requires.map { |r| ['--require', r] }.flatten)
                 .concat(options.flatten)
                 .concat(patterns)
@@ -64,6 +66,7 @@ module RuboCop
       @verbose = true
       @fail_on_error = true
       @patterns = []
+      @plugins = []
       @requires = []
       @options = []
       @formatters = []

data/lib/rubocop/rspec/cop_helper.rb

@@ -13,6 +13,13 @@ module CopHelper
   let(:parser_engine) { ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym }
   let(:rails_version) { false }
 
+  before(:all) do
+    plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
+      feature_name if feature_specification.metadata['default_lint_roller_plugin']
+    end
+    RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
+  end
+
   def inspect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}

data/lib/rubocop/server/cache.rb

@@ -2,8 +2,10 @@
 
 require 'digest'
 require 'pathname'
+require 'yaml'
 require_relative '../cache_config'
 require_relative '../config_finder'
+require_relative '../path_util'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -50,9 +52,11 @@ module RuboCop
           end.find(&:exist?)
           version_data = lockfile_path&.read || RuboCop::Version::STRING
           config_data = Pathname(ConfigFinder.find_config_path(Dir.pwd)).read
-          todo_data = (rubocop_todo = Pathname('.rubocop_todo.yml')).exist? ? rubocop_todo.read : ''
+          yaml = YAML.safe_load(config_data, permitted_classes: [Regexp, Symbol], aliases: true)
+          inherit_from_data = inherit_from_data(yaml)
+          require_data = require_data(yaml)
 
-          Digest::SHA1.hexdigest(version_data + config_data + todo_data)
+          Digest::SHA1.hexdigest(version_data + config_data + inherit_from_data + require_data)
         end
         # rubocop:enable Metrics/AbcSize
 
@@ -164,6 +168,35 @@ module RuboCop
         def write_version_file(version)
           version_path.write(version)
         end
+
+        def inherit_from_data(yaml)
+          return '' unless (inherit_from_paths = yaml['inherit_from'])
+
+          Array(inherit_from_paths).map do |path|
+            next if PathUtil.remote_file?(path)
+
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        def require_data(yaml)
+          return '' unless (require_paths = yaml['require'])
+
+          Array(require_paths).map do |path|
+            # NOTE: This targets only relative or absolute path specifications.
+            # For example, specifications like `require: rubocop-performance`,
+            # which can be loaded from `$LOAD_PATH`, are ignored.
+            next unless path.start_with?('.', '/')
+
+            # NOTE: `.so` files are not typically specified, so only `.rb` files are targeted.
+            path = "#{path}.rb" unless path.end_with?('.rb')
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
       end
     end
   end

data/lib/rubocop/server/cli.rb

@@ -86,7 +86,7 @@ module RuboCop
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def run_command(server_command, detach:)
         case server_command
         when '--server'
@@ -107,7 +107,7 @@ module RuboCop
           Server::ClientCommand::Status.new.run
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       def fetch_cache_root_path_from(arguments)
         cache_root = arguments.detect { |argument| argument.start_with?('--cache-root') }

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.71.2'
+    STRING = '1.72.1'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
@@ -63,9 +63,21 @@ module RuboCop
     end
 
     # @api private
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.extension_versions(env)
+      plugins = config_for_pwd(env).loaded_plugins
+      plugin_versions = plugins.filter_map do |plugin|
+        next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
+        next unless (plugin_name = plugin.about.name)
+
+        "  - #{plugin_name} #{plugin.about.version}"
+      end
+
+      # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
+      # don't support plugins. It should be removed in future once the old style becomes obsolete.
       features = config_for_pwd(env).loaded_features.sort
-      features.filter_map do |loaded_feature|
+      features -= plugins.map { |plugin| plugin.about.name }
+      feature_versions = features.filter_map do |loaded_feature|
         next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
 
         # Get the expected name of the folder containing the extension code.
@@ -84,7 +96,10 @@ module RuboCop
 
         "  - #{loaded_feature} #{feature_version}"
       end
+
+      plugin_versions + feature_versions
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     # @api private
     def self.target_ruby_version(env)

data/lib/rubocop.rb

@@ -304,6 +304,7 @@ require_relative 'rubocop/cop/lint/constant_definition_in_block'
 require_relative 'rubocop/cop/lint/constant_overwritten_in_rescue'
 require_relative 'rubocop/cop/lint/constant_reassignment'
 require_relative 'rubocop/cop/lint/constant_resolution'
+require_relative 'rubocop/cop/lint/cop_directive_syntax'
 require_relative 'rubocop/cop/lint/debugger'
 require_relative 'rubocop/cop/lint/deprecated_class_methods'
 require_relative 'rubocop/cop/lint/deprecated_constants'
@@ -384,6 +385,7 @@ require_relative 'rubocop/cop/lint/redundant_require_statement'
 require_relative 'rubocop/cop/lint/redundant_safe_navigation'
 require_relative 'rubocop/cop/lint/redundant_splat_expansion'
 require_relative 'rubocop/cop/lint/redundant_string_coercion'
+require_relative 'rubocop/cop/lint/redundant_type_conversion'
 require_relative 'rubocop/cop/lint/redundant_with_index'
 require_relative 'rubocop/cop/lint/redundant_with_object'
 require_relative 'rubocop/cop/lint/refinement_import_methods'
@@ -405,6 +407,7 @@ require_relative 'rubocop/cop/lint/shadowed_exception'
 require_relative 'rubocop/cop/lint/shadowing_outer_local_variable'
 require_relative 'rubocop/cop/lint/struct_new_override'
 require_relative 'rubocop/cop/lint/suppressed_exception'
+require_relative 'rubocop/cop/lint/suppressed_exception_in_number_conversion'
 require_relative 'rubocop/cop/lint/symbol_conversion'
 require_relative 'rubocop/cop/lint/syntax'
 require_relative 'rubocop/cop/lint/to_enum_arguments'
@@ -425,6 +428,7 @@ require_relative 'rubocop/cop/lint/uri_escape_unescape'
 require_relative 'rubocop/cop/lint/uri_regexp'
 require_relative 'rubocop/cop/lint/useless_access_modifier'
 require_relative 'rubocop/cop/lint/useless_assignment'
+require_relative 'rubocop/cop/lint/useless_constant_scoping'
 require_relative 'rubocop/cop/lint/useless_defined'
 require_relative 'rubocop/cop/lint/useless_else_without_rescue'
 require_relative 'rubocop/cop/lint/useless_method_definition'
@@ -604,6 +608,7 @@ require_relative 'rubocop/cop/style/redundant_each'
 require_relative 'rubocop/cop/style/redundant_fetch_block'
 require_relative 'rubocop/cop/style/redundant_file_extension_in_require'
 require_relative 'rubocop/cop/style/redundant_filter_chain'
+require_relative 'rubocop/cop/style/redundant_format'
 require_relative 'rubocop/cop/style/redundant_heredoc_delimiter_quotes'
 require_relative 'rubocop/cop/style/redundant_initialize'
 require_relative 'rubocop/cop/style/redundant_interpolation_unfreeze'