rubocop 1.27.0 → 1.51.0

data/lib/rubocop/config.rb

@@ -21,24 +21,30 @@ module RuboCop
     DEFAULT_RAILS_VERSION = 5.0
     attr_reader :loaded_path
 
-    def initialize(hash = {}, loaded_path = nil)
+    def self.create(hash, path, check: true)
+      config = new(hash, path)
+      config.check if check
+
+      config
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def initialize(hash = RuboCop::ConfigLoader.default_configuration, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
-        qualified_cop_name = Cop::Registry.qualified_cop_name(cop, loaded_path)
-        cop_options = self[qualified_cop_name] || {}
+        cop_name = cop.respond_to?(:cop_name) ? cop.cop_name : cop
+        qualified_cop_name = Cop::Registry.qualified_cop_name(cop_name, loaded_path)
+        cop_options = self[qualified_cop_name].dup || {}
         cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
-        h[cop] = cop_options
+        h[cop] = h[cop_name] = cop_options
       end
       @hash = hash
       @validator = ConfigValidator.new(self)
-    end
-
-    def self.create(hash, path, check: true)
-      config = new(hash, path)
-      config.check if check
 
-      config
+      @badge_config_cache = {}.compare_by_identity
+      @clusivity_config_exists_cache = {}
     end
+    # rubocop:enable Metrics/AbcSize
 
     def loaded_features
       @loaded_features ||= ConfigLoader.loaded_features
@@ -116,14 +122,31 @@ module RuboCop
     # Note: the 'Enabled' attribute is calculated according to the department's
     # and 'AllCops' configuration; other attributes are not inherited.
     def for_cop(cop)
-      @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
+      @for_cop[cop]
     end
 
     # @return [Config] for the given cop merged with that of its department (if any)
     # Note: the 'Enabled' attribute is same as that returned by `for_cop`
     def for_badge(badge)
-      cop_config = for_cop(badge.to_s)
-      fetch(badge.department.to_s) { return cop_config }.merge(cop_config)
+      @badge_config_cache[badge] ||= begin
+        department_config = self[badge.department_name]
+        cop_config = for_cop(badge.to_s)
+        if department_config
+          department_config.merge(cop_config)
+        else
+          cop_config
+        end
+      end
+    end
+
+    # @return [Boolean] whether config for this badge has 'Include' or 'Exclude' keys
+    # @api private
+    def clusivity_config_for_badge?(badge)
+      exists = @clusivity_config_exists_cache[badge.to_s]
+      return exists unless exists.nil?
+
+      cop_config = for_badge(badge)
+      @clusivity_config_exists_cache[badge.to_s] = cop_config['Include'] || cop_config['Exclude']
     end
 
     # @return [Config] for the given department name.
@@ -146,6 +169,10 @@ module RuboCop
       for_all_cops['NewCops'] == 'enable'
     end
 
+    def active_support_extensions_enabled?
+      for_all_cops['ActiveSupportExtensionsEnabled']
+    end
+
     def file_to_include?(file)
       relative_file_path = path_relative_to_config(file)
 
@@ -211,7 +238,7 @@ module RuboCop
     # directory since that wouldn't work.
     def base_dir_for_path_parameters
       @base_dir_for_path_parameters ||=
-        if File.basename(loaded_path).start_with?('.rubocop') &&
+        if loaded_path && File.basename(loaded_path).start_with?('.rubocop') &&
            loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
           File.expand_path(File.dirname(loaded_path))
         else
@@ -238,7 +265,7 @@ module RuboCop
       return nil unless loaded_path
 
       base_path = base_dir_for_path_parameters
-      ['gems.locked', 'Gemfile.lock'].each do |file_name|
+      ['Gemfile.lock', 'gems.locked'].each do |file_name|
         path = find_file_upwards(file_name, base_path)
         return path if path
       end
@@ -257,6 +284,10 @@ module RuboCop
       end
     end
 
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
+    end
+
     private
 
     def target_rails_version_from_bundler_lock_file
@@ -268,16 +299,17 @@ module RuboCop
       return nil unless lock_file_path
 
       File.foreach(lock_file_path) do |line|
-        # If rails is in Gemfile.lock or gems.lock, there should be a line like:
-        #         rails (X.X.X)
-        result = line.match(/^\s+rails\s+\((\d+\.\d+)/)
+        # If Rails (or one of its frameworks) is in Gemfile.lock or gems.lock, there should be
+        # a line like:
+        #         railties (X.X.X)
+        result = line.match(/^\s+railties\s+\((\d+\.\d+)/)
         return result.captures.first.to_f if result
       end
     end
 
     def enable_cop?(qualified_cop_name, cop_options)
-      # If the cop is explicitly enabled, the other checks can be skipped.
-      return true if cop_options['Enabled'] == true
+      # If the cop is explicitly enabled or `Lint/Syntax`, the other checks can be skipped.
+      return true if cop_options['Enabled'] == true || qualified_cop_name == 'Lint/Syntax'
 
       department = department_of(qualified_cop_name)
       cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }

data/lib/rubocop/config_finder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'file_finder'
+
+module RuboCop
+  # This class has methods related to finding configuration path.
+  # @api private
+  class ConfigFinder
+    DOTFILE = '.rubocop.yml'
+    XDG_CONFIG = 'config.yml'
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+
+    class << self
+      include FileFinder
+
+      attr_writer :project_root
+
+      def find_config_path(target_dir)
+        find_project_dotfile(target_dir) || find_user_dotfile || find_user_xdg_config ||
+          DEFAULT_FILE
+      end
+
+      # Returns the path RuboCop inferred as the root of the project. No file
+      # searches will go past this directory.
+      def project_root
+        @project_root ||= find_project_root
+      end
+
+      private
+
+      def find_project_root
+        pwd = Dir.pwd
+        gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
+        return unless gems_file
+
+        File.dirname(gems_file)
+      end
+
+      def find_project_dotfile(target_dir)
+        find_file_upwards(DOTFILE, target_dir, project_root)
+      end
+
+      def find_user_dotfile
+        return unless ENV.key?('HOME')
+
+        file = File.join(Dir.home, DOTFILE)
+
+        return file if File.exist?(file)
+      end
+
+      def find_user_xdg_config
+        xdg_config_home = expand_path(ENV.fetch('XDG_CONFIG_HOME', '~/.config'))
+        xdg_config = File.join(xdg_config_home, 'rubocop', XDG_CONFIG)
+
+        return xdg_config if File.exist?(xdg_config)
+      end
+
+      def expand_path(path)
+        File.expand_path(path)
+      rescue ArgumentError
+        # Could happen because HOME or ID could not be determined. Fall back on
+        # using the path literally in that case.
+        path
+      end
+    end
+  end
+end

data/lib/rubocop/config_loader.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'yaml'
+require 'erb'
 require 'pathname'
+require 'yaml'
+require_relative 'config_finder'
 
 module RuboCop
   # Raised when a RuboCop configuration file is not found.
@@ -14,16 +16,24 @@ module RuboCop
   # during a run of the rubocop program, if files in several
   # directories are inspected.
   class ConfigLoader
-    DOTFILE = '.rubocop.yml'
-    XDG_CONFIG = 'config.yml'
+    DOTFILE = ConfigFinder::DOTFILE
     RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
     DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
 
     class << self
       include FileFinder
 
-      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops
-      attr_writer :default_configuration, :project_root
+      PENDING_BANNER = <<~BANNER
+        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
+
+        Please also note that you can opt-in to new cops by default by adding this to your config:
+          AllCops:
+            NewCops: enable
+      BANNER
+
+      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
+                    :ignore_unrecognized_cops
+      attr_writer :default_configuration
       attr_reader :loaded_features
 
       alias debug? debug
@@ -40,18 +50,18 @@ module RuboCop
 
         hash = load_yaml_configuration(path)
 
-        # Resolve requires first in case they define additional cops
         loaded_features = resolver.resolve_requires(path, hash)
         add_loaded_features(loaded_features)
 
-        add_missing_namespaces(path, hash)
-
         resolver.override_department_setting_for_cops({}, hash)
         resolver.resolve_inheritance_from_gems(hash)
         resolver.resolve_inheritance(path, hash, file, debug?)
-
         hash.delete('inherit_from')
 
+        # Adding missing namespaces only after resolving requires & inheritance,
+        # since both can introduce new cops that need to be considered here.
+        add_missing_namespaces(path, hash)
+
         Config.create(hash, path, check: check)
       end
 
@@ -93,8 +103,7 @@ module RuboCop
       # user's home directory is checked. If there's no .rubocop.yml
       # there either, the path to the default file is returned.
       def configuration_file_for(target_dir)
-        find_project_dotfile(target_dir) || find_user_dotfile ||
-          find_user_xdg_config || DEFAULT_FILE
+        ConfigFinder.find_config_path(target_dir)
       end
 
       def configuration_from_file(config_file, check: true)
@@ -110,17 +119,24 @@ module RuboCop
         end
 
         merge_with_default(config, config_file).tap do |merged_config|
-          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(merged_config)
+          unless possible_new_cops?(merged_config)
+            pending_cops = pending_cops_only_qualified(merged_config.pending_cops)
+            warn_on_pending_cops(pending_cops) unless pending_cops.empty?
+          end
         end
       end
 
+      def pending_cops_only_qualified(pending_cops)
+        pending_cops.select { |cop| Cop::Registry.qualified_cop?(cop.name) }
+      end
+
       def possible_new_cops?(config)
         disable_pending_cops || enable_pending_cops ||
           config.disabled_new_cops? || config.enabled_new_cops?
       end
 
       def add_excludes_from_files(config, config_file)
-        exclusion_file = find_last_file_upwards(DOTFILE, config_file, project_root)
+        exclusion_file = find_last_file_upwards(DOTFILE, config_file, ConfigFinder.project_root)
 
         return unless exclusion_file
         return if PathUtil.relative_path(exclusion_file) == PathUtil.relative_path(config_file)
@@ -136,23 +152,28 @@ module RuboCop
         end
       end
 
+      # @api private
+      def inject_defaults!(project_root)
+        path = File.join(project_root, 'config', 'default.yml')
+        config = load_file(path)
+        new_config = ConfigLoader.merge_with_default(config, path)
+        puts "configuration from #{path}" if debug?
+        @default_configuration = new_config
+      end
+
       # Returns the path RuboCop inferred as the root of the project. No file
       # searches will go past this directory.
+      # @deprecated Use `RuboCop::ConfigFinder.project_root` instead.
       def project_root
-        @project_root ||= find_project_root
-      end
-
-      PENDING_BANNER = <<~BANNER
-        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
+        warn Rainbow(<<~WARNING).yellow
+          `RuboCop::ConfigLoader.project_root` is deprecated and will be removed in RuboCop 2.0. \
+          Use `RuboCop::ConfigFinder.project_root` instead.
+        WARNING
 
-        Please also note that you can opt-in to new cops by default by adding this to your config:
-          AllCops:
-            NewCops: enable
-      BANNER
+        ConfigFinder.project_root
+      end
 
       def warn_on_pending_cops(pending_cops)
-        return if pending_cops.empty?
-
         warn Rainbow(PENDING_BANNER).yellow
 
         pending_cops.each { |cop| warn_pending_cop cop }
@@ -185,39 +206,6 @@ module RuboCop
         File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
       end
 
-      def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir, project_root)
-      end
-
-      def find_project_root
-        pwd = Dir.pwd
-        gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
-        return unless gems_file
-
-        File.dirname(gems_file)
-      end
-
-      def find_user_dotfile
-        return unless ENV.key?('HOME')
-
-        file = File.join(Dir.home, DOTFILE)
-        return file if File.exist?(file)
-      end
-
-      def find_user_xdg_config
-        xdg_config_home = expand_path(ENV.fetch('XDG_CONFIG_HOME', '~/.config'))
-        xdg_config = File.join(xdg_config_home, 'rubocop', XDG_CONFIG)
-        return xdg_config if File.exist?(xdg_config)
-      end
-
-      def expand_path(path)
-        File.expand_path(path)
-      rescue ArgumentError
-        # Could happen because HOME or ID could not be determined. Fall back on
-        # using the path literally in that case.
-        path
-      end
-
       def resolver
         @resolver ||= ConfigLoaderResolver.new
       end
@@ -258,18 +246,10 @@ module RuboCop
         raise
       end
 
-      if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
-        def yaml_safe_load!(yaml_code, filename)
-          YAML.safe_load(yaml_code,
-                         permitted_classes: [Regexp, Symbol],
-                         permitted_symbols: [],
-                         aliases: true,
-                         filename: filename)
-        end
-      else # Ruby < 2.6
-        def yaml_safe_load!(yaml_code, filename)
-          YAML.safe_load(yaml_code, [Regexp, Symbol], [], true, filename)
-        end
+      def yaml_safe_load!(yaml_code, filename)
+        YAML.safe_load(
+          yaml_code, permitted_classes: [Regexp, Symbol], aliases: true, filename: filename
+        )
       end
     end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
 require 'pathname'
+require 'yaml'
 
 module RuboCop
   # A help class for ConfigLoader that handles configuration resolution.
@@ -11,11 +11,7 @@ module RuboCop
       config_dir = File.dirname(path)
       hash.delete('require').tap do |loaded_features|
         Array(loaded_features).each do |feature|
-          if feature.start_with?('.')
-            require(File.join(config_dir, feature))
-          else
-            require(feature)
-          end
+          FeatureLoader.load(config_directory_path: config_dir, feature: feature)
         end
       end
     end
@@ -37,7 +33,7 @@ module RuboCop
                       inherit_mode: determine_inherit_mode(hash, k))
           end
           hash[k] = v
