rubocop 0.51.0 → 0.87.0

data/lib/rubocop/config_loader.rb

@@ -4,111 +4,87 @@ require 'yaml'
 require 'pathname'
 
 module RuboCop
+  # Raised when a RuboCop configuration file is not found.
+  class ConfigNotFoundError < Error
+  end
+
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
   # file from which it was read. Several different Configs can be used
   # during a run of the rubocop program, if files in several
   # directories are inspected.
   class ConfigLoader
-    DOTFILE = '.rubocop.yml'.freeze
+    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')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'.freeze
 
     class << self
-      include ConfigLoaderResolver
+      include FileFinder
 
-      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion
-      attr_writer :root_level # The upwards search is stopped at this level.
+      attr_accessor :debug, :ignore_parent_exclusion,
+                    :disable_pending_cops, :enable_pending_cops
       attr_writer :default_configuration
 
       alias debug? debug
-      alias auto_gen_config? auto_gen_config
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
-        @debug = @auto_gen_config = @root_level = nil
+        @debug = nil
+        FileFinder.root_level = nil
       end
 
-      def load_file(file)
-        return if file.nil?
-        path = File.absolute_path(
-          file.is_a?(RemoteConfig) ? file.file : file
-        )
+      def load_file(file) # rubocop:disable Metrics/AbcSize
+        path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
 
         hash = load_yaml_configuration(path)
 
         # Resolve requires first in case they define additional cops
-        resolve_requires(path, hash)
+        resolver.resolve_requires(path, hash)
 
         add_missing_namespaces(path, hash)
-        target_ruby_version_to_f!(hash)
 
-        resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
-        resolve_inheritance(path, hash, file)
+        resolver.override_department_setting_for_cops({}, hash)
+        resolver.resolve_inheritance_from_gems(hash)
+        resolver.resolve_inheritance(path, hash, file, debug?)
 
         hash.delete('inherit_from')
 
-        create_config(hash, path)
+        Config.create(hash, path)
       end
 
-      def create_config(hash, path)
-        config = Config.new(hash, path)
-
-        config.deprecation_check do |deprecation_message|
-          warn("#{path} - #{deprecation_message}")
+      def load_yaml_configuration(absolute_path)
+        file_contents = read_file(absolute_path)
+        yaml_code = Dir.chdir(File.dirname(absolute_path)) do
+          ERB.new(file_contents).result
         end
+        check_duplication(yaml_code, absolute_path)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
 
-        config.validate
-        config.make_excludes_absolute
-        config
+        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+
+        hash
       end
 
-      # rubocop:disable Performance/HashEachMethods
       def add_missing_namespaces(path, hash)
-        hash.keys.each do |key|
+        # Using `hash.each_key` will cause the
+        # `can't add a new key into hash during iteration` error
+        hash_keys = hash.keys
+        hash_keys.each do |key|
           q = Cop::Cop.qualified_cop_name(key, path)
           next if q == key
 
           hash[q] = hash.delete(key)
         end
       end
-      # rubocop:enable Performance/HashEachMethods
 
       # Return a recursive merge of two hashes. That is, a normal hash merge,
       # with the addition that any value that is a hash, and occurs in both
       # arguments, will also be merged. And so on.
       def merge(base_hash, derived_hash)
-        result = base_hash.merge(derived_hash)
-        keys_appearing_in_both = base_hash.keys & derived_hash.keys
-        keys_appearing_in_both.each do |key|
-          next unless base_hash[key].is_a?(Hash)
-          result[key] = merge(base_hash[key], derived_hash[key])
-        end
-        result
-      end
-
-      def base_configs(path, inherit_from, file)
-        configs = Array(inherit_from).compact.map do |f|
-          load_file(inherited_file(path, f, file))
-        end
-
-        configs.compact
-      end
-
-      def inherited_file(path, inherit_from, file)
-        regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
-        if inherit_from =~ /\A#{regex}\z/
-          f = RemoteConfig.new(inherit_from, File.dirname(path))
-        elsif file.is_a?(RemoteConfig)
-          f = file.inherit_from_remote(inherit_from, path)
-        else
-          f = File.expand_path(inherit_from, File.dirname(path))
-
-          return if auto_gen_config? && f.include?(AUTO_GENERATED_FILE)
-          print 'Inheriting ' if debug?
-        end
-        f
+        resolver.merge(base_hash, derived_hash)
       end
 
       # Returns the path of .rubocop.yml searching upwards in the
