class RuboCop::Config

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.

Constants

COMMON_PARAMS
KNOWN_RUBIES
OBSOLETE_COPS

Attributes

loaded_path[R]

Public Class Methods

new(hash = {}, loaded_path = nil) click to toggle source
# File lib/rubocop/config.rb, line 43
def initialize(hash = {}, loaded_path = nil)
  @loaded_path = loaded_path
  @for_cop = Hash.new do |h, cop|
    h[cop] = self[Cop::Cop.qualified_cop_name(cop, loaded_path)] || {}
  end
  replace(hash)
end

Public Instance Methods

add_excludes_from_higher_level(highest_config) click to toggle source
# File lib/rubocop/config.rb, line 67
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
add_missing_namespaces() click to toggle source
# File lib/rubocop/config.rb, line 108
def add_missing_namespaces
  keys.each do |k|
    q = Cop::Cop.qualified_cop_name(k, loaded_path)
    next if q == k

    self[q] = self[k]
    delete(k)
  end
end
base_dir_for_path_parameters() click to toggle source

Paths specified in .rubocop.yml and .rubocop_todo.yml files 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.

# File lib/rubocop/config.rb, line 185
def base_dir_for_path_parameters
  config_files = [ConfigLoader::DOTFILE, ConfigLoader::AUTO_GENERATED_FILE]
  @base_dir_for_path_parameters ||=
    if config_files.include?(File.basename(loaded_path)) &&
       loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
      File.expand_path(File.dirname(loaded_path))
    else
      Dir.pwd
    end
end
cop_enabled?(cop) click to toggle source
# File lib/rubocop/config.rb, line 98
def cop_enabled?(cop)
  department = cop.cop_type.to_s.capitalize!

  if (dept_config = self[department])
    return false if dept_config['Enabled'] == false
  end

  for_cop(cop).empty? || for_cop(cop)['Enabled']
end
deprecation_check() { |"AllCops/| ... } click to toggle source
# File lib/rubocop/config.rb, line 79
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
file_to_exclude?(file) click to toggle source
# File lib/rubocop/config.rb, line 161
def file_to_exclude?(file)
  file = File.expand_path(file)
  patterns_to_exclude.any? do |pattern|
    match_path?(pattern, file, loaded_path)
  end
end
file_to_include?(file) click to toggle source
# File lib/rubocop/config.rb, line 136
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|
    match_path?(pattern, relative_file_path, loaded_path) ||
      match_path?(pattern, absolute_file_path, loaded_path)
  end
end
for_all_cops() click to toggle source
# File lib/rubocop/config.rb, line 94
def for_all_cops
  @for_all_cops ||= self['AllCops'] || {}
end
for_cop(cop) click to toggle source
# File lib/rubocop/config.rb, line 90
def for_cop(cop)
  @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
end
make_excludes_absolute() click to toggle source
# File lib/rubocop/config.rb, line 51
def make_excludes_absolute
  each_key do |key|
    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
path_relative_to_config(path) click to toggle source
# File lib/rubocop/config.rb, line 176
def path_relative_to_config(path)
  relative_path(path, base_dir_for_path_parameters)
end
patterns_to_exclude() click to toggle source
# File lib/rubocop/config.rb, line 172
def patterns_to_exclude
  @patterns_to_exclude ||= for_all_cops['Exclude']
end
patterns_to_include() click to toggle source
# File lib/rubocop/config.rb, line 168
def patterns_to_include
  @patterns_to_include ||= for_all_cops['Include']
end
possibly_include_hidden?() click to toggle source

Returns true if there's a chance that an Include pattern matches hidden files, false if that's definitely not possible.

# File lib/rubocop/config.rb, line 155
def possibly_include_hidden?
  @possibly_include_hidden ||= patterns_to_include.any? do |s|
    s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
  end
end
validate() click to toggle source
# File lib/rubocop/config.rb, line 118
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

  reject_obsolete_cops
  warn_about_unrecognized_cops(invalid_cop_names)
  reject_obsolete_parameters
  check_target_ruby
  validate_parameter_names(valid_cop_names)
  validate_enforced_styles(valid_cop_names)
end

Private Instance Methods

check_obsolete_parameter(cop, parameter, alternative = nil) click to toggle source
# File lib/rubocop/config.rb, line 256
def check_obsolete_parameter(cop, parameter, alternative = nil)
  if self[cop] && self[cop].key?(parameter)
    raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) "                                "found in #{loaded_path}"                                "#{"\n" if alternative}#{alternative}"
  end
end
check_target_ruby() click to toggle source
# File lib/rubocop/config.rb, line 273
def check_target_ruby
  target = for_all_cops['TargetRubyVersion']
  return unless target

  unless KNOWN_RUBIES.include?(target)
    raise ValidationError, "Unknown Ruby version #{target.inspect} found "                                'in `TargetRubyVersion` parameter (in '                                "#{loaded_path}).\nKnown versions: "                                "#{KNOWN_RUBIES.join(', ')}"
  end
end
reject_obsolete_cops() click to toggle source
# File lib/rubocop/config.rb, line 264
def reject_obsolete_cops
  OBSOLETE_COPS.each do |cop_name, message|
    next unless key?(cop_name) || key?(cop_name.split('/').last)
    message += "\n(obsolete configuration found in #{loaded_path}, please"                     ' update it)'
    raise ValidationError, message
  end
end
reject_obsolete_parameters() click to toggle source
# File lib/rubocop/config.rb, line 245
def reject_obsolete_parameters
  check_obsolete_parameter('Style/SpaceAroundOperators',
                           'MultiSpaceAllowedForOperators',
                           'If your intention was to allow extra spaces '                                 'for alignment, please use AllowForAlignment: '                                 'true instead.')
  check_obsolete_parameter('AllCops', 'RunRailsCops',
                           "Use the following configuration instead:\n"                                 "Rails:\n  Enabled: true")
end
validate_enforced_styles(valid_cop_names) click to toggle source
# File lib/rubocop/config.rb, line 232
def validate_enforced_styles(valid_cop_names)
  valid_cop_names.each do |name|
    next unless (style = self[name]['EnforcedStyle'])
    valid = ConfigLoader.default_configuration[name]['SupportedStyles']
    next if valid.include?(style)

    msg = "invalid EnforcedStyle '#{style}' for #{name} found in "                "#{loaded_path}\n"                "Valid choices are: #{valid.join(', ')}"
    raise ValidationError, msg
  end
end
validate_parameter_names(valid_cop_names) click to toggle source
# File lib/rubocop/config.rb, line 219
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)

      warn Rainbow("Warning: unrecognized parameter #{name}:#{param} "                         "found in #{loaded_path}").yellow
    end
  end
end
validate_section_presence(name) click to toggle source
# File lib/rubocop/config.rb, line 214
def validate_section_presence(name)
  return unless key?(name) && self[name].nil?
  raise ValidationError, "empty section #{name} found in #{loaded_path}"
end
warn_about_unrecognized_cops(invalid_cop_names) click to toggle source
# File lib/rubocop/config.rb, line 198
def warn_about_unrecognized_cops(invalid_cop_names)
  invalid_cop_names.each do |name|
    if name == 'Syntax'
      raise ValidationError,
            "configuration for Syntax cop found in #{loaded_path}\n"                  'This cop cannot be configured.'
    end

    # There could be a custom cop with this name. If so, don't warn
    next if Cop::Cop.all.any? { |c| c.match?([name]) }

    warn Rainbow("Warning: unrecognized cop #{name} found in "                       "#{loaded_path}").yellow
  end
end