Class: RuboCop::Cop::Base

# File 'lib/rubocop/cop/base.rb', line 111

def self.lint?
  department == :Lint
end

# File 'lib/rubocop/cop/base.rb', line 93

def self.support_autocorrect?
  false
end

# File 'lib/rubocop/cop/base.rb', line 137

def self.support_multiple_source?
  false
end

# File 'lib/rubocop/cop/base.rb', line 99

def self.badge
  @badge ||= Badge.for(name)
end

# File 'lib/rubocop/cop/base.rb', line 353

def self.callbacks_needed
  @callbacks_needed ||= public_instance_methods.select do |m|
    # OPTIMIZE: `start_with?` with two string arguments instead of a regex
    # is faster in this specific case.
    m.start_with?('on_', 'after_') &&
      # exclude standard "callbacks" like 'on_new_investigation' unless refined
      instance_method(m).owner != Base
  end
end

# File 'lib/rubocop/cop/base.rb', line 103

def self.cop_name
  badge.to_s
end

# File 'lib/rubocop/cop/base.rb', line 107

def self.department
  badge.department
end

# File 'lib/rubocop/cop/base.rb', line 76

def self.documentation_url(config = nil)
  Documentation.url_for(self, config)
end

# File 'lib/rubocop/cop/base.rb', line 87

def self.exclude_from_registry
  Registry.global.dismiss(self)
end

# File 'lib/rubocop/cop/base.rb', line 80

def self.inherited(subclass)
  super
  subclass.instance_variable_set(:@gem_requirements, gem_requirements.dup)
  Registry.global.enlist(subclass)
end

# File 'lib/rubocop/cop/base.rb', line 124

def self.joining_forces; end

# File 'lib/rubocop/cop/base.rb', line 117

def self.match?(given_names)
  return false unless given_names

  given_names.include?(cop_name) || given_names.include?(badge.department_name)
end

# File 'lib/rubocop/cop/base.rb', line 159

def requires_gem(gem_name, *version_requirements)
  @gem_requirements[gem_name] = Gem::Requirement.new(version_requirements)
end

# File 'lib/rubocop/cop/base.rb', line 404

private_class_method def self.restrict_on_send
  @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
end

# File 'lib/rubocop/cop/base.rb', line 380

def always_autocorrect?
  # `true` is the same as `'always'` for backward compatibility.
  ['always', true].include?(cop_config.fetch('AutoCorrect', 'always'))
end

# File 'lib/rubocop/cop/base.rb', line 43

attr_reader :config, :processed_source

# File 'lib/rubocop/cop/base.rb', line 256

def config_to_allow_offenses
  Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] ||= {}
end

# File 'lib/rubocop/cop/base.rb', line 260

def config_to_allow_offenses=(hash)
  Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] = hash
end

# File 'lib/rubocop/cop/base.rb', line 386

def contextual_autocorrect?
  cop_config.fetch('AutoCorrect', 'always') == 'contextual'
end

# File 'lib/rubocop/cop/base.rb', line 391

def disabled_autocorrect?
  # `false` is the same as `'disabled'` for backward compatibility.
  ['disabled', false].include?(cop_config['AutoCorrect'])
end

# File 'lib/rubocop/cop/base.rb', line 304

def preview?
  @config.preview?(@options)
end

# File 'lib/rubocop/cop/base.rb', line 43

attr_reader :config, :processed_source

# File 'lib/rubocop/cop/base.rb', line 44

attr_accessor :project_index

# File 'lib/rubocop/cop/base.rb', line 297

def string_literals_frozen_by_default?
  @config.string_literals_frozen_by_default?
end

# File 'lib/rubocop/cop/base.rb', line 631

def target_satisfies_all_gem_version_requirements?
  self.class.gem_requirements.all? do |gem_name, version_requirement|
    gem_version = target_gem_version(gem_name)

    gem_version && version_requirement.satisfied_by?(gem_version)
  end
end

# File 'lib/rubocop/cop/base.rb', line 209

def add_offense(node_or_range, message: nil, severity: nil, &block)
  range = range_from_node_or_range(node_or_range)
  return unless current_offense_locations.add?(range)

  range_to_pass = callback_argument(range)

  severity = find_severity(range_to_pass, severity)
  message = find_message(range_to_pass, message)

  status, corrector = enabled_lines?(range) ? correct(range, &block) : :disabled

  current_offenses << new_offense(range, severity, message, status, corrector)
end

# File 'lib/rubocop/cop/base.rb', line 540

def annotate(message)
  RuboCop::Cop::MessageAnnotator.new(
    config, cop_name, cop_config, @options
  ).annotate(message)
end

# File 'lib/rubocop/cop/base.rb', line 430

def apply_correction(corrector)
  current_corrector&.merge!(corrector) if corrector
end

# File 'lib/rubocop/cop/base.rb', line 504