@@ -117,24 +93,38 @@ 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)
-        config_files_in_path(target_dir).first || DEFAULT_FILE
+        find_project_dotfile(target_dir) || find_user_dotfile ||
+          find_user_xdg_config || DEFAULT_FILE
       end
 
       def configuration_from_file(config_file)
-        config = load_file(config_file)
-        return config if config_file == DEFAULT_FILE
+        return default_configuration if config_file == DEFAULT_FILE
 
+        config = load_file(config_file)
         if ignore_parent_exclusion?
           print 'Ignoring AllCops/Exclude from parent folders' if debug?
         else
           add_excludes_from_files(config, config_file)
         end
-        merge_with_default(config, config_file)
+
+        merge_with_default(config, config_file).tap do |merged_config|
+          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(config)
+        end
+      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)
-        found_files = config_files_in_path(config_file)
-        return unless found_files.any? && found_files.last != config_file
+        found_files = find_files_upwards(DOTFILE, config_file)
+        found_files = [find_user_dotfile, find_user_xdg_config].compact if found_files.empty?
+
+        return if found_files.empty?
+        return if PathUtil.relative_path(found_files.last) ==
+                  PathUtil.relative_path(config_file)
+
         print 'AllCops/Exclude ' if debug?
         config.add_excludes_from_higher_level(load_file(found_files.last))
       end
@@ -146,119 +136,98 @@ module RuboCop
                                    end
       end
 
-      # Merges the given configuration with the default one. If
-      # AllCops:DisabledByDefault is true, it changes the Enabled params so
-      # that only cops from user configuration are enabled.
-      # If AllCops::EnabledByDefault is true, it changes the Enabled params
-      # so that only cops explicitly disabled in user configuration are
-      # disabled.
-      def merge_with_default(config, config_file)
-        default_configuration = self.default_configuration
-
-        disabled_by_default = config.for_all_cops['DisabledByDefault']
-        enabled_by_default = config.for_all_cops['EnabledByDefault']
-
-        if disabled_by_default || enabled_by_default
-          default_configuration = transform(default_configuration) do |params|
-            params.merge('Enabled' => !disabled_by_default)
-          end
-        end
+      def warn_on_pending_cops(pending_cops)
+        return if pending_cops.empty?
+
+        warn Rainbow('The following cops were added to RuboCop, but are not ' \
+                     'configured. Please set Enabled to either `true` or ' \
+                     '`false` in your `.rubocop.yml` file:').yellow
+
+        pending_cops.each do |cop|
+          version = cop.metadata['VersionAdded'] || 'N/A'
 
-        if disabled_by_default
-          config = handle_disabled_by_default(config, default_configuration)
+          warn Rainbow(" - #{cop.name} (#{version})").yellow
         end
 
-        Config.new(merge(default_configuration, config), config_file)
+        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
       end
 
-      def target_ruby_version_to_f!(hash)
-        version = 'TargetRubyVersion'
-        return unless hash['AllCops'] && hash['AllCops'][version]
-
-        hash['AllCops'][version] = hash['AllCops'][version].to_f
+      # Merges the given configuration with the default one.
+      def merge_with_default(config, config_file, unset_nil: true)
+        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
       private
 
-      def handle_disabled_by_default(config, new_default_configuration)
-        department_config = config.to_hash.reject { |cop| cop.include?('/') }
-        department_config.each do |dept, dept_params|
-          # Rails is always disabled by default and the department's Enabled
-          # flag works like the --rails command line option, which is that when
-          # AllCops:DisabledByDefault is true, each Rails cop must still be
-          # explicitly mentioned in user configuration in order to be enabled.
-          next if dept == 'Rails'
-
-          next unless dept_params['Enabled']
-
-          new_default_configuration.each do |cop, params|
-            next unless cop.start_with?(dept + '/')
+      def find_project_dotfile(target_dir)
+        find_file_upwards(DOTFILE, target_dir)
+      end
 
