Class: RuboCop::Config

Inherits:
Object
  • 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.

Constant Summary collapse

COMMON_PARAMS = 
%w(Exclude Include Severity
AutoCorrect StyleGuide Details).freeze
DEFAULT_RUBY_VERSION =

2.1 is the oldest officially supported Ruby version.

2.1
KNOWN_RUBIES = 
[1.9, 2.0, 2.1, 2.2, 2.3, 2.4].freeze
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.',
  'Style/SingleSpaceBeforeFirstArg' =>
    'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
    '`Style/SpaceBeforeFirstArg.`',
  'Lint/SpaceBeforeFirstArg' =>
    'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
    'duplicate of `Style/SpaceBeforeFirstArg`. Please use ' \
    '`Style/SpaceBeforeFirstArg` instead.',
  'Style/SpaceAfterControlKeyword' =>
    'The `Style/SpaceAfterControlKeyword` cop has been removed. Please ' \
    'use `Style/SpaceAroundKeyword` instead.',
  'Style/SpaceBeforeModifierKeyword' =>
    'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
    'use `Style/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`.'
}.freeze
OBSOLETE_PARAMETERS = 
[
  {
    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: 'Style/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

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from PathUtil

absolute?, match_path?, relative_path

Constructor Details

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

Returns a new instance of Config.



96
97
98
99
100
101
102
 
# File 'lib/rubocop/config.rb', line 96

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
  @hash = hash
end

Instance Attribute Details

#loaded_path ⇒ Object (readonly)

Returns the value of attribute loaded_path.



94
95
96
 
# File 'lib/rubocop/config.rb', line 94

def loaded_path
  @loaded_path
end

Instance Method Details

#[](key) ⇒ Object 



104
105
106
 
# File 'lib/rubocop/config.rb', line 104

def [](key)
  @hash[key]
end

#[]=(key, value) ⇒ Object 



108
109
110
 
# File 'lib/rubocop/config.rb', line 108

def []=(key, value)
  @hash[key] = value
end

#add_excludes_from_higher_level(highest_config) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/rubocop/config.rb', line 164

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

#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.



271
272
273
274
275
276
277
278
279
280
 
# File 'lib/rubocop/config.rb', line 271

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

Returns:

  • (Boolean) 


195
196
197
198
199
200
201
 
# File 'lib/rubocop/config.rb', line 195

def cop_enabled?(cop)
  if (dept_config = self[cop.department.to_s])
    return false if dept_config['Enabled'] == false
  end

  for_cop(cop).empty? || for_cop(cop).fetch('Enabled', true)
end

#delete(key) ⇒ Object 



112
113
114
 
# File 'lib/rubocop/config.rb', line 112

def delete(key)
  @hash.delete(key)
end

#deprecation_check ⇒ Object 



176
177
178
179
180
181
182
183
184
185
 
# File 'lib/rubocop/config.rb', line 176

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

#each(&block) ⇒ Object 



116
117
118
 
# File 'lib/rubocop/config.rb', line 116

def each(&block)
  @hash.each(&block)
end

#file_to_exclude?(file) ⇒ Boolean

Returns:

  • (Boolean) 


247
248
249
250
251
252
 
# File 'lib/rubocop/config.rb', line 247

def file_to_exclude?(file)
  file = File.expand_path(file)
  patterns_to_exclude.any? do |pattern|
    match_path?(pattern, file)
  end
end

#file_to_include?(file) ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/rubocop/config.rb', line 220

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) ||
      match_path?(pattern, absolute_file_path)
  end
end

#for_all_cops ⇒ Object 



191
192
193
 
# File 'lib/rubocop/config.rb', line 191

def for_all_cops
  @for_all_cops ||= self['AllCops'] || {}
end

#for_cop(cop) ⇒ Object 



187
188
189
 
# File 'lib/rubocop/config.rb', line 187

def for_cop(cop)
  @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/rubocop/config.rb', line 120

def key?(key)
  @hash.key?(key)
end

#keys ⇒ Object 



124
125
126
 
# File 'lib/rubocop/config.rb', line 124

def keys
  @hash.keys
end

#make_excludes_absolute ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/rubocop/config.rb', line 148

def make_excludes_absolute
  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) && !absolute?(exclude_elem)
        File.expand_path(File.join(base_dir_for_path_parameters,
                                   exclude_elem))
      else
        exclude_elem
      end
    end
  end
end

#map(&block) ⇒ Object 



128
129
130
 
# File 'lib/rubocop/config.rb', line 128

def map(&block)
  @hash.map(&block)
end

#merge(other_hash) ⇒ Object 



132
133
134
 
# File 'lib/rubocop/config.rb', line 132

def merge(other_hash)
  @hash.merge(other_hash)
end

#path_relative_to_config(path) ⇒ Object 



262
263
264
 
# File 'lib/rubocop/config.rb', line 262

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

#patterns_to_exclude ⇒ Object 



258
259
260
 
# File 'lib/rubocop/config.rb', line 258

def patterns_to_exclude
  for_all_cops['Exclude']
end

#patterns_to_include ⇒ Object 



254
255
256
 
# File 'lib/rubocop/config.rb', line 254

def patterns_to_include
  for_all_cops['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) 


239
240
241
242
243
244
245
 
# File 'lib/rubocop/config.rb', line 239

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

#target_ruby_version ⇒ Object 



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/rubocop/config.rb', line 282

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

#to_h ⇒ Object 



136
137
138
 
# File 'lib/rubocop/config.rb', line 136

def to_h
  @hash
end

#to_hash ⇒ Object 



140
141
142
 
# File 'lib/rubocop/config.rb', line 140

def to_hash
  @hash
end

#to_s ⇒ Object 



144
145
146
 
# File 'lib/rubocop/config.rb', line 144

def to_s
  @to_s ||= @hash.to_s
end

#validate ⇒ Object 



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/rubocop/config.rb', line 203

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_and_parameters
  warn_about_unrecognized_cops(invalid_cop_names)
  check_target_ruby
  validate_parameter_names(valid_cop_names)
  validate_enforced_styles(valid_cop_names)
end