rubocop 0.51.0 → 0.87.0

data/lib/rubocop/config.rb

@@ -2,8 +2,9 @@
 
 require 'pathname'
 
+# FIXME: Moving Rails department code to RuboCop Rails will remove
+# the following rubocop:disable comment.
 # rubocop:disable Metrics/ClassLength
-
 module RuboCop
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
@@ -12,153 +13,12 @@ module RuboCop
   # directories are inspected.
   class Config
     include PathUtil
+    include FileFinder
+    extend Forwardable
 
-    COMMON_PARAMS = %w[Exclude Include Severity
-                       AutoCorrect StyleGuide Details].freeze
-    # 2.1 is the oldest officially supported Ruby version.
-    DEFAULT_RUBY_VERSION = 2.1
-    KNOWN_RUBIES = [2.1, 2.2, 2.3, 2.4].freeze
-    OBSOLETE_RUBIES = { 1.9 => '0.50', 2.0 => '0.50' }.freeze
-    DEFAULT_RAILS_VERSION = 5.0
-    OBSOLETE_COPS = {
-      'Style/TrailingComma' =>
-        'The `Style/TrailingComma` cop no longer exists. Please use ' \
-        '`Style/TrailingCommaInLiteral` and/or ' \
-        '`Style/TrailingCommaInArguments` instead.',
-      'Rails/DefaultScope' =>
-        'The `Rails/DefaultScope` cop no longer exists.',
-      'Lint/InvalidCharacterLiteral' =>
-        'The `Lint/InvalidCharacterLiteral` cop has been removed since it ' \
-        'was never being actually triggered.',
-      'Style/SingleSpaceBeforeFirstArg' =>
-        'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
-        '`Layout/SpaceBeforeFirstArg`.',
-      'Lint/SpaceBeforeFirstArg' =>
-        'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
-        'duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
-        '`Layout/SpaceBeforeFirstArg` instead.',
-      'Layout/SpaceAfterControlKeyword' =>
-        'The `Layout/SpaceAfterControlKeyword` cop has been removed. Please ' \
-        'use `Layout/SpaceAroundKeyword` instead.',
-      'Layout/SpaceBeforeModifierKeyword' =>
-        'The `Layout/SpaceBeforeModifierKeyword` cop has been removed. ' \
-        'Please use `Layout/SpaceAroundKeyword` instead.',
-      'Style/SpaceAfterControlKeyword' =>
-        'The `Style/SpaceAfterControlKeyword` cop has been removed. Please ' \
-        'use `Layout/SpaceAroundKeyword` instead.',
-      'Style/SpaceBeforeModifierKeyword' =>
-        'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
-        'use `Layout/SpaceAroundKeyword` instead.',
-      'Style/MethodCallParentheses' =>
-        'The `Style/MethodCallParentheses` cop has been renamed to ' \
-          '`Style/MethodCallWithoutArgsParentheses`.',
-      'Lint/Eval' =>
-        'The `Lint/Eval` cop has been renamed to `Security/Eval`.',
-      'Style/DeprecatedHashMethods' =>
-        'The `Style/DeprecatedHashMethods` cop has been renamed to ' \
-          '`Style/PreferredHashMethods`.',
-      'Style/AccessorMethodName' =>
-        'The `Style/AccessorMethodName` cop has been moved to ' \
-          '`Naming/AccessorMethodName`.',
-      'Style/AsciiIdentifiers' =>
-        'The `Style/AsciiIdentifiers` cop has been moved to ' \
-          '`Naming/AccessorMethodName`.',
-      'Style/OpMethod' =>
-        'The `Style/OpMethod` cop has been renamed and moved to ' \
-          '`Naming/BinaryOperatorParameterName`.',
-      'Style/ClassAndModuleCamelCase' =>
-        'The `Style/ClassAndModuleCamelCase` cop has been renamed to ' \
-          '`Naming/ClassAndModuleCamelCase`.',
-      'Style/ConstantName' =>
-        'The `Style/ConstantName` cop has been renamed to ' \
-          '`Naming/ConstantName`.',
-      'Style/FileName' =>
-        'The `Style/FileName` cop has been renamed to `Naming/FileName`.',
-      'Style/MethodName' =>
-        'The `Style/MethodName` cop has been renamed to ' \
-          '`Naming/MethodName`.',
-      'Style/PredicateName' =>
-        'The `Style/PredicateName` cop has been renamed to ' \
-          '`Naming/PredicateName`.',
-      'Style/VariableName' =>
-        'The `Style/VariableName` cop has been renamed to ' \
-          '`Naming/VariableName`.',
-      'Style/VariableNumber' =>
-        'The `Style/VariableNumber` cop has been renamed to ' \
-          '`Naming/VariableNumber`.'
-    }.freeze
-
-    OBSOLETE_PARAMETERS = [
-      {
-        cop: 'Layout/SpaceAroundOperators',
-        parameter: 'MultiSpaceAllowedForOperators',
-        alternative: 'If your intention was to allow extra spaces ' \
-                     'for alignment, please use AllowForAlignment: ' \
-                     'true instead.'
-      },
-      {
-        cop: 'Style/Encoding',
-        parameter: 'EnforcedStyle',
-        alternative: 'Style/Encoding no longer supports styles. ' \
-                     'The "never" behavior is always assumed.'
-      },
-      {
-        cop: 'Style/Encoding',
-        parameter: 'SupportedStyles',
-        alternative: 'Style/Encoding no longer supports styles. ' \
-                     'The "never" behavior is always assumed.'
-      },
-      {
-        cop: 'Style/Encoding',
-        parameter: 'AutoCorrectEncodingComment',
-        alternative: 'Style/Encoding no longer supports styles. ' \
-                     'The "never" behavior is always assumed.'
-      },
-      {
-        cop: 'Style/SpaceAroundOperators',
-        parameter: 'MultiSpaceAllowedForOperators',
-        alternative: 'If your intention was to allow extra spaces ' \
-                     'for alignment, please use AllowForAlignment: ' \
-                     'true instead.'
-      },
-      {
-        cop: 'AllCops',
-        parameter: 'RunRailsCops',
-        alternative: "Use the following configuration instead:\n" \
-                     "Rails:\n  Enabled: true"
-      },
-      {
-        cop: 'Layout/CaseIndentation',
-        parameter: 'IndentWhenRelativeTo',
-        alternative: '`IndentWhenRelativeTo` has been renamed to ' \
-                     '`EnforcedStyle`'
-      },
-      {
-        cop: 'Lint/BlockAlignment',
-        parameter: 'AlignWith',
-        alternative: '`AlignWith` has been renamed to ' \
-                     '`EnforcedStyleAlignWith`'
-      },
-      {
-        cop: 'Lint/EndAlignment',
-        parameter: 'AlignWith',
-        alternative: '`AlignWith` has been renamed to ' \
-                     '`EnforcedStyleAlignWith`'
-      },
-      {
-        cop: 'Lint/DefEndAlignment',
-        parameter: 'AlignWith',
-        alternative: '`AlignWith` has been renamed to ' \
-                     '`EnforcedStyleAlignWith`'
-      },
-      {
-        cop: 'Rails/UniqBeforePluck',
-        parameter: 'EnforcedMode',
-        alternative: '`EnforcedMode` has been renamed to ' \
-                     '`EnforcedStyle`'
-      }
-    ].freeze
+    CopConfig = Struct.new(:name, :metadata)
 