-            # Retain original default configuration for cops in the department.
-            params['Enabled'] = default_configuration[cop]['Enabled']
-          end
-        end
+      def find_user_dotfile
+        return unless ENV.key?('HOME')
 
-        transform(config) do |params|
-          { 'Enabled' => true }.merge(params) # Set true if not set.
-        end
+        file = File.join(Dir.home, DOTFILE)
+        return file if File.exist?(file)
       end
 
-      # Returns a new hash where the parameters of the given config hash have
-      # been replaced by parameters returned by the given block.
-      def transform(config)
-        Hash[config.map { |cop, params| [cop, yield(params)] }]
+      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 load_yaml_configuration(absolute_path)
-        yaml_code = IO.read(absolute_path, encoding: Encoding::UTF_8)
-        hash = yaml_safe_load(yaml_code, absolute_path) || {}
-
-        puts "configuration from #{absolute_path}" if debug?
-
-        unless hash.is_a?(Hash)
-          raise(TypeError, "Malformed configuration in #{absolute_path}")
-        end
-
-        hash
+      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 yaml_safe_load(yaml_code, filename)
-        if YAML.respond_to?(:safe_load) # Ruby 2.1+
-          if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
-            SafeYAML.load(yaml_code, filename,
-                          whitelisted_tags: %w[!ruby/regexp])
-          else
-            YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, filename)
-          end
-        else
-          YAML.load(yaml_code, filename) # rubocop:disable Security/YAMLLoad
-        end
+      def resolver
+        @resolver ||= ConfigLoaderResolver.new
       end
 
-      def gem_config_path(gem_name, relative_config_path)
-        spec = Gem::Specification.find_by_name(gem_name)
-        return File.join(spec.gem_dir, relative_config_path)
-      rescue Gem::LoadError => e
-        raise Gem::LoadError,
-              "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+      def check_duplication(yaml_code, absolute_path)
+        smart_path = PathUtil.smart_path(absolute_path)
+        YAMLDuplicationChecker.check(yaml_code, absolute_path) do |key1, key2|
+          value = key1.value
+          # .start_line is only available since ruby 2.5 / psych 3.0
+          message = if key1.respond_to? :start_line
+                      line1 = key1.start_line + 1
+                      line2 = key2.start_line + 1
+                      "#{smart_path}:#{line1}: " \
+                      "`#{value}` is concealed by line #{line2}"
+                    else
+                      "#{smart_path}: `#{value}` is concealed by duplicate"
+                    end
+          warn Rainbow(message).yellow
+        end
       end
 
-      def config_files_in_path(target)
-        possible_config_files = dirs_to_search(target).map do |dir|
-          File.join(dir, DOTFILE)
-        end
-        possible_config_files.select { |config_file| File.exist?(config_file) }
+      # Read the specified file, or exit with a friendly, concise message on
+      # stderr. Care is taken to use the standard OS exit code for a "file not
+      # found" error.
+      def read_file(absolute_path)
+        IO.read(absolute_path, encoding: Encoding::UTF_8)
+      rescue Errno::ENOENT
+        raise ConfigNotFoundError,
+              "Configuration file not found: #{absolute_path}"
       end
 
-      def dirs_to_search(target_dir)
-        dirs_to_search = []
-        Pathname.new(File.expand_path(target_dir)).ascend do |dir_pathname|
-          break if dir_pathname.to_s == @root_level
-          dirs_to_search << dir_pathname.to_s
+      def yaml_safe_load(yaml_code, filename)
+        if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
+          SafeYAML.load(yaml_code, filename, whitelisted_tags: %w[!ruby/regexp])
+        # Ruby 2.6+
+        elsif Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
+          YAML.safe_load(yaml_code,
+                         permitted_classes: [Regexp, Symbol],
+                         permitted_symbols: [],
+                         aliases: true,
+                         filename: filename)
+        else
+          YAML.safe_load(yaml_code, [Regexp, Symbol], [], true, filename)
         end
-        dirs_to_search << Dir.home if ENV.key? 'HOME'
-        dirs_to_search
       end
     end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -4,8 +4,8 @@ require 'yaml'
 require 'pathname'
 
 module RuboCop