-          fix_include_paths(base_config.loaded_path, hash, path, k, v) if v.key?('Include')
+          fix_include_paths(base_config.loaded_path, hash, k, v) if v.key?('Include')
         end
       end
     end
@@ -46,13 +42,12 @@ module RuboCop
     # base configuration are relative to the directory where the base configuration file is. For the
     # derived configuration, we need to make those paths relative to where the derived configuration
     # file is.
-    def fix_include_paths(base_config_path, hash, path, key, value)
+    def fix_include_paths(base_config_path, hash, key, value)
       return unless File.basename(base_config_path).start_with?('.rubocop')
 
       base_dir = File.dirname(base_config_path)
-      derived_dir = File.dirname(path)
       hash[key]['Include'] = value['Include'].map do |include_path|
-        PathUtil.relative_path(File.join(base_dir, include_path), derived_dir)
+        PathUtil.relative_path(File.join(base_dir, include_path), Dir.pwd)
       end
     end
 
@@ -179,7 +174,7 @@ module RuboCop
 
     def determine_inherit_mode(hash, key)
       cop_cfg = hash[key]
-      local_inherit = cop_cfg.delete('inherit_mode') if cop_cfg.is_a?(Hash)
+      local_inherit = cop_cfg['inherit_mode'] if cop_cfg.is_a?(Hash)
       local_inherit || hash['inherit_mode'] || {}
     end
 