def attempt_correction(range, corrector)
  if corrector
    status = :corrected
  elsif disable_uncorrectable?
    corrector = disable_uncorrectable(range)
    status = :corrected_with_todo
  else
    return :unsupported
  end

  apply_correction(corrector)
  status
end

# File 'lib/rubocop/cop/base.rb', line 366

def begin_investigation(processed_source, offset: 0, original: processed_source)
  @current_offenses = nil
  @current_offense_locations = nil
  @currently_disabled_lines = nil
  @processed_source = processed_source
  @current_corrector = nil

  # We need to keep track of the original source and offset,
  # because `processed_source` here may be an embedded code in it.
  @current_offset = offset
  @current_original = original
end

# File 'lib/rubocop/cop/base.rb', line 426

def callback_argument(range)
  range
end

# File 'lib/rubocop/cop/base.rb', line 348

def callbacks_needed
  self.class.callbacks_needed
end

# File 'lib/rubocop/cop/base.rb', line 455

def complete_investigation
  InvestigationReport.new(
    self, processed_source, @current_offenses || EMPTY_OFFENSES, @current_corrector
  )
ensure
  reset_investigation
end

# File 'lib/rubocop/cop/base.rb', line 250

def cop_config
  # Use department configuration as basis, but let individual cop
  # configuration override.
  @cop_config ||= @config.for_badge(self.class.badge)
end

# File 'lib/rubocop/cop/base.rb', line 242

def cop_name
  @cop_name ||= self.class.cop_name
end

# File 'lib/rubocop/cop/base.rb', line 473

def correct(range)
  if block_given?
    corrector = Corrector.new(self)
    yield corrector
    if corrector.empty?
      corrector = nil
    elsif !self.class.support_autocorrect?
      raise "The Cop #{name} must `extend AutoCorrector` to be able to autocorrect"
    end
  end

  [use_corrector(range, corrector), corrector]
end

# File 'lib/rubocop/cop/base.rb', line 592

def covering_disabled_range(range)
  disabled_ranges = @processed_source.comment_config.cop_disabled_line_ranges[cop_name]
  disabled_ranges&.find do |disabled_range|
    disabled_range.end >= range.first_line && disabled_range.begin <= range.last_line
  end
end

# File 'lib/rubocop/cop/base.rb', line 444

def current_corrector
  @current_corrector ||= Corrector.new(@processed_source) if @processed_source.valid_syntax?
end

# File 'lib/rubocop/cop/base.rb', line 436

def current_offense_locations
  @current_offense_locations ||= Set.new
end

# File 'lib/rubocop/cop/base.rb', line 448

def current_offenses
  @current_offenses ||= []
end

# File 'lib/rubocop/cop/base.rb', line 440

def currently_disabled_lines
  @currently_disabled_lines ||= Set.new
end

# File 'lib/rubocop/cop/base.rb', line 607

def custom_severity
  severity = cop_config['Severity']
  return unless severity

  if Severity::NAMES.include?(severity.to_sym)
    severity.to_sym
  else
    message = "Warning: Invalid severity '#{severity}'. " \
              "Valid severities are #{Severity::NAMES.join(', ')}."
    warn(Rainbow(message).red)
  end
end

# File 'lib/rubocop/cop/base.rb', line 603

def default_severity
  DEPARTMENT_SEVERITIES.fetch(self.class.department, :convention)
end

# File 'lib/rubocop/cop/base.rb', line 518

def disable_uncorrectable(range)
  line = range.line
  return unless currently_disabled_lines.add?(line)

  disable_offense(range)
end

# File 'lib/rubocop/cop/base.rb', line 569

def enabled_line?(line_number)
  return true if @options[:ignore_disable_comments] || !@processed_source

  @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
end

# File 'lib/rubocop/cop/base.rb', line 578

def enabled_lines?(range)
  return true if @options[:ignore_disable_comments] || !@processed_source

  comment_config = @processed_source.comment_config
  comment_config.cop_enabled_at_lines?(self, range.first_line, range.last_line)
end

# File 'lib/rubocop/cop/base.rb', line 317

def excluded_file?(file)
  !relevant_file?(file)
end

# File 'lib/rubocop/cop/base.rb', line 238

def external_dependency_checksum
  nil
end

# File 'lib/rubocop/cop/base.rb', line 546

def file_name_matches_any?(file, parameter, default_result)
  patterns = cop_config[parameter]
  return default_result unless patterns

  file_patterns = FilePatterns.from(patterns)
  relative_file_path = config.path_relative_to_config(file)
  return true if file_patterns.match?(relative_file_path)

  if parameter == 'Include' && !relative_file_path.start_with?('..')
    matches_absolute_include_pattern?(patterns, file)
  else
    file_patterns.match?(file)
  end
end

# File 'lib/rubocop/cop/base.rb', line 536

def find_message(range, message)
  annotate(message || message(range))
end

# File 'lib/rubocop/cop/base.rb', line 599

def find_severity(_range, severity)
  custom_severity || severity || default_severity
