rubocop 0.75.1

data/lib/rubocop/config_loader_resolver.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+
+module RuboCop
+  # 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|
+        if r.start_with?('.')
+          require(File.join(config_dir, r))
+        else
+          require(r)
+        end
+      end
+    end
+
+    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|
+        base_config.each do |k, v|
+          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
+
+    def resolve_inheritance_from_gems(hash, gems)
+      (gems || {}).each_pair do |gem_name, config_path|
+        if gem_name == 'rubocop'
+          raise ArgumentError,
+                "can't inherit configuration from the rubocop gem"
+        end
+
+        hash['inherit_from'] = Array(hash['inherit_from'])
+        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
+
+      if disabled_by_default
+        config = handle_disabled_by_default(config, default_configuration)
+      end
+
+      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
+
+    private
+
+    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)
+        RemoteConfig.new(inherit_from, File.dirname(path))
+      elsif file.is_a?(RemoteConfig)
+        file.inherit_from_remote(inherit_from, path)
+      else
+        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])
+      uri =~ /\A#{regex}\z/
+    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)
+      Hash[config.map { |cop, params| [cop, yield(params)] }]
+    end
+
+    def gem_config_path(gem_name, relative_config_path)
+      spec = Gem::Specification.find_by_name(gem_name)
+      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}"
+    end
+  end
+end

data/lib/rubocop/config_obsoletion.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles obsolete configuration.
+  class ConfigObsoletion
+    RENAMED_COPS = {
+      'Style/SingleSpaceBeforeFirstArg' => 'Layout/SpaceBeforeFirstArg',
+      'Style/MethodCallParentheses' => 'Style/MethodCallWithoutArgsParentheses',
+      'Style/DeprecatedHashMethods' => 'Style/PreferredHashMethods',
+      'Style/OpMethod' => 'Naming/BinaryOperatorParameterName',
+      'Layout/FirstParameterIndentation' => 'Layout/IndentFirstArgument',
+      'Layout/IndentArray' => 'Layout/IndentFirstArrayElement',
+      'Layout/IndentHash' => 'Layout/IndentFirstHashElement'
+    }.map do |old_name, new_name|
+      [old_name, "The `#{old_name}` cop has been renamed to `#{new_name}`."]
+    end
+
+    MOVED_COPS = {
+      'Security' => 'Lint/Eval',
+      'Naming' => %w[Style/ClassAndModuleCamelCase Style/ConstantName
+                     Style/FileName Style/MethodName Style/PredicateName
+                     Style/VariableName Style/VariableNumber
+                     Style/AccessorMethodName Style/AsciiIdentifiers],
+      'Layout' => %w[Lint/BlockAlignment Lint/EndAlignment
+                     Lint/DefEndAlignment],
+      'Lint' => 'Style/FlipFlop'
+    }.map do |new_department, old_names|
+      Array(old_names).map do |old_name|
+        [old_name, "The `#{old_name}` cop has been moved to " \
+                   "`#{new_department}/#{old_name.split('/').last}`."]
+      end
+    end
+
+    REMOVED_COPS = {
+      'Rails/DefaultScope' => nil,
+      'Layout/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
+      'Layout/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/SpaceAfterControlKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/SpaceBeforeModifierKeyword' => 'Layout/SpaceAroundKeyword',
+      'Style/TrailingComma' => 'Style/TrailingCommaInArguments, ' \
+                               'Style/TrailingCommaInArrayLiteral, and/or ' \
+                               'Style/TrailingCommaInHashLiteral',
+      'Style/TrailingCommaInLiteral' => 'Style/TrailingCommaInArrayLiteral ' \
+                                        'and/or ' \
+                                        'Style/TrailingCommaInHashLiteral',
+      'Lint/RescueWithoutErrorClass' => 'Style/RescueStandardError'
+    }.map do |old_name, other_cops|
+      if other_cops
+        more = ". Please use #{other_cops} instead".gsub(%r{[A-Z]\w+/\w+},
+                                                         '`\&`')
+      end
+      [old_name, "The `#{old_name}` cop has been removed#{more}."]
+    end
+
+    REMOVED_COPS_WITH_REASON = {
+      'Lint/InvalidCharacterLiteral' => 'it was never being actually triggered',
+      'Lint/SpaceBeforeFirstArg' =>
+        'it was a duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
+        '`Layout/SpaceBeforeFirstArg` instead'
+    }.map do |cop_name, reason|
+      [cop_name, "The `#{cop_name}` cop has been removed since #{reason}."]
+    end
+
+    SPLIT_COPS = {
+      'Style/MethodMissing' =>
+        'The `Style/MethodMissing` cop has been split into ' \
+        '`Style/MethodMissingSuper` and `Style/MissingRespondToMissing`.'
+    }.to_a
+
+    OBSOLETE_COPS = Hash[*(RENAMED_COPS + MOVED_COPS + REMOVED_COPS +
+                           REMOVED_COPS_WITH_REASON + SPLIT_COPS).flatten]
+
+    OBSOLETE_PARAMETERS = [
+      {
+        cops: %w[Layout/SpaceAroundOperators Style/SpaceAroundOperators],
+        parameters: 'MultiSpaceAllowedForOperators',
+        alternative: 'If your intention was to allow extra spaces for ' \
+                     'alignment, please use AllowForAlignment: true instead.'
+      },
+      {
+        cops: 'Style/Encoding',
+        parameters: %w[EnforcedStyle SupportedStyles
+                       AutoCorrectEncodingComment],
+        alternative: 'Style/Encoding no longer supports styles. ' \
+                     'The "never" behavior is always assumed.'
+      },
+      {
+        cops: 'Style/IfUnlessModifier',
+        parameters: 'MaxLineLength',
+        alternative: '`Style/IfUnlessModifier: MaxLineLength` has been ' \
+                     'removed. Use `Metrics/LineLength: Max` instead'
+      },
+      {
+        cops: 'Style/WhileUntilModifier',
+        parameters: 'MaxLineLength',
+        alternative: '`Style/WhileUntilModifier: MaxLineLength` has been ' \
+                     'removed. Use `Metrics/LineLength: Max` instead'
+      },
+      {
+        cops: 'AllCops',
+        parameters: 'RunRailsCops',
+        alternative: "Use the following configuration instead:\n" \
+                     "Rails:\n  Enabled: true"
+      },
+      {
+        cops: 'Layout/CaseIndentation',
+        parameters: 'IndentWhenRelativeTo',
+        alternative: '`IndentWhenRelativeTo` has been renamed to ' \
+                     '`EnforcedStyle`'
+      },
+      {
+        cops: %w[Lint/BlockAlignment Layout/BlockAlignment Lint/EndAlignment
+                 Layout/EndAlignment Lint/DefEndAlignment
+                 Layout/DefEndAlignment],
+        parameters: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to `EnforcedStyleAlignWith`'
+      },
+      {
+        cops: 'Rails/UniqBeforePluck',
+        parameters: 'EnforcedMode',
+        alternative: '`EnforcedMode` has been renamed to `EnforcedStyle`'
+      },
+      {
+        cops: 'Style/MethodCallWithArgsParentheses',
+        parameters: 'IgnoredMethodPatterns',
+        alternative: '`IgnoredMethodPatterns` has been renamed to ' \
+                     '`IgnoredPatterns`'
+      },
+      {
+        cops: %w[Performance/Count Performance/Detect],
+        parameters: 'SafeMode',
+        alternative: '`SafeMode` has been removed. ' \
+                     'Use `SafeAutoCorrect` instead.'
+      }
+    ].freeze
+
+    OBSOLETE_ENFORCED_STYLES = [
+      {
+        cop: 'Layout/IndentationConsistency',
+        parameter: 'EnforcedStyle',
+        enforced_style: 'rails',
+        alternative: '`EnforcedStyle: rails` has been renamed to ' \
+                     '`EnforcedStyle: indented_internal_methods`'
+      }
+    ].freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def reject_obsolete_cops_and_parameters
+      messages = [obsolete_cops, obsolete_parameters,
+                  obsolete_enforced_style].flatten.compact
+      return if messages.empty?
+
+      raise ValidationError, messages.join("\n")
+    end
+
+    private
+
+    def obsolete_cops
+      OBSOLETE_COPS.map do |cop_name, message|
+        next unless @config.key?(cop_name) ||
+                    @config.key?(Cop::Badge.parse(cop_name).cop_name)
+
+        message + "\n(obsolete configuration found in " \
+                  "#{smart_loaded_path}, please update it)"
+      end
+    end
+
+    def obsolete_enforced_style
+      OBSOLETE_ENFORCED_STYLES.map do |params|
+        obsolete_enforced_style_message(params[:cop], params[:parameter],
+                                        params[:enforced_style],
+                                        params[:alternative])
+      end
+    end
+
+    def obsolete_enforced_style_message(cop, param, enforced_style, alternative)
+      style = @config[cop]&.detect { |key, _| key.start_with?(param) }
+
+      return unless style && style[1] == enforced_style
+
+      "obsolete `#{param}: #{enforced_style}` (for #{cop}) found in " \
+      "#{smart_loaded_path}\n#{alternative}"
+    end
+
+    def obsolete_parameters
+      OBSOLETE_PARAMETERS.map do |params|
+        obsolete_parameter_message(params[:cops], params[:parameters],
+                                   params[:alternative])
+      end
+    end
+
+    def obsolete_parameter_message(cops, parameters, alternative)
+      Array(cops).map do |cop|
+        obsolete_parameters = Array(parameters).select do |param|
+          @config[cop]&.key?(param)
+        end
+        next if obsolete_parameters.empty?
+
+        obsolete_parameters.map do |parameter|
+          "obsolete parameter #{parameter} (for #{cop}) found in " \
+          "#{smart_loaded_path}\n#{alternative}"
+        end
+      end
+    end
+
+    def smart_loaded_path
+      PathUtil.smart_path(@config.loaded_path)
+    end
+  end
+end