@@ -210,7 +205,11 @@ module RuboCop
     end
 
     def base_configs(path, inherit_from, file)
-      configs = Array(inherit_from).compact.map do |f|
+      inherit_froms = Array(inherit_from).compact.flat_map do |f|
+        PathUtil.glob?(f) ? Dir.glob(f) : f
+      end
+
+      configs = inherit_froms.map do |f|
         ConfigLoader.load_file(inherited_file(path, f, file))
       end
 

data/lib/rubocop/config_obsoletion/changed_parameter.rb

@@ -12,6 +12,11 @@ module RuboCop
 
         if alternative
           "#{base}\n`#{parameter}` has been renamed to `#{alternative.chomp}`."
+        elsif alternatives
+          "#{base}\n`#{parameter}` has been renamed to #{to_sentence(alternatives.map do |item|
+                                                                       "`#{item}`"
+                                                                     end,
+                                                                     connector: 'and/or')}."
         else
           "#{base}\n#{reason.chomp}"
         end

data/lib/rubocop/config_obsoletion/parameter_rule.rb

@@ -32,6 +32,10 @@ module RuboCop
         metadata['alternative']
       end
 
+      def alternatives
+        metadata['alternatives']
+      end
+
       def reason
         metadata['reason']
       end

data/lib/rubocop/config_obsoletion.rb