+    DEFAULT_RAILS_VERSION = 5.0
     attr_reader :loaded_path
 
     def initialize(hash = {}, loaded_path = nil)
@@ -170,59 +30,44 @@ module RuboCop
         h[cop] = cop_options
       end
       @hash = hash
+      @validator = ConfigValidator.new(self)
     end
 
-    def [](key)
-      @hash[key]
-    end
-
-    def []=(key, value)
-      @hash[key] = value
-    end
-
-    def delete(key)
-      @hash.delete(key)
-    end
-
-    def each(&block)
-      @hash.each(&block)
-    end
-
-    def key?(key)
-      @hash.key?(key)
-    end
-
-    def keys
-      @hash.keys
-    end
-
-    def each_key(&block)
-      @hash.each_key(&block)
+    def self.create(hash, path)
+      new(hash, path).check
     end
 
-    def map(&block)
-      @hash.map(&block)
+    def check
+      deprecation_check do |deprecation_message|
+        warn("#{loaded_path} - #{deprecation_message}")
+      end
+      @validator.validate
+      make_excludes_absolute
+      self
     end
 
-    def merge(other_hash)
-      @hash.merge(other_hash)
-    end
+    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
+                   :map, :merge, :to_h, :to_hash, :transform_values
+    def_delegators :@validator, :validate, :target_ruby_version
 
