Class: RuboCop::Cop::Base

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

def self.lint?
  department == :Lint
end

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

def self.support_autocorrect?
  false
end

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

def self.support_multiple_source?
  false
end

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

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

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

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 98

def self.cop_name
  badge.to_s
end

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

def self.department
  badge.department
end

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

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

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

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

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

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 119

def self.joining_forces; end

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

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 154

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

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

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 363

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 257

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

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

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

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

def contextual_autocorrect?
  cop_config.fetch('AutoCorrect', 'always') == 'contextual'
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 287

def string_literals_frozen_by_default?
  @config.string_literals_frozen_by_default?
end

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

def target_satisfies_all_gem_version_requirements?
  gem_requirements = self.class.gem_requirements
  return true if gem_requirements.empty?

  gem_requirements.all? do |gem_name, version_req|
    all_gem_versions_in_target = @config.gem_versions_in_target
    next false unless all_gem_versions_in_target

    gem_version_in_target = all_gem_versions_in_target[gem_name]
    next false unless gem_version_in_target

    version_req.satisfied_by?(gem_version_in_target)
  end
end

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

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
  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.
  range = range_for_original(range)

  current_offenses << Offense.new(severity, range, message, name, status, corrector,
                                  justification: justification)
end

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

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

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

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

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

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 349

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 387

def callback_argument(range)
  range
end

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

def callbacks_needed
  self.class.callbacks_needed
end

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

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 251

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 243

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

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

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 552

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 405

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

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

def current_offense_locations
  @current_offense_locations ||= Set.new
end

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

def current_offenses
  @current_offenses ||= []
end

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

def currently_disabled_lines
  @currently_disabled_lines ||= Set.new
end

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

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 563

def default_severity
  self.class.lint? ? :warning : :convention
end

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

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 529

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 538

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 300

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

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

def external_dependency_checksum
  nil
end

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

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 496

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

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

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

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

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

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

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 186

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

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

alias name cop_name

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

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 173

def on_investigation_end
  # Typically do nothing here
end

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

def on_new_investigation
  # Typically do nothing here
end

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

def on_other_file
  # Typically do nothing here
end

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

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

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

def parser_engine
  @config.parser_engine
end

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

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 485

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 311

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 291

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 426

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

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

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 271

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

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

def target_rails_version
  @config.target_rails_version
end

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

def target_ruby_version
  @config.target_ruby_version
end

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

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? && !LSP.enabled?))
    :uncorrected
  else
    :unsupported
  end
end