@@ -47,10 +47,15 @@ module RuboCop
 
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
-    def load_rules
+    def load_rules # rubocop:disable Metrics/AbcSize
       rules = self.class.files.each_with_object({}) do |filename, hash|
         hash.merge!(YAML.safe_load(File.read(filename))) do |_key, first, second|
-          first.merge(second)
+          case first
+          when Hash
+            first.merge(second)
+          when Array
+            first.concat(second)
+          end
         end
       end
 
@@ -63,11 +68,11 @@ module RuboCop
     # Cop rules are keyed by the name of the original cop
     def load_cop_rules(rules)
       rules.flat_map do |rule_type, data|
-        data.map do |cop_name, configuration|
+        data.filter_map do |cop_name, configuration|
           next unless configuration # allow configurations to be disabled with `CopName: ~`
 
           COP_RULE_CLASSES[rule_type].new(@config, cop_name, configuration)
-        end.compact
+        end
       end
     end
 

data/lib/rubocop/config_validator.rb

@@ -102,6 +102,22 @@ module RuboCop
     end
 
     def alert_about_unrecognized_cops(invalid_cop_names)
+      unknown_cops = list_unknown_cops(invalid_cop_names)
+
+      return if unknown_cops.empty?
+
+      if ConfigLoader.ignore_unrecognized_cops
+        warn Rainbow('The following cops or departments are not ' \
+                     'recognized and will be ignored:').yellow
+        warn unknown_cops.join("\n")
+
+        return
+      end
+
+      raise ValidationError, unknown_cops.join("\n")
+    end
+
+    def list_unknown_cops(invalid_cop_names)
       unknown_cops = []
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
@@ -119,7 +135,8 @@ module RuboCop
 
         unknown_cops << message
       end