-    def to_h
-      @hash
+    def to_s
+      @to_s ||= @hash.to_s
     end
 
-    def to_hash
-      @hash
+    def signature
+      @signature ||= Digest::SHA1.hexdigest(to_s)
     end
 
-    def to_s
-      @to_s ||= @hash.to_s
+    # True if this is a config file that is shipped with RuboCop
+    def internal?
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
+                                                    'config'))
+      File.expand_path(loaded_path).start_with?(base_config_path)
     end
 
     def make_excludes_absolute
       each_key do |key|
-        validate_section_presence(key)
+        @validator.validate_section_presence(key)
         next unless self[key]['Exclude']
 
         self[key]['Exclude'].map! do |exclude_elem|
@@ -263,34 +108,27 @@ module RuboCop
       @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
     end
 
+    def for_department(department_name)
+      @for_cop[department_name]
+    end
+
     def for_all_cops
       @for_all_cops ||= self['AllCops'] || {}
     end
 
-    def validate
-      # Don't validate RuboCop's own files. Avoids infinite recursion.
-      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
-                                                    'config'))
-      return if File.expand_path(loaded_path).start_with?(base_config_path)
-
-      valid_cop_names, invalid_cop_names = keys.partition do |key|
-        ConfigLoader.default_configuration.key?(key)
-      end
+    def disabled_new_cops?
+      for_all_cops['NewCops'] == 'disable'
+    end
 
-      reject_obsolete_cops_and_parameters
-      warn_about_unrecognized_cops(invalid_cop_names)
-      check_target_ruby
-      validate_parameter_names(valid_cop_names)
-      validate_enforced_styles(valid_cop_names)
-      validate_syntax_cop(valid_cop_names)
-      reject_mutually_exclusive_defaults
+    def enabled_new_cops?
+      for_all_cops['NewCops'] == 'enable'
     end
 
     def file_to_include?(file)
       relative_file_path = path_relative_to_config(file)
 
       # Optimization to quickly decide if the given file is hidden (on the top
-      # level) and can not be matched by any pattern.
+      # level) and cannot be matched by any pattern.
       is_hidden = relative_file_path.start_with?('.') &&
                   !relative_file_path.start_with?('..')
       return false if is_hidden && !possibly_include_hidden?
@@ -298,8 +136,25 @@ module RuboCop
       absolute_file_path = File.expand_path(file)
 
       patterns_to_include.any? do |pattern|
-        match_path?(pattern, relative_file_path) ||
-          match_path?(pattern, absolute_file_path)
+        if block_given?
+          yield pattern, relative_file_path, absolute_file_path
+        else
+          match_path?(pattern, relative_file_path) ||
+            match_path?(pattern, absolute_file_path)
+        end
+      end
+    end
+
+    def allowed_camel_case_file?(file)
+      # Gemspecs are allowed to have dashes because that fits with bundler best
+      # practices in the case when the gem is nested under a namespace (e.g.,
+      # `bundler-console` conveys `Bundler::Console`).
+      return true if File.extname(file) == '.gemspec'
+
+      file_to_include?(file) do |pattern, relative_path, absolute_path|
+        /[A-Z]/.match?(pattern.to_s) &&
+          (match_path?(pattern, relative_path) ||
+           match_path?(pattern, absolute_path))
       end
     end
 
