rubocop 0.76.0 → 1.50.0

data/lib/rubocop/config.rb

@@ -2,6 +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
@@ -13,36 +16,54 @@ module RuboCop
     include FileFinder
     extend Forwardable
 
+    CopConfig = Struct.new(:name, :metadata)
+
     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::Cop.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)
+
+      @badge_config_cache = {}.compare_by_identity
+      @clusivity_config_exists_cache = {}
     end
+    # rubocop:enable Metrics/AbcSize
 
-    def self.create(hash, path)
-      new(hash, path).check
+    def loaded_features
+      @loaded_features ||= ConfigLoader.loaded_features
     end
 
     def check
-      deprecation_check do |deprecation_message|
-        warn("#{loaded_path} - #{deprecation_message}")
-      end
+      deprecation_check { |deprecation_message| warn("#{loaded_path} - #{deprecation_message}") }
       @validator.validate
       make_excludes_absolute
       self
     end
 
-    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
-                   :map, :merge, :to_h, :to_hash
+    def validate_after_resolution
+      @validator.validate_after_resolution
+      self
+    end
+
+    def_delegators :@hash, :[], :[]=, :delete, :dig, :each, :key?, :keys, :each_key,
+                   :fetch, :map, :merge, :replace, :to_h, :to_hash, :transform_values
     def_delegators :@validator, :validate, :target_ruby_version
 
     def to_s
@@ -55,8 +76,7 @@ module RuboCop
 
     # 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'))
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME, 'config'))
       File.expand_path(loaded_path).start_with?(base_config_path)
     end
 
@@ -67,8 +87,7 @@ module RuboCop
 
         self[key]['Exclude'].map! do |exclude_elem|
           if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
-            File.expand_path(File.join(base_dir_for_path_parameters,
-                                       exclude_elem))
+            File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
           else
             exclude_elem
           end
@@ -99,25 +118,67 @@ module RuboCop
       end
     end
 
+    # @return [Config] for the given cop / cop name.
+    # 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)
+      @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.
+    # Note: the 'Enabled' attribute will be present only if specified
+    # at the department's level
     def for_department(department_name)
-      @for_cop[department_name]
+      @for_department ||= Hash.new { |h, dept| h[dept] = self[dept] || {} }
+      @for_department[department_name.to_s]
     end
 
     def for_all_cops
       @for_all_cops ||= self['AllCops'] || {}
     end
 
+    def disabled_new_cops?
+      for_all_cops['NewCops'] == 'disable'
+    end
+
+    def enabled_new_cops?
+      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)
 
       # Optimization to quickly decide if the given file is hidden (on the top
-      # level) and can not be matched by any pattern.
-      is_hidden = relative_file_path.start_with?('.') &&
-                  !relative_file_path.start_with?('..')
+      # 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?
 
       absolute_file_path = File.expand_path(file)
@@ -126,8 +187,7 @@ module RuboCop
         if block_given?
           yield pattern, relative_file_path, absolute_file_path
         else
-          match_path?(pattern, relative_file_path) ||
-            match_path?(pattern, absolute_file_path)
+          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
         end
       end
     end
@@ -139,9 +199,8 @@ module RuboCop
       return true if File.extname(file) == '.gemspec'
 
       file_to_include?(file) do |pattern, relative_path, absolute_path|
-        pattern.to_s =~ /[A-Z]/ &&
-          (match_path?(pattern, relative_path) ||
-           match_path?(pattern, absolute_path))
+        /[A-Z]/.match?(pattern.to_s) &&
+          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
       end
     end
 
@@ -157,9 +216,7 @@ module RuboCop
 
     def file_to_exclude?(file)
       file = File.expand_path(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file)
-      end
+      patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
     end
 
     def patterns_to_include
@@ -181,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
@@ -208,18 +265,29 @@ 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
       nil
     end
 
+    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
+
+        cop_metadata = self[qualified_cop_name]
+        next unless cop_metadata['Enabled'] == 'pending'
+
+        pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
+      end
+    end
+
     private
 
     def target_rails_version_from_bundler_lock_file
-      @target_rails_version_from_bundler_lock_file ||=
-        read_rails_version_from_bundler_lock_file
+      @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
     end
 
     def read_rails_version_from_bundler_lock_file
@@ -227,25 +295,32 @@ 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)
-      cop_department, cop_name = qualified_cop_name.split('/')
-      department = cop_name.nil?
+      # 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'
 
-      unless department
-        department_options = self[cop_department]
-        if department_options && department_options['Enabled'] == false
-          return false
-        end
-      end
+      department = department_of(qualified_cop_name)
+      cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+      return true if cop_enabled == 'override_department'
+      return false if department && department['Enabled'] == false
+
+      cop_enabled
+    end
+
+    def department_of(qualified_cop_name)
+      *cop_department, _ = qualified_cop_name.split('/')
+      return nil if cop_department.empty?
 
-      cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+      self[cop_department.join('/')]
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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