rubocop 0.75.1

data/lib/rubocop/config.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  # 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 Config
+    include PathUtil
+    include FileFinder
+    extend Forwardable
+
+    DEFAULT_RAILS_VERSION = 5.0
+    attr_reader :loaded_path
+
+    def initialize(hash = {}, 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_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+        h[cop] = cop_options
+      end
+      @hash = hash
+      @validator = ConfigValidator.new(self)
+    end
+
+    def self.create(hash, path)
+      new(hash, path).check
+    end
+
+    def check
+      deprecation_check do |deprecation_message|
+        warn("#{loaded_path} - #{deprecation_message}")
+      end
+      @validator.validate
+      make_excludes_absolute
+      self
+    end
+
+    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
+                   :map, :merge, :to_h, :to_hash
+    def_delegators :@validator, :validate, :target_ruby_version
+
+    def to_s
+      @to_s ||= @hash.to_s
+    end
+
+    def signature
+      @signature ||= Digest::SHA1.hexdigest(to_s)
+    end
+
+    def make_excludes_absolute
+      each_key do |key|
+        @validator.validate_section_presence(key)
+        next unless self[key]['Exclude']
+
+        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))
+          else
+            exclude_elem
+          end
+        end
+      end
+    end
+
+    def add_excludes_from_higher_level(highest_config)
+      return unless highest_config.for_all_cops['Exclude']
+
+      excludes = for_all_cops['Exclude'] ||= []
+      highest_config.for_all_cops['Exclude'].each do |path|
+        unless path.is_a?(Regexp) || absolute?(path)
+          path = File.join(File.dirname(highest_config.loaded_path), path)
+        end
+        excludes << path unless excludes.include?(path)
+      end
+    end
+
+    def deprecation_check
+      %w[Exclude Include].each do |key|
+        plural = "#{key}s"
+        next unless for_all_cops[plural]
+
+        for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
+        for_all_cops.delete(plural)
+        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
+      end
+    end
+
+    def for_cop(cop)
+      @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 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?('..')
+      return false if is_hidden && !possibly_include_hidden?
+
+      absolute_file_path = File.expand_path(file)
+
+      patterns_to_include.any? do |pattern|
+        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|
+        pattern.to_s =~ /[A-Z]/ &&
+          (match_path?(pattern, relative_path) ||
+           match_path?(pattern, absolute_path))
+      end
+    end
+
+    # Returns true if there's a chance that an Include pattern matches hidden
+    # files, false if that's definitely not possible.
+    def possibly_include_hidden?
+      return @possibly_include_hidden if defined?(@possibly_include_hidden)
+
+      @possibly_include_hidden = patterns_to_include.any? do |s|
+        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
+      end
+    end
+
+    def file_to_exclude?(file)
+      file = File.expand_path(file)
+      patterns_to_exclude.any? do |pattern|
+        match_path?(pattern, file)
+      end
+    end
+
+    def patterns_to_include
+      for_all_cops['Include'] || []
+    end
+
+    def patterns_to_exclude
+      for_all_cops['Exclude'] || []
+    end
+
+    def path_relative_to_config(path)
+      relative_path(path, base_dir_for_path_parameters)
+    end
+
+    # Paths specified in configuration files starting with .rubocop are
+    # relative to the directory where that file is. Paths in other config files
+    # are relative to the current directory. This is so that paths in
+    # config/default.yml, for example, are not relative to RuboCop's config
+    # 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') &&
+           loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
+          File.expand_path(File.dirname(loaded_path))
+        else
+          Dir.pwd
+        end
+    end
+
+    def target_rails_version
+      @target_rails_version ||=
+        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 smart_loaded_path
+      PathUtil.smart_path(@loaded_path)
+    end
+
+    def bundler_lock_file_path
+      return nil unless loaded_path
+
+      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
+
+    private
+
+    def target_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
+      lock_file_path = bundler_lock_file_path
+      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+)/)
+        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?
+
+      unless department
+        department_options = self[cop_department]
+        if department_options && department_options['Enabled'] == false
+          return false
+        end
+      end
+
+      cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+    end
+  end
+end