@@ -321,11 +176,11 @@ module RuboCop
     end
 
     def patterns_to_include
-      for_all_cops['Include']
+      for_all_cops['Include'] || []
     end
 
     def patterns_to_exclude
-      for_all_cops['Exclude']
+      for_all_cops['Exclude'] || []
     end
 
     def path_relative_to_config(path)
@@ -347,171 +202,80 @@ module RuboCop
         end
     end
 
-    def target_ruby_version
-      @target_ruby_version ||=
-        if for_all_cops['TargetRubyVersion']
-          @target_ruby_version_source = :rubocop_yml
-
-          for_all_cops['TargetRubyVersion']
-        elsif File.file?('.ruby-version') &&
-              /\A(ruby-)?(?<version>\d+\.\d+)/ =~ File.read('.ruby-version')
-
-          @target_ruby_version_source = :dot_ruby_version
-
-          version.to_f
-        else
-          DEFAULT_RUBY_VERSION
-        end
-    end
-
     def target_rails_version
       @target_rails_version ||=
-        for_all_cops.fetch('TargetRailsVersion', DEFAULT_RAILS_VERSION)
-    end
-
-    private
-
-    def warn_about_unrecognized_cops(invalid_cop_names)
-      invalid_cop_names.each do |name|
-        # There could be a custom cop with this name. If so, don't warn
-        next if Cop::Cop.registry.contains_cop_matching?([name])
-
-        warn Rainbow("Warning: unrecognized cop #{name} found in " \
-                     "#{smart_loaded_path}").yellow
-      end
-    end
-
-    def validate_syntax_cop(valid_cop_names)
-      return unless valid_cop_names.include?('Lint/Syntax') ||
-                    valid_cop_names.include?('Syntax')
-
-      raise ValidationError,
-            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
-            'This cop cannot be configured.'
+        if for_all_cops['TargetRailsVersion']
+          for_all_cops['TargetRailsVersion'].to_f
+        elsif target_rails_version_from_bundler_lock_file
+          target_rails_version_from_bundler_lock_file
+        else
+          DEFAULT_RAILS_VERSION
+        end
     end
 
-    def validate_section_presence(name)
-      return unless key?(name) && self[name].nil?
-      raise ValidationError,
-            "empty section #{name} found in #{smart_loaded_path}"
+    def smart_loaded_path
+      PathUtil.smart_path(@loaded_path)
     end
 
-    def validate_parameter_names(valid_cop_names)
-      valid_cop_names.each do |name|
-        validate_section_presence(name)
-        self[name].each_key do |param|
-          next if COMMON_PARAMS.include?(param) ||
-                  ConfigLoader.default_configuration[name].key?(param)
+    def bundler_lock_file_path
+      return nil unless loaded_path
 
-          warn Rainbow("Warning: unrecognized parameter #{name}:#{param} " \
-                       "found in #{smart_loaded_path}").yellow
-        end
+      base_path = base_dir_for_path_parameters
+      ['gems.locked', 'Gemfile.lock'].each do |file_name|
+        path = find_file_upwards(file_name, base_path)
+        return path if path
       end
+      nil
     end
 
-    def validate_enforced_styles(valid_cop_names)
-      valid_cop_names.each do |name|
-        styles = self[name].select { |key, _| key.start_with?('Enforced') }
+    def pending_cops
+      keys.each_with_object([]) do |qualified_cop_name, pending_cops|
+        department = department_of(qualified_cop_name)
+        next if department && department['Enabled'] == false
 
-        styles.each do |style_name, style|
-          supported_key = RuboCop::Cop::Util.to_supported_styles(style_name)
-          valid = ConfigLoader.default_configuration[name][supported_key]
-          next unless valid
-          next if valid.include?(style)
+        cop_metadata = self[qualified_cop_name]
+        next unless cop_metadata['Enabled'] == 'pending'
 
