Class: RuboCop::Config

Inherits:
Hash
  • Object
show all
Includes:
PathUtil
Defined in:
lib/rubocop/config.rb

Overview

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.

Defined Under Namespace

Classes: ValidationError

Constant Summary collapse

COMMON_PARAMS = 
%w(Exclude Include Severity AutoCorrect)

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from PathUtil

hidden?, issue_deprecation_warning, match_path?, relative_path

Constructor Details

#initialize(hash = {}, loaded_path = nil) ⇒ Config

Returns a new instance of Config.



21
22
23
24
 
# File 'lib/rubocop/config.rb', line 21

def initialize(hash = {}, loaded_path = nil)
  @loaded_path = loaded_path
  super(hash)
end

Instance Attribute Details

#loaded_path ⇒ Object (readonly)

Returns the value of attribute loaded_path.



19
20
21
 
# File 'lib/rubocop/config.rb', line 19

def loaded_path
  @loaded_path
end

Instance Method Details

#add_excludes_from_higher_level(highest_config) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/rubocop/config.rb', line 46

def add_excludes_from_higher_level(highest_config)
  return unless highest_config['AllCops'] &&
                highest_config['AllCops']['Exclude']

  self['AllCops'] ||= {}
  excludes = self['AllCops']['Exclude'] ||= []
  highest_config['AllCops']['Exclude'].each do |path|
    unless path.is_a?(Regexp) || path.start_with?('/')
      path = File.join(File.dirname(highest_config.loaded_path), path)
    end
    excludes << path unless excludes.include?(path)
  end
end

#add_missing_namespaces ⇒ Object 



90
91
92
93
94
95
96
97
98
 
# File 'lib/rubocop/config.rb', line 90

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 ⇒ Object

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.



170
171
172
173
174
175
176
177
178
 
# File 'lib/rubocop/config.rb', line 170

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))
      File.expand_path(File.dirname(loaded_path))
    else
      Dir.pwd
    end
end

#cop_enabled?(cop) ⇒ Boolean

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/rubocop/config.rb', line 80

def cop_enabled?(cop)
  for_cop(cop).nil? || for_cop(cop)['Enabled']
end

#deprecation_check ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/rubocop/config.rb', line 60

def deprecation_check
  all_cops = self['AllCops']
  return unless all_cops

  %w(Exclude Include).each do |key|
    plural = "#{key}s"
    next unless all_cops[plural]

    all_cops[key] = all_cops[plural] # Stay backwards compatible.
    all_cops.delete(plural)
    yield "AllCops/#{plural} was renamed to AllCops/#{key}"
  end
end

#file_to_exclude?(file) ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
149
150
151
 
# File 'lib/rubocop/config.rb', line 146

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) ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/rubocop/config.rb', line 118

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_cop(cop) ⇒ Object 



74
75
76
77
78
 
# File 'lib/rubocop/config.rb', line 74

def for_cop(cop)
  cop = cop.cop_name if cop.respond_to?(:cop_name)
  @for_cop ||= {}
  @for_cop[cop] ||= self[Cop::Cop.qualified_cop_name(cop, loaded_path)]
end

#make_excludes_absolute ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/rubocop/config.rb', line 30

def make_excludes_absolute
  keys.each do |key|
    validate_section_presence(key)
    next unless self[key]['Exclude']

    self[key]['Exclude'].map! do |exclude_elem|
      if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
        File.expand_path(File.join(base_dir_for_path_parameters,
                                   exclude_elem))
      else
        exclude_elem
      end
    end
  end
end

#path_relative_to_config(path) ⇒ Object 



161
162
163
 
# File 'lib/rubocop/config.rb', line 161

def path_relative_to_config(path)
  relative_path(path, base_dir_for_path_parameters)
end

#patterns_to_exclude ⇒ Object 



157
158
159
 
# File 'lib/rubocop/config.rb', line 157

def patterns_to_exclude
  @patterns_to_exclude ||= self['AllCops']['Exclude']
end

#patterns_to_include ⇒ Object 



153
154
155
 
# File 'lib/rubocop/config.rb', line 153

def patterns_to_include
  @patterns_to_include ||= self['AllCops']['Include']
end

#possibly_include_hidden? ⇒ Boolean

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

Returns:

  • (Boolean) 


137
138
139
140
141
142
143
144
 
# File 'lib/rubocop/config.rb', line 137

def possibly_include_hidden?
  if @possibly_include_hidden.nil?
    @possibly_include_hidden = patterns_to_include.any? do |s|
      s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
    end
  end
  @possibly_include_hidden
end

#to_s ⇒ Object 



26
27
28
 
# File 'lib/rubocop/config.rb', line 26

def to_s
  @to_s ||= __getobj__.to_s
end

#validate ⇒ Object

TODO: This should be a private method



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/rubocop/config.rb', line 101

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

  invalid_cop_names.each do |name|
    fail ValidationError, "unrecognized cop #{name} found in #{loaded_path}"
  end

  validate_parameter_names(valid_cop_names)
end

#warn_unless_valid ⇒ Object 



84
85
86
87
88
 
# File 'lib/rubocop/config.rb', line 84

def warn_unless_valid
  validate
rescue Config::ValidationError => e
  warn Rainbow.new.wrap("Warning: #{e.message}").red
end