data/lib/rubocop/config_loader.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+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'
+    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'
+
+    class << self
+      include FileFinder
+
+      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion,
+                    :options_config
+      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 = @options_config = nil
+        FileFinder.root_level = nil
+      end
+
+      def load_file(file)
+        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
+        resolver.resolve_requires(path, hash)
+
+        add_missing_namespaces(path, hash)
+
+        resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
+        resolver.resolve_inheritance(path, hash, file, debug?)
+
+        hash.delete('inherit_from')
+
+        Config.create(hash, path)
+      end
+
+      def add_missing_namespaces(path, hash)
+        hash.keys.each do |key|
+          q = Cop::Cop.qualified_cop_name(key, path)
+          next if q == key
+
+          hash[q] = hash.delete(key)
+        end
+      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.
+      def merge(base_hash, derived_hash)
+        resolver.merge(base_hash, derived_hash)
+      end
+
+      # Returns the path of .rubocop.yml searching upwards in the
+      # directory structure starting at the given directory where the
+      # inspected file is. If no .rubocop.yml is found there, the
+      # 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
+      end
+
+      def configuration_from_file(config_file)
+        config = load_file(config_file)
+        return config if config_file == DEFAULT_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)
+      end
+
+      def add_excludes_from_files(config, config_file)
+        found_files =
+          find_files_upwards(DOTFILE, config_file) +
+          [find_user_dotfile, find_user_xdg_config].compact
+
+        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
+
+      def default_configuration
+        @default_configuration ||= begin
+                                     print 'Default ' if debug?
+                                     load_file(DEFAULT_FILE)
+                                   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: true)
+        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
+      end
+
+      def add_inheritance_from_auto_generated_file
+        file_string = " #{AUTO_GENERATED_FILE}"
+
+        config_file = options_config || DOTFILE
+
+        if File.exist?(config_file)
+          files = Array(load_yaml_configuration(config_file)['inherit_from'])
+
+          return if files.include?(AUTO_GENERATED_FILE)
+
+          files.unshift(AUTO_GENERATED_FILE)
+          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
+          rubocop_yml_contents = existing_configuration(config_file)
+        end
+
+        write_config_file(config_file, file_string, rubocop_yml_contents)
+
+        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
+      end
+
+      private
+
+      def find_project_dotfile(target_dir)
+        find_file_upwards(DOTFILE, target_dir)
+      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 existing_configuration(config_file)
+        IO.read(config_file, encoding: Encoding::UTF_8)
+          .sub(/^inherit_from: *[^\n]+/, '')
+          .sub(/^inherit_from: *(\n *- *[^\n]+)+/, '')
+      end
+
+      def write_config_file(file_name, file_string, rubocop_yml_contents)
+        File.open(file_name, 'w') do |f|
+          f.write "inherit_from:#{file_string}\n"
+          f.write "\n#{rubocop_yml_contents}" if rubocop_yml_contents =~ /\S/
+        end
+      end
+
+      def resolver
+        @resolver ||= ConfigLoaderResolver.new
+      end
+
+      def load_yaml_configuration(absolute_path)
+        yaml_code = read_file(absolute_path)
+        check_duplication(yaml_code, absolute_path)
+        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
+
+        check_cop_config_value(hash)
+
+        hash
+      end
+
+      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 check_cop_config_value(hash, parent = nil)
+        hash.each do |key, value|
+          check_cop_config_value(value, key) if value.is_a?(Hash)
+
+          next unless %w[Enabled
+                         Safe
+                         SafeAutoCorrect
+                         AutoCorrect].include?(key) && value.is_a?(String)
+
+          abort(
+            "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow}" \
+            " is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+          )
+        end
+      end
+
+      # 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 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
+      end
+    end
+
+    # Initializing class ivars
+    clear_options
+  end
+end