-          msg = "invalid #{style_name} '#{style}' for #{name} found in " \
-            "#{smart_loaded_path}\n" \
-            "Valid choices are: #{valid.join(', ')}"
-          raise ValidationError, msg
-        end
+        pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
       end
     end
 
-    def reject_obsolete_cops_and_parameters
-      messages = [
-        obsolete_cops,
-        obsolete_parameters
-      ].flatten.compact
-      return if messages.empty?
-
-      raise ValidationError, messages.join("\n")
-    end
+    private
 
-    def obsolete_parameters
-      OBSOLETE_PARAMETERS.map do |params|
-        obsolete_parameter_message(params[:cop], params[:parameter],
-                                   params[:alternative])
-      end
+    def target_rails_version_from_bundler_lock_file
+      @target_rails_version_from_bundler_lock_file ||=
+        read_rails_version_from_bundler_lock_file
     end
 
-    def obsolete_parameter_message(cop, parameter, alternative)
-      return unless self[cop] && self[cop].key?(parameter)
+    def read_rails_version_from_bundler_lock_file
+      lock_file_path = bundler_lock_file_path
+      return nil unless lock_file_path
 
-      "obsolete parameter #{parameter} (for #{cop}) " \
-        "found in #{smart_loaded_path}" \
-        "\n#{alternative}"
-    end
-
-    def obsolete_cops
-      OBSOLETE_COPS.map do |cop_name, message|
-        next unless key?(cop_name) || key?(Cop::Badge.parse(cop_name).cop_name)
-        message + "\n(obsolete configuration found in #{smart_loaded_path}," \
-                   ' please update it)'
+      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+)/)
+        return result.captures.first.to_f if result
       end
     end
 
-    def check_target_ruby
-      return if KNOWN_RUBIES.include?(target_ruby_version)
-
-      msg = if OBSOLETE_RUBIES.include?(target_ruby_version)
-              "Unsupported Ruby version #{target_ruby_version} found in " \
-              "#{target_ruby_source}. #{target_ruby_version}-compatible " \
-              'analysis was dropped after version ' \
-              "#{OBSOLETE_RUBIES[target_ruby_version]}."
-            else
-              "Unknown Ruby version #{target_ruby_version.inspect} found in " \
-              "#{target_ruby_source}."
-            end
-
-      msg += "\nSupported versions: #{KNOWN_RUBIES.join(', ')}"
-
-      raise ValidationError, msg
-    end
-
-    def target_ruby_source
-      case @target_ruby_version_source
-      when :dot_ruby_version
-        '`.ruby-version`'
-      when :rubocop_yml
-        "`TargetRubyVersion` parameter (in #{smart_loaded_path})"
+    def enable_cop?(qualified_cop_name, cop_options)
+      department = department_of(qualified_cop_name)
+      cop_enabled = cop_options.fetch('Enabled') do
+        !for_all_cops['DisabledByDefault']
       end
-    end
-
-    def reject_mutually_exclusive_defaults
-      disabled_by_default = for_all_cops['DisabledByDefault']
-      enabled_by_default = for_all_cops['EnabledByDefault']
-      return unless disabled_by_default && enabled_by_default
+      return true if cop_enabled == 'override_department'
+      return false if department && department['Enabled'] == false
 
-      msg = 'Cops cannot be both enabled by default and disabled by default'
-      raise ValidationError, msg
+      cop_enabled
     end
 
-    def enable_cop?(qualified_cop_name, cop_options)
+    def department_of(qualified_cop_name)
       cop_department, cop_name = qualified_cop_name.split('/')
-      department = cop_name.nil?
-
-      unless department
-        department_options = self[cop_department]
-        if department_options && department_options['Enabled'] == false
-          return false
-        end
-      end
-
-      cop_options.fetch('Enabled', true)
-    end
+      return nil if cop_name.nil?
 
-    def smart_loaded_path
-      PathUtil.smart_path(@loaded_path)
+      self[cop_department]
     end
   end
 end
+# rubocop:enable Metrics/ClassLength