end

# File 'lib/rubocop/cop/base.rb', line 396

def inspect # :nodoc:
  "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
end

# File 'lib/rubocop/cop/base.rb', line 561

def matches_absolute_include_pattern?(patterns, file)
  absolute_file_path = absolute?(file) ? file : File.expand_path(file)
  patterns.any? do |pattern|
    (absolute?(pattern.to_s) || pattern.to_s.start_with?('..')) &&
      match_path?(pattern, absolute_file_path)
  end
end

# File 'lib/rubocop/cop/base.rb', line 191

def message(_range = nil)
  self.class::MSG
end

# File 'lib/rubocop/cop/base.rb', line 246

alias name cop_name

# File 'lib/rubocop/cop/base.rb', line 409

def new_offense(range, severity, message, status, corrector)
  justification = suppression_reason(range) if status == :disabled

  # Since this range may be generated from Ruby code embedded in some
  # template file, we convert it to location info in the original file.
  # A cop configured with `AutoCorrect: false` reports no edits, since
  # nothing that honors the configuration applies them. The corrector
  # stays, so an editor can still offer it as a quick fix to choose.
  corrections = [] if corrector && disabled_autocorrect?

  Offense.new(severity, range_for_original(range), message, name, status, corrector,
              justification: justification, correction_safe: safe_autocorrect?,
              corrections: corrections)
end

# File 'lib/rubocop/cop/base.rb', line 339

def offenses
  raise 'The offenses are not directly available; ' \
        'they are returned as the result of the investigation'
end

# File 'lib/rubocop/cop/base.rb', line 178

def on_investigation_end
  # Typically do nothing here
end

# File 'lib/rubocop/cop/base.rb', line 172

def on_new_investigation
  # Typically do nothing here
end

# File 'lib/rubocop/cop/base.rb', line 184

def on_other_file
  # Typically do nothing here
end

# File 'lib/rubocop/cop/base.rb', line 322

def parse(source, path = nil)
  ProcessedSource.new(source, target_ruby_version, path, parser_engine: parser_engine)
end

# File 'lib/rubocop/cop/base.rb', line 285

def parser_engine
  @config.parser_engine
end

# File 'lib/rubocop/cop/base.rb', line 620

def range_for_original(range)
  buffer = @current_original.buffer
  return range if @current_offset.zero? && range.source_buffer.equal?(buffer)

  ::Parser::Source::Range.new(
    buffer,
    range.begin_pos + @current_offset,
    range.end_pos + @current_offset
  )
end

# File 'lib/rubocop/cop/base.rb', line 525

def range_from_node_or_range(node_or_range)
  if node_or_range.respond_to?(:loc)
    node_or_range.source_range
  elsif node_or_range.is_a?(::Parser::Source::Range)
    node_or_range
  else
    extra = ' (call `add_global_offense`)' if node_or_range.nil?
    raise "Expected a Source::Range, got #{node_or_range.inspect}#{extra}"
  end
end

# File 'lib/rubocop/cop/base.rb', line 328

def ready
  return self if self.class.support_multiple_source?

  self.class.new(@config, @options).tap do |fresh|
    fresh.project_index = @project_index
  end
end

# File 'lib/rubocop/cop/base.rb', line 308

def relevant_file?(file)
  return false unless target_satisfies_all_gem_version_requirements?
  return true unless @config.clusivity_config_for_badge?(self.class.badge)

  file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
    (file_name_matches_any?(file, 'Include', true) &&
      !file_name_matches_any?(file, 'Exclude', false))
end

# File 'lib/rubocop/cop/base.rb', line 465

def reset_investigation
  @currently_disabled_lines = nil
  @current_offenses = nil
  @processed_source = nil
  @current_corrector = nil
end

# File 'lib/rubocop/cop/base.rb', line 587

def suppression_reason(range)
  covering = covering_disabled_range(range)
  covering.directive.reason if covering.respond_to?(:directive)
end

# File 'lib/rubocop/cop/base.rb', line 280

def target_gem_version(gem_name)
  gem_versions = @config.gem_versions_in_target
  gem_versions && gem_versions[gem_name]
end

# File 'lib/rubocop/cop/base.rb', line 289

def target_rails_version
  @config.target_rails_version
end

# File 'lib/rubocop/cop/base.rb', line 264

def target_ruby_version
  @config.target_ruby_version
end

# File 'lib/rubocop/cop/base.rb', line 488

def use_corrector(range, corrector)
  if autocorrect?
    attempt_correction(range, corrector)
  elsif skipped_unsafe_correction_with_disable_uncorrectable?
    # The unsafe correction will not run, so the offense is
    # uncorrectable for this run and gets a todo comment.
    attempt_correction(range, nil)
  elsif corrector && (always_autocorrect? ||
                      (contextual_autocorrect? && !contextual_autocorrect_held_back?))
    :uncorrected
  else
    :unsupported
  end
end