-      raise ValidationError, unknown_cops.join("\n") if unknown_cops.any?
+
+      unknown_cops
     end
 
     def suggestion(name)
@@ -145,7 +162,7 @@ module RuboCop
       return unless syntax_config && default_config.merge(syntax_config) != default_config
 
       raise ValidationError,
-            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
+            "configuration for Lint/Syntax cop found in #{smart_loaded_path}\n" \
             'It\'s not possible to disable this cop.'
     end
 
@@ -227,7 +244,7 @@ module RuboCop
         next unless cop_config.is_a?(Hash)
         next unless cop_config['Safe'] == false && cop_config['SafeAutoCorrect'] == true
 
-        msg = 'Unsafe cops cannot have a safe auto-correction ' \
+        msg = 'Unsafe cops cannot have a safe autocorrection ' \
               "(section #{name} in #{smart_loaded_path})"
         raise ValidationError, msg
       end
@@ -248,8 +265,8 @@ module RuboCop
     # FIXME: Handling colors in exception messages like this is ugly.
     def msg_not_boolean(parent, key, value)
       "#{Rainbow('').reset}" \
-        "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow}" \
-        " is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+        "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow} " \
+        "is supposed to be a boolean and #{Rainbow(value).yellow} is not."
     end
   end
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -13,7 +13,7 @@ module RuboCop
       end
 
       def autocorrect_requested?
-        @options.fetch(:auto_correct, false)
+        @options.fetch(:autocorrect, false)
       end
 
       def correctable?
@@ -34,25 +34,33 @@ module RuboCop
 
         return false if cop_config['AutoCorrect'] == false
 
-        return safe_autocorrect? if @options.fetch(:safe_auto_correct, false)
+        # :safe_autocorrect is a derived option based on several command-line
+        # arguments - see RuboCop::Options#add_autocorrection_options
+        return safe_autocorrect? if @options.fetch(:safe_autocorrect, false)
 
         true
       end
 
       private
 
-      def disable_offense(range)
-        heredoc_range = surrounding_heredoc(range)
-        if heredoc_range
-          disable_offense_before_and_after(range_by_lines(heredoc_range))
+      def disable_offense(offense_range)
+        range = surrounding_heredoc(offense_range) || surrounding_percent_array(offense_range)
+
+        if range
+          disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_with_eol_or_surround_comment(offense_range)
+        end
+      end
+
+      def disable_offense_with_eol_or_surround_comment(range)
+        eol_comment = " # rubocop:todo #{cop_name}"
+        needed_line_length = (range.source_line + eol_comment).length
+
+        if needed_line_length <= max_line_length
+          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
         else
-          eol_comment = " # rubocop:todo #{cop_name}"
-          needed_line_length = (range.source_line + eol_comment).length
-          if needed_line_length <= max_line_length
-            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-          else
-            disable_offense_before_and_after(range_by_lines(range))
-          end
+          disable_offense_before_and_after(range_by_lines(range))
         end
       end
 
@@ -63,10 +71,20 @@ module RuboCop
         heredoc_nodes = processed_source.ast.each_descendant.select do |node|
           node.respond_to?(:heredoc?) && node.heredoc?
         end
-        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+        heredoc_nodes.map { |node| node.source_range.join(node.loc.heredoc_end) }
                      .find { |range| range.contains?(offense_range) }
       end
 
+      def surrounding_percent_array(offense_range)
+        return nil if offense_range.empty?
+
+        percent_array = processed_source.ast.each_descendant.select do |node|
+          node.array_type? && node.percent_literal?
+        end
+
+        percent_array.map(&:source_range).find { |range| range.overlaps?(offense_range) }
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length