-  # A mixin to break up ConfigLoader
-  module ConfigLoaderResolver
+  # A help class for ConfigLoader that handles configuration resolution.
+  class ConfigLoaderResolver
     def resolve_requires(path, hash)
       config_dir = File.dirname(path)
       Array(hash.delete('require')).each do |r|
@@ -17,16 +17,29 @@ module RuboCop
       end
     end
 
-    def resolve_inheritance(path, hash, file)
-      base_configs(path, hash['inherit_from'], file)
-        .reverse_each do |base_config|
+    # rubocop:disable Metrics/MethodLength
+    def resolve_inheritance(path, hash, file, debug)
+      inherited_files = Array(hash['inherit_from'])
+      base_configs(path, inherited_files, file)
+        .reverse.each_with_index do |base_config, index|
+        override_department_setting_for_cops(base_config, hash)
         base_config.each do |k, v|
-          hash[k] = hash.key?(k) ? merge(v, hash[k]) : v if v.is_a?(Hash)
+          next unless v.is_a?(Hash)
+
+          if hash.key?(k)
+            v = merge(v, hash[k],
+                      cop_name: k, file: file, debug: debug,
+                      inherited_file: inherited_files[index],
+                      inherit_mode: determine_inherit_mode(hash, k))
+          end
+          hash[k] = v
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
-    def resolve_inheritance_from_gems(hash, gems)
+    def resolve_inheritance_from_gems(hash)
+      gems = hash.delete('inherit_gem')
       (gems || {}).each_pair do |gem_name, config_path|
         if gem_name == 'rubocop'
           raise ArgumentError,
@@ -34,11 +47,188 @@ module RuboCop
         end
 
         hash['inherit_from'] = Array(hash['inherit_from'])
-        Array(config_path).reverse.each do |path|
+        Array(config_path).reverse_each do |path|
           # Put gem configuration first so local configuration overrides it.
           hash['inherit_from'].unshift gem_config_path(gem_name, path)
         end
       end
     end
