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.



225
226
227
 
# File 'lib/rubocop/options.rb', line 225

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.



191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/rubocop/options.rb', line 191

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) 


280
281
282
 
# File 'lib/rubocop/options.rb', line 280

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

#except_syntax? ⇒ Boolean

Returns:

  • (Boolean) 


275
276
277
278
 
# File 'lib/rubocop/options.rb', line 275

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

#incompatible_options ⇒ Object 



288
289
290
 
# File 'lib/rubocop/options.rb', line 288

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

#no_offense_counts_without_auto_gen_config? ⇒ Boolean

Returns:

  • (Boolean) 


284
285
286
 
# File 'lib/rubocop/options.rb', line 284

def no_offense_counts_without_auto_gen_config?
  @options.key?(:no_offense_counts) && !@options.key?(:auto_gen_config)
end

#only_includes_unneeded_disable? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#validate_compatibility ⇒ Object

rubocop:disable Metrics/MethodLength

Raises:

  • (ArgumentError) 


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

def validate_compatibility # rubocop:disable Metrics/MethodLength
  if only_includes_unneeded_disable?
    raise ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
  end
  if except_syntax?
    raise ArgumentError, 'Syntax checking can not be turned off.'
  end
  unless boolean_or_empty_cache?
    raise ArgumentError, '-C/--cache argument must be true or false'
  end
  if no_offense_counts_without_auto_gen_config?
    raise ArgumentError, '--no-offense-counts can only be used together ' \
                         'with --auto-gen-config.'
  end
  validate_parallel

  return if incompatible_options.size <= 1
  raise ArgumentError, 'Incompatible cli options: ' \
                       "#{incompatible_options.inspect}"
end

#validate_exclude_limit_option(args) ⇒ Object

Raises:

  • (ArgumentError) 


292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'lib/rubocop/options.rb', line 292

def validate_exclude_limit_option(args)
  if @options[:exclude_limit] !~ /^\d+$/
    # Emulate OptionParser's behavior to make failures consistent regardless
    # of option order.
    raise OptionParser::MissingArgument
  end

  # --exclude-limit is valid if there's a parsed or yet unparsed
  # --auto-gen-config.
  return if @options[:auto_gen_config] || args.include?('--auto-gen-config')

  raise ArgumentError,
        '--exclude-limit can only be used with --auto-gen-config.'
end

#validate_parallel ⇒ Object 



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/rubocop/options.rb', line 250

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

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

  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 can not be combined with -F/--fail-fast.',
    auto_correct: '-P/--parallel can not be combined with --auto-correct.'
  }

  combos.each { |key, msg| raise ArgumentError, msg if @options.key?(key) }
end