data/lib/rubocop/config_store.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Handles caching of configurations and association of inspected
+  # ruby files to configurations.
+  class ConfigStore
+    def initialize
+      # @options_config stores a config that is specified in the command line.
+      # This takes precedence over configs located in any directories
+      @options_config = nil
+
+      # @path_cache maps directories to configuration paths. We search
+      # for .rubocop.yml only if we haven't already found it for the
+      # given directory.
+      @path_cache = {}
+
+      # @object_cache maps configuration file paths to
+      # configuration objects so we only need to load them once.
+      @object_cache = {}
+    end
+
+    def options_config=(options_config)
+      loaded_config = ConfigLoader.load_file(options_config)
+      @options_config = ConfigLoader.merge_with_default(loaded_config,
+                                                        options_config)
+    end
+
+    def force_default_config!
+      @options_config = ConfigLoader.default_configuration
+    end
+
+    def for(file_or_dir)
+      return @options_config if @options_config
+
+      dir = if File.directory?(file_or_dir)
+              file_or_dir
+            else
+              File.dirname(file_or_dir)
+            end
+      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
+      path = @path_cache[dir]
+      @object_cache[path] ||= begin
+                                print "For #{dir}: " if ConfigLoader.debug?
+                                ConfigLoader.configuration_from_file(path)
+                              end
+    end
+  end
+end