+
+    # Merges the given configuration with the default one. If
+    # AllCops:DisabledByDefault is true, it changes the Enabled params so that
+    # only cops from user configuration are enabled. If
+    # AllCops::EnabledByDefault is true, it changes the Enabled params so that
+    # only cops explicitly disabled in user configuration are disabled.
+    def merge_with_default(config, config_file, unset_nil:)
+      default_configuration = ConfigLoader.default_configuration
+
+      disabled_by_default = config.for_all_cops['DisabledByDefault']
+      enabled_by_default = config.for_all_cops['EnabledByDefault']
+
+      if disabled_by_default || enabled_by_default
+        default_configuration = transform(default_configuration) do |params|
+          params.merge('Enabled' => !disabled_by_default)
+        end
+      end
+
+      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+
+      opts = { inherit_mode: config['inherit_mode'] || {},
+               unset_nil: unset_nil }
+      Config.new(merge(default_configuration, config, **opts), config_file)
+    end
+
+    # Return a recursive merge of two hashes. That is, a normal hash merge,
+    # with the addition that any value that is a hash, and occurs in both
+    # arguments, will also be merged. And so on.
+    #
+    # rubocop:disable Metrics/AbcSize
+    def merge(base_hash, derived_hash, **opts)
+      result = base_hash.merge(derived_hash)
+      keys_appearing_in_both = base_hash.keys & derived_hash.keys
+      keys_appearing_in_both.each do |key|
+        if opts[:unset_nil] && derived_hash[key].nil?
+          result.delete(key)
+        elsif base_hash[key].is_a?(Hash)
+          result[key] = merge(base_hash[key], derived_hash[key], **opts)
+        elsif should_union?(base_hash, key, opts[:inherit_mode])
+          result[key] = base_hash[key] | derived_hash[key]
+        elsif opts[:debug]
+          warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
+        end
+      end
+      result
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # An `Enabled: true` setting in user configuration for a cop overrides an
+    # `Enabled: false` setting for its department.
+    def override_department_setting_for_cops(base_hash, derived_hash)
+      derived_hash.each_key do |key|
+        next unless key =~ %r{(.*)/.*}
+
+        department = Regexp.last_match(1)
+        next unless disabled?(derived_hash, department) ||
+                    disabled?(base_hash, department)
+
+        # The `override_department` setting for the `Enabled` parameter is an
+        # internal setting that's not documented in the manual. It will cause a
+        # cop to be enabled later, when logic surrounding enabled/disabled it
+        # run, even though its department is disabled.
+        derived_hash[key]['Enabled'] = 'override_department' if derived_hash[key]['Enabled']
+      end
+    end
+
+    private
+
+    def disabled?(hash, department)
+      hash[department] && hash[department]['Enabled'] == false
+    end
+
+    def duplicate_setting?(base_hash, derived_hash, key, inherited_file)
+      return false if inherited_file.nil? # Not inheritance resolving merge
+      return false if inherited_file.start_with?('..') # Legitimate override
+      return false if base_hash[key] == derived_hash[key] # Same value
+      return false if remote_file?(inherited_file) # Can't change
+
+      Gem.path.none? { |dir| inherited_file.start_with?(dir) } # Can change?
+    end
+
+    def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
+      return unless duplicate_setting?(base_hash, derived_hash,
+                                       key, opts[:inherited_file])
+
+      inherit_mode = opts[:inherit_mode]['merge'] ||
+                     opts[:inherit_mode]['override']
+      return if base_hash[key].is_a?(Array) &&
+                inherit_mode && inherit_mode.include?(key)
+
+      puts "#{PathUtil.smart_path(opts[:file])}: " \
+           "#{opts[:cop_name]}:#{key} overrides " \
+           "the same parameter in #{opts[:inherited_file]}"
+    end
+
+    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 || hash['inherit_mode'] || {}
+    end
+
+    def should_union?(base_hash, key, inherit_mode)
+      base_hash[key].is_a?(Array) &&
+        inherit_mode &&
+        inherit_mode['merge'] &&
+        inherit_mode['merge'].include?(key)
+    end
+
+    def base_configs(path, inherit_from, file)
+      configs = Array(inherit_from).compact.map do |f|
+        ConfigLoader.load_file(inherited_file(path, f, file))
+      end
+
+      configs.compact
+    end
+
+    def inherited_file(path, inherit_from, file)
+      if remote_file?(inherit_from)
+        # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
+        RemoteConfig.new(inherit_from, File.dirname(path))
+      elsif Pathname.new(inherit_from).absolute?
+        # An absolute path to a config, e.g. `inherit_from: /Users/me/rubocop.yml`.
+        # The path may come from `inherit_gem` option, where a gem name is expanded
+        # to an absolute path to that gem.
+        print 'Inheriting ' if ConfigLoader.debug?
+        inherit_from
+      elsif file.is_a?(RemoteConfig)
+        # A path relative to a URL, e.g. `inherit_from: configs/default.yml`
+        # in a config included with `inherit_from: http://example.com/rubocop.yml`
+        file.inherit_from_remote(inherit_from, path)
+      else
+        # A local relative path, e.g. `inherit_from: default.yml`
+        print 'Inheriting ' if ConfigLoader.debug?
+        File.expand_path(inherit_from, File.dirname(path))
+      end
+    end
+
+    def remote_file?(uri)
+      regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
+      /\A#{regex}\z/.match?(uri)
+    end
+
+    def handle_disabled_by_default(config, new_default_configuration)
+      department_config = config.to_hash.reject { |cop| cop.include?('/') }
+      department_config.each do |dept, dept_params|
+        next unless dept_params['Enabled']
+
+        new_default_configuration.each do |cop, params|
+          next unless cop.start_with?(dept + '/')
+
+          # Retain original default configuration for cops in the department.
+          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
+        end
+      end
+
+      transform(config) do |params|
+        { 'Enabled' => true }.merge(params) # Set true if not set.
+      end
+    end
+
+    def transform(config)
+      config.transform_values { |params| yield(params) }
+    end
+
+    def gem_config_path(gem_name, relative_config_path)
+      if defined?(Bundler)
+        gem = Bundler.load.specs[gem_name].first
+        gem_path = gem.full_gem_path if gem
+      end
+
+      gem_path ||= Gem::Specification.find_by_name(gem_name).gem_dir
+
+      File.join(gem_path, relative_config_path)
+    rescue Gem::LoadError => e
+      raise Gem::LoadError,
+            "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+    end
   end
 end