Class: RuboCop::OptionsValidator

Inherits:
Object
  • Object
show all
Defined in:
lib/rubocop/options.rb

Overview

Validates option arguments and the options’ compatibility with each other.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ OptionsValidator

Returns a new instance of OptionsValidator.



264
265
266
 
# File 'lib/rubocop/options.rb', line 264

def initialize(options)
  @options = options
end

Class Method Details

.validate_cop_list(names) ⇒ Object

Cop name validation must be done later than option parsing, so it’s not called from within Options.



233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/rubocop/options.rb', line 233

def validate_cop_list(names)
  return unless names

  cop_names = Cop::Cop.registry.names
  departments = Cop::Cop.registry.departments.map(&:to_s)

  names.each do |name|
    next if cop_names.include?(name)
    next if departments.include?(name)
    next if %w[Syntax Lint/Syntax].include?(name)

    raise IncorrectCopNameError, format_message_from(name, cop_names)
  end
end

Instance Method Details

#boolean_or_empty_cache? ⇒ Boolean

Returns:

  • (Boolean) 


372
373
374
 
# File 'lib/rubocop/options.rb', line 372

def boolean_or_empty_cache?
  !@options.key?(:cache) || %w[true false].include?(@options[:cache])
end

#display_only_fail_level_offenses_with_autocorrect? ⇒ Boolean

Returns:

  • (Boolean) 


363
364
365
 
# File 'lib/rubocop/options.rb', line 363

def display_only_fail_level_offenses_with_autocorrect?
  @options[:display_only_fail_level_offenses] && @options[:autocorrect]
end

#except_syntax? ⇒ Boolean

Returns:

  • (Boolean) 


367
368
369
370
 
# File 'lib/rubocop/options.rb', line 367

def except_syntax?
  @options.key?(:except) &&
    (@options[:except] & %w[Lint/Syntax Syntax]).any?
end

#incompatible_options ⇒ Object 



376
377
378
 
# File 'lib/rubocop/options.rb', line 376

def incompatible_options
  @incompatible_options ||= @options.keys & Options::EXITING_OPTIONS
end

#only_includes_redundant_disable? ⇒ Boolean

Returns:

  • (Boolean) 


357
358
359
360
361
 
# File 'lib/rubocop/options.rb', line 357

def only_includes_redundant_disable?
  @options.key?(:only) &&
    (@options[:only] & %w[Lint/RedundantCopDisableDirective
                          RedundantCopDisableDirective]).any?
end

#validate_auto_correct ⇒ Object

Raises:



323
324
325
326
327
328
329
 
# File 'lib/rubocop/options.rb', line 323

def validate_auto_correct
  return if @options.key?(:auto_correct)
  return unless @options.key?(:disable_uncorrectable)

  raise OptionArgumentError,
        format('--disable-uncorrectable can only be used together with --auto-correct.')
end

#validate_auto_gen_config ⇒ Object

rubocop:enable Metrics/AbcSize



301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/rubocop/options.rb', line 301

def validate_auto_gen_config
  return if @options.key?(:auto_gen_config)

  message = '--%<flag>s can only be used together with --auto-gen-config.'

  %i[exclude_limit no_offense_counts no_auto_gen_timestamp
     auto_gen_only_exclude].each do |option|
    if @options.key?(option)
      raise OptionArgumentError,
            format(message, flag: option.to_s.tr('_', '-'))
    end
  end
end

#validate_compatibility ⇒ Object

rubocop:disable Metrics/AbcSize

Raises:



275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/rubocop/options.rb', line 275

def validate_compatibility # rubocop:disable Metrics/MethodLength
  if only_includes_redundant_disable?
    raise OptionArgumentError, 'Lint/RedundantCopDisableDirective cannot ' \
                               'be used with --only.'
  end
  raise OptionArgumentError, 'Syntax checking cannot be turned off.' if except_syntax?
  unless boolean_or_empty_cache?
    raise OptionArgumentError, '-C/--cache argument must be true or false'
  end

  if display_only_fail_level_offenses_with_autocorrect?
    raise OptionArgumentError, '--autocorrect cannot be used with ' \
      '--display-only-fail-level-offenses'
  end
  validate_auto_gen_config
  validate_auto_correct
  validate_display_only_failed
  validate_parallel

  return if incompatible_options.size <= 1

  raise OptionArgumentError, 'Incompatible cli options: ' \
                             "#{incompatible_options.inspect}"
end

#validate_cop_options ⇒ Object 



268
269
270
271
272
 
# File 'lib/rubocop/options.rb', line 268

def validate_cop_options
  %i[only except].each do |opt|
    OptionsValidator.validate_cop_list(@options[opt])
  end
end

#validate_display_only_failed ⇒ Object

Raises:



315
316
317
318
319
320
321
 
# File 'lib/rubocop/options.rb', line 315

def validate_display_only_failed
  return unless @options.key?(:display_only_failed)
  return if @options[:format] == 'junit'

  raise OptionArgumentError,
        format('--display-only-failed can only be used together with --format junit.')
end

#validate_exclude_limit_option ⇒ Object

Raises:

  • (OptionParser::MissingArgument) 


380
381
382
383
384
385
386
 
# File 'lib/rubocop/options.rb', line 380

def validate_exclude_limit_option
  return if /^\d+$/.match?(@options[:exclude_limit])

  # Emulate OptionParser's behavior to make failures consistent regardless
  # of option order.
  raise OptionParser::MissingArgument
end

#validate_parallel ⇒ Object 



331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/rubocop/options.rb', line 331

def validate_parallel
  return unless @options.key?(:parallel)

  if @options[:cache] == 'false'
    raise OptionArgumentError, '-P/--parallel uses caching to speed up ' \
                               'execution, so combining with --cache ' \
                               'false is not allowed.'
  end

  validate_parallel_with_combo_option
end

#validate_parallel_with_combo_option ⇒ Object 



343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/rubocop/options.rb', line 343

def validate_parallel_with_combo_option
  combos = {
    auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
                     'while --auto-gen-config needs a non-cached run, ' \
                     'so they cannot be combined.',
    fail_fast: '-P/--parallel cannot be combined with -F/--fail-fast.',
    auto_correct: '-P/--parallel cannot be combined with --auto-correct.'
  }

  combos.each do |key, msg|
    raise OptionArgumentError, msg if @options.key?(key)
  end
end