class RuboCop::Runner
This class handles the processing of files, which includes dealing with formatters and letting cops inspect the files.
Constants
- MAX_ITERATIONS
@api private
Attributes
aborting[W]
errors[R]
warnings[R]
Public Class Methods
new(options, config_store)
click to toggle source
# File lib/rubocop/runner.rb, line 33 def initialize(options, config_store) @options = options @config_store = config_store @errors = [] @warnings = [] @aborting = false end
Public Instance Methods
aborting?()
click to toggle source
# File lib/rubocop/runner.rb, line 57 def aborting? @aborting end
run(paths)
click to toggle source
# File lib/rubocop/runner.rb, line 41 def run(paths) target_files = find_target_files(paths) if @options[:list_target_files] list_files(target_files) else warm_cache(target_files) if @options[:parallel] inspect_files(target_files) end rescue Interrupt self.aborting = true warn '' warn 'Exiting...' false end
Private Instance Methods
add_redundant_disables(file, offenses, source)
click to toggle source
# File lib/rubocop/runner.rb, line 170 def add_redundant_disables(file, offenses, source) team_for_redundant_disables(file, offenses, source) do |team| new_offenses, redundant_updated = inspect_file(source, team) offenses += new_offenses if redundant_updated # Do one extra inspection loop if any redundant disables were # removed. This is done in order to find rubocop:enable directives that # have now become useless. _source, new_offenses = do_inspection_loop(file) offenses |= new_offenses end end offenses end
cached_result(file, team)
click to toggle source
# File lib/rubocop/runner.rb, line 144 def cached_result(file, team) ResultCache.new(file, team, @options, @config_store) end
cached_run?()
click to toggle source
# File lib/rubocop/runner.rb, line 222 def cached_run? @cached_run ||= (@options[:cache] == 'true' || (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) && # When running --auto-gen-config, there's some processing done in the # cops related to calculating the Max parameters for Metrics cops. We # need to do that processing and cannot use caching. !@options[:auto_gen_config] && # We can't cache results from code which is piped in to stdin !@options[:stdin] end
check_for_infinite_loop(processed_source, offenses_by_iteration)
click to toggle source
Check whether a run created source identical to a previous run, which means that we definitely have an infinite loop.
# File lib/rubocop/runner.rb, line 300 def check_for_infinite_loop(processed_source, offenses_by_iteration) checksum = processed_source.checksum if (loop_start_index = @processed_sources.index(checksum)) raise InfiniteCorrectionLoop.new( processed_source.path, offenses_by_iteration, loop_start: loop_start_index ) end @processed_sources << checksum end
check_for_redundant_disables?(source)
click to toggle source
# File lib/rubocop/runner.rb, line 196 def check_for_redundant_disables?(source) !source.disabled_line_ranges.empty? && !filtered_run? end
considered_failure?(offense)
click to toggle source
# File lib/rubocop/runner.rb, line 380 def considered_failure?(offense) # For :autocorrect level, any offense - corrected or not - is a failure. return false if offense.disabled? return true if @options[:fail_level] == :autocorrect !offense.corrected? && offense.severity >= minimum_severity_to_fail end
default_config(cop_name)
click to toggle source
# File lib/rubocop/runner.rb, line 413 def default_config(cop_name) RuboCop::ConfigLoader.default_configuration[cop_name] end
do_inspection_loop(file)
click to toggle source
# File lib/rubocop/runner.rb, line 244 def do_inspection_loop(file) processed_source = get_processed_source(file) # This variable is 2d array used to track corrected offenses after each # inspection iteration. This is used to output meaningful infinite loop # error message. offenses_by_iteration = [] # When running with --autocorrect, we need to inspect the file (which # includes writing a corrected version of it) until no more corrections # are made. This is because automatic corrections can introduce new # offenses. In the normal case the loop is only executed once. iterate_until_no_changes(processed_source, offenses_by_iteration) do # The offenses that couldn't be corrected will be found again so we # only keep the corrected ones in order to avoid duplicate reporting. !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?) new_offenses, updated_source_file = inspect_file(processed_source) offenses_by_iteration.push(new_offenses) # We have to reprocess the source to pickup the changes. Since the # change could (theoretically) introduce parsing errors, we break the # loop if we find any. break unless updated_source_file processed_source = get_processed_source(file) end # Return summary of corrected offenses after all iterations offenses = offenses_by_iteration.flatten.uniq [processed_source, offenses] end
each_inspected_file(files) { |file| ... }
click to toggle source
# File lib/rubocop/runner.rb, line 107 def each_inspected_file(files) files.reduce(true) do |all_passed, file| offenses = process_file(file) yield file if offenses.any? { |o| considered_failure?(o) } break false if @options[:fail_fast] next false end all_passed end end
file_finished(file, offenses)
click to toggle source
# File lib/rubocop/runner.rb, line 217 def file_finished(file, offenses) offenses = offenses_to_report(offenses) formatter_set.file_finished(file, offenses) end
file_offense_cache(file) { || ... }
click to toggle source
# File lib/rubocop/runner.rb, line 148 def file_offense_cache(file) config = @config_store.for_file(file) cache = cached_result(file, standby_team(config)) if cached_run? if cache&.valid? offenses = cache.load # If we're running --autocorrect and the cache says there are # offenses, we need to actually inspect the file. If the cache shows no # offenses, we're good. real_run_needed = @options[:autocorrect] && offenses.any? else real_run_needed = true end if real_run_needed offenses = yield save_in_cache(cache, offenses) end offenses end
file_offenses(file)
click to toggle source
# File lib/rubocop/runner.rb, line 136 def file_offenses(file) file_offense_cache(file) do source, offenses = do_inspection_loop(file) offenses = add_redundant_disables(file, offenses.compact.sort, source) offenses.sort.reject(&:disabled?).freeze end end
file_started(file)
click to toggle source
# File lib/rubocop/runner.rb, line 212 def file_started(file) puts "Scanning #{file}" if @options[:debug] formatter_set.file_started(file, cli_options: @options, config_store: @config_store) end
filter_cop_classes(cop_classes, config)
click to toggle source
# File lib/rubocop/runner.rb, line 360 def filter_cop_classes(cop_classes, config) # use only cops that link to a style guide if requested return unless style_guide_cops_only?(config) cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] } end
filtered_run?()
click to toggle source
# File lib/rubocop/runner.rb, line 208 def filtered_run? @options[:except] || @options[:only] end
find_target_files(paths)
click to toggle source
# File lib/rubocop/runner.rb, line 78 def find_target_files(paths) target_finder = TargetFinder.new(@config_store, @options) mode = if @options[:only_recognized_file_types] :only_recognized_file_types else :all_file_types end target_files = target_finder.find(paths, mode) target_files.each(&:freeze).freeze end
formatter_set()
click to toggle source
# File lib/rubocop/runner.rb, line 371 def formatter_set @formatter_set ||= begin set = Formatter::FormatterSet.new(@options) pairs = @options[:formatters] || [['progress']] pairs.each { |formatter_key, output_path| set.add_formatter(formatter_key, output_path) } set end end
get_processed_source(file)
click to toggle source
# File lib/rubocop/runner.rb, line 425 def get_processed_source(file) ruby_version = @config_store.for_file(file).target_ruby_version if @options[:stdin] ProcessedSource.new(@options[:stdin], ruby_version, file) else begin ProcessedSource.from_file(file, ruby_version) rescue Errno::ENOENT raise RuboCop::Error, "No such file or directory: #{file}" end end end
inspect_file(processed_source, team = mobilize_team(processed_source))
click to toggle source
# File lib/rubocop/runner.rb, line 314 def inspect_file(processed_source, team = mobilize_team(processed_source)) report = team.investigate(processed_source) @errors.concat(team.errors) @warnings.concat(team.warnings) [report.offenses, team.updated_source_file?] end
inspect_files(files)
click to toggle source
# File lib/rubocop/runner.rb, line 89 def inspect_files(files) inspected_files = [] formatter_set.started(files) each_inspected_file(files) { |file| inspected_files << file } ensure # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization # mainly targets editors that integrates RuboCop. When RuboCop is run # by an editor, it should be inspecting only one file. if files.size > 1 && cached_run? ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root]) end formatter_set.finished(inspected_files.freeze) formatter_set.close_output_files end
iterate_until_no_changes(source, offenses_by_iteration) { || ... }
click to toggle source
# File lib/rubocop/runner.rb, line 275 def iterate_until_no_changes(source, offenses_by_iteration) # Keep track of the state of the source. If a cop modifies the source # and another cop undoes it producing identical source we have an # infinite loop. @processed_sources = [] # It is also possible for a cop to keep adding indefinitely to a file, # making it bigger and bigger. If the inspection loop runs for an # excessively high number of iterations, this is likely happening. iterations = 0 loop do check_for_infinite_loop(source, offenses_by_iteration) if (iterations += 1) > MAX_ITERATIONS raise InfiniteCorrectionLoop.new(source.path, offenses_by_iteration) end source = yield break unless source end end
list_files(paths)
click to toggle source
# File lib/rubocop/runner.rb, line 122 def list_files(paths) paths.each { |path| puts PathUtil.relative_path(path) } end
mark_as_safe_by_config?(config)
click to toggle source
# File lib/rubocop/runner.rb, line 409 def mark_as_safe_by_config?(config) config.nil? || (config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true)) end
minimum_severity_to_fail()
click to toggle source
# File lib/rubocop/runner.rb, line 417 def minimum_severity_to_fail @minimum_severity_to_fail ||= begin # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail name = @options[:fail_level] || :refactor RuboCop::Cop::Severity.new(name) end end
mobilize_team(processed_source)
click to toggle source
# File lib/rubocop/runner.rb, line 321 def mobilize_team(processed_source) config = @config_store.for_file(processed_source.path) Cop::Team.mobilize(mobilized_cop_classes(config), config, @options) end
mobilized_cop_classes(config)
click to toggle source
# File lib/rubocop/runner.rb, line 326 def mobilized_cop_classes(config) # rubocop:disable Metrics/AbcSize @mobilized_cop_classes ||= {}.compare_by_identity @mobilized_cop_classes[config] ||= begin cop_classes = Cop::Registry.all # `@options[:only]` and `@options[:except]` are not qualified until # needed so that the Registry can be fully loaded, including any # cops added by `require`s. qualify_option_cop_names OptionsValidator.new(@options).validate_cop_options if @options[:only] cop_classes.select! { |c| c.match?(@options[:only]) } else filter_cop_classes(cop_classes, config) end cop_classes.reject! { |c| c.match?(@options[:except]) } Cop::Registry.new(cop_classes, @options) end end
offenses_to_report(offenses)
click to toggle source
# File lib/rubocop/runner.rb, line 389 def offenses_to_report(offenses) if @options[:display_only_fail_level_offenses] offenses.select { |o| considered_failure?(o) } elsif @options[:display_only_safe_correctable] offenses.select { |o| supports_safe_autocorrect?(o) } elsif @options[:display_only_correctable] offenses.select(&:correctable?) else offenses end end
process_file(file)
click to toggle source
# File lib/rubocop/runner.rb, line 126 def process_file(file) file_started(file) offenses = file_offenses(file) rescue InfiniteCorrectionLoop => e offenses = e.offenses.compact.sort.freeze raise ensure file_finished(file, offenses || []) end
qualify_option_cop_names()
click to toggle source
# File lib/rubocop/runner.rb, line 350 def qualify_option_cop_names %i[only except].each do |option| next unless @options[option] @options[option].map! do |cop_name| Cop::Registry.qualified_cop_name(cop_name, "--#{option} option") end end end
redundant_cop_disable_directive(file) { |cop| ... }
click to toggle source
# File lib/rubocop/runner.rb, line 200 def redundant_cop_disable_directive(file) config = @config_store.for_file(file) return unless config.for_cop(Cop::Lint::RedundantCopDisableDirective).fetch('Enabled') cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options) yield cop if cop.relevant_file?(file) end
save_in_cache(cache, offenses)
click to toggle source
# File lib/rubocop/runner.rb, line 234 def save_in_cache(cache, offenses) return unless cache # Caching results when a cop has crashed would prevent the crash in the # next run, since the cop would not be called then. We want crashes to # show up the same in each run. return if errors.any? || warnings.any? cache.save(offenses) end
standby_team(config)
click to toggle source
A Cop::Team
instance is stateful and may change when inspecting. The “standby” team for a given config is an initialized but otherwise dormant team that can be used for config- and option- level caching in ResultCache
.
# File lib/rubocop/runner.rb, line 443 def standby_team(config) @team_by_config ||= {}.compare_by_identity @team_by_config[config] ||= Cop::Team.mobilize(mobilized_cop_classes(config), config, @options) end
style_guide_cops_only?(config)
click to toggle source
# File lib/rubocop/runner.rb, line 367 def style_guide_cops_only?(config) @options[:only_guide_cops] || config.for_all_cops['StyleGuideCopsOnly'] end
supports_safe_autocorrect?(offense)
click to toggle source
# File lib/rubocop/runner.rb, line 401 def supports_safe_autocorrect?(offense) cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name) default_cfg = default_config(offense.cop_name) offense.correctable? && cop_class&.support_autocorrect? && mark_as_safe_by_config?(default_cfg) end
team_for_redundant_disables(file, offenses, source) { |team| ... }
click to toggle source
# File lib/rubocop/runner.rb, line 185 def team_for_redundant_disables(file, offenses, source) return unless check_for_redundant_disables?(source) config = @config_store.for_file(file) team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options) return if team.cops.empty? team.cops.first.offenses_to_check = offenses yield team end
warm_cache(target_files)
click to toggle source
Warms up the RuboCop
cache by forking a suitable number of RuboCop
instances that each inspects its allotted group of files.
# File lib/rubocop/runner.rb, line 65 def warm_cache(target_files) saved_options = @options.dup if target_files.length <= 1 puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug] return end puts 'Running parallel inspection' if @options[:debug] %i[autocorrect safe_autocorrect].each { |opt| @options[opt] = false } Parallel.each(target_files) { |target_file| file_offenses(target_file) } ensure @options = saved_options end