Class: RuboCop::Config

# File 'lib/rubocop/config.rb', line 207

def disabled_new_cops?
  for_all_cops['NewCops'] == 'disable'
end

# File 'lib/rubocop/config.rb', line 211

def enabled_new_cops?
  for_all_cops['NewCops'] == 'enable'
end

# File 'lib/rubocop/config.rb', line 109

def internal?
  base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME, 'config'))
  File.expand_path(loaded_path).start_with?(base_config_path)
end

# File 'lib/rubocop/config.rb', line 21

attr_reader :loaded_path

# File 'lib/rubocop/config.rb', line 268

def possibly_include_hidden?
  return @possibly_include_hidden if defined?(@possibly_include_hidden)

  @possibly_include_hidden = patterns_to_include.any? do |s|
    s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
  end
end

# File 'lib/rubocop/config.rb', line 233

def string_literals_frozen_by_default?
  for_all_cops['StringLiteralsFrozenByDefault']
end

# File 'lib/rubocop/config.rb', line 257

def allowed_camel_case_file?(file)
  # Gemspecs are allowed to have dashes because that fits with bundler best
  # practices in the case when the gem is nested under a namespace (e.g.,
  # `bundler-console` conveys `Bundler::Console`).
  return true if File.extname(file) == '.gemspec'

  file_to_include?(file) { |pattern| /[A-Z]/.match?(pattern.to_s) }
end

# File 'lib/rubocop/config.rb', line 298

def base_dir_for_path_parameters
  @base_dir_for_path_parameters ||=
    if loaded_path && File.basename(loaded_path).start_with?('.rubocop') &&
       loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
      File.expand_path(File.dirname(loaded_path))
    else
      PathUtil.pwd
    end
end

# File 'lib/rubocop/config.rb', line 328

def bundler_lock_file_path
  return nil unless loaded_path

  base_path = base_dir_for_path_parameters
  ['Gemfile.lock', 'gems.locked'].each do |file_name|
    path = find_file_upwards(file_name, base_path)
    return path if path
  end
  nil
end

# File 'lib/rubocop/config.rb', line 84

def check
  deprecation_check { |deprecation_message| warn("#{loaded_path} - #{deprecation_message}") }
  @validator.validate
  make_excludes_absolute
  self
end

# File 'lib/rubocop/config.rb', line 183

def clusivity_config_for_badge?(badge)
  exists = @clusivity_config_exists_cache[badge.to_s]
  return exists unless exists.nil?

  cop_config = for_badge(badge)
  @clusivity_config_exists_cache[badge.to_s] = cop_config['Include'] || cop_config['Exclude']
end

# File 'lib/rubocop/config.rb', line 454

def comparable_version(value)
  value = value.to_s
  Gem::Version.new(value) if value.match?(/\A\d/) && Gem::Version.correct?(value)
end

# File 'lib/rubocop/config.rb', line 203

def cop_enabled?(name)
  !!for_cop(name)['Enabled']
end

# File 'lib/rubocop/config.rb', line 414

def department_of(qualified_cop_name)
  *cop_department, _ = qualified_cop_name.split('/')
  return nil if cop_department.empty?

  self[cop_department.join('/')]
end

# File 'lib/rubocop/config.rb', line 138

def deprecation_check
  %w[Exclude Include].each do |key|
    plural = "#{key}s"
    next unless for_all_cops[plural]

    for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
    for_all_cops.delete(plural)
    yield "AllCops/#{plural} was renamed to AllCops/#{key}"
  end
end

# File 'lib/rubocop/config.rb', line 402

def enable_cop?(qualified_cop_name, cop_options)
  # If the cop is explicitly enabled or `Lint/Syntax`, the other checks can be skipped.
  return true if cop_options['Enabled'] == true || qualified_cop_name == 'Lint/Syntax'

  department = department_of(qualified_cop_name)
  cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
  return true if cop_enabled == 'override_department'
  return false if department && department['Enabled'] == false

  cop_enabled
end

# File 'lib/rubocop/config.rb', line 219

def enabled_new_cop?(qualified_cop_name)
  setting = new_cops_setting_for(qualified_cop_name)

  case setting.to_s
  when 'enable' then true
  when '', 'pending', 'disable' then false
  else new_cops_version_covers?(setting, qualified_cop_name)
  end
end

# File 'lib/rubocop/config.rb', line 276

def file_to_exclude?(file)
  file = File.expand_path(file)
  patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
end

# File 'lib/rubocop/config.rb', line 240

def file_to_include?(file)
  relative_file_path = path_relative_to_config(file)

  # Optimization to quickly decide if the given file is hidden (on the top
  # level) and cannot be matched by any pattern.
  is_hidden = relative_file_path.start_with?('.') && !relative_file_path.start_with?('..')
  return false if is_hidden && !possibly_include_hidden?

  absolute_file_path = File.expand_path(file)

  patterns_to_include.any? do |pattern|
    next if block_given? && !yield(pattern)

    match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
  end
end

# File 'lib/rubocop/config.rb', line 199

def for_all_cops
  @for_all_cops ||= self['AllCops'] || {}
end

# File 'lib/rubocop/config.rb', line 165

def for_badge(badge)
  @badge_config_cache[badge] ||= begin
    department_config = self[badge.department_name]
    cop_config = for_cop(badge.to_s)
    if department_config
      merged_config = department_config.merge(cop_config)
      if department_config['Exclude'] && cop_config['Exclude']
        merged_config['Exclude'] = department_config['Exclude'] | cop_config['Exclude']
      end
      merged_config
    else
      cop_config
    end
  end
end

# File 'lib/rubocop/config.rb', line 152

def for_cop(cop)
  @for_cop[cop]
end

# File 'lib/rubocop/config.rb', line 194

def for_department(department_name)
  @for_department ||= Hash.new { |h, dept| h[dept] = self[dept] || {} }
  @for_department[department_name.to_s]
end

# File 'lib/rubocop/config.rb', line 159

def for_enabled_cop(cop)
  cop_enabled?(cop) ? for_cop(cop) : EMPTY_CONFIG
end

# File 'lib/rubocop/config.rb', line 389

def gem_version_to_major_minor_float(gem_version)
  segments = gem_version.segments
  Float("#{segments[0]}.#{segments[1]}")
end

# File 'lib/rubocop/config.rb', line 354

def gem_versions_in_target
  @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
end

# File 'lib/rubocop/config.rb', line 358

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

# File 'lib/rubocop/config.rb', line 80

def loaded_features
  @loaded_features ||= ConfigLoader.loaded_features
end

# File 'lib/rubocop/config.rb', line 76

def loaded_plugins
  @loaded_plugins ||= ConfigLoader.loaded_plugins
end

# File 'lib/rubocop/config.rb', line 114

def make_excludes_absolute
  each_key do |key|
    dig(key, 'Exclude')&.map! do |exclude_elem|
      if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
        File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
      else
        exclude_elem
      end
    end
  end
end

# File 'lib/rubocop/config.rb', line 364

def match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
  should_use_absolute_path = absolute?(pattern.to_s) || pattern.to_s.start_with?('..') ||
                             relative_file_path.start_with?('..')
  match_path?(pattern, should_use_absolute_path ? absolute_file_path : relative_file_path)
end

# File 'lib/rubocop/config.rb', line 433

def new_cops_covered?(qualified_cop_name)
  setting = new_cops_setting_for(qualified_cop_name)

  case setting.to_s
  when 'enable', 'disable' then true
  when '', 'pending' then false
  else new_cops_version_covers?(setting, qualified_cop_name)
  end
end

# File 'lib/rubocop/config.rb', line 423

def new_cops_setting_for(qualified_cop_name)
  department = department_of(qualified_cop_name)
  setting = department['NewCops'] if department

  setting || for_all_cops['NewCops']
end

# File 'lib/rubocop/config.rb', line 443

def new_cops_version_covers?(new_cops_version, qualified_cop_name)
  cop_metadata = self[qualified_cop_name]
  version_added = comparable_version(cop_metadata['VersionAdded']) if cop_metadata
  pinned_version = comparable_version(new_cops_version)
  return false if version_added.nil? || pinned_version.nil?

  version_added <= pinned_version
end

# File 'lib/rubocop/config.rb', line 308

def parser_engine
  @parser_engine ||= for_all_cops.fetch('ParserEngine', :default).to_sym
end

# File 'lib/rubocop/config.rb', line 289

def path_relative_to_config(path)
  relative_path(path, base_dir_for_path_parameters)
end

# File 'lib/rubocop/config.rb', line 285

def patterns_to_exclude
  for_all_cops['Exclude'] || []
end

# File 'lib/rubocop/config.rb', line 281

def patterns_to_include
  for_all_cops['Include'] || []
end

# File 'lib/rubocop/config.rb', line 339

def pending_cops
  keys.each_with_object([]) do |qualified_cop_name, pending_cops|
    department = department_of(qualified_cop_name)
    next if department && department['Enabled'] == false

    cop_metadata = self[qualified_cop_name]
    next unless cop_metadata['Enabled'] == 'pending'
    next if new_cops_covered?(qualified_cop_name)

    pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
  end
end

# File 'lib/rubocop/config.rb', line 395

def read_gem_versions_from_target_lockfile
  lockfile_path = bundler_lock_file_path
  return nil unless lockfile_path

  Lockfile.new(lockfile_path).gem_versions
end

# File 'lib/rubocop/config.rb', line 376

def read_rails_version_from_bundler_lock_file
  return nil unless gem_versions_in_target

  # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
  # See https://github.com/rubocop/rubocop/pull/11289
  rails_version_in_target = gem_versions_in_target['railties']
  return nil unless rails_version_in_target

  gem_version_to_major_minor_float(rails_version_in_target)
end

# File 'lib/rubocop/config.rb', line 104

def signature
  @signature ||= Digest::SHA1.hexdigest(to_s)
end

# File 'lib/rubocop/config.rb', line 323

def smart_loaded_path
  PathUtil.smart_path(@loaded_path)
end

# File 'lib/rubocop/config.rb', line 312

def target_rails_version
  @target_rails_version ||=
    if for_all_cops['TargetRailsVersion']
      for_all_cops['TargetRailsVersion'].to_f
    elsif target_rails_version_from_bundler_lock_file
      target_rails_version_from_bundler_lock_file
    else
      DEFAULT_RAILS_VERSION
    end
end

# File 'lib/rubocop/config.rb', line 371

def target_rails_version_from_bundler_lock_file
  @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
end

# File 'lib/rubocop/config.rb', line 100

def to_s
  @to_s ||= @hash.to_s
end

# File 'lib/rubocop/config.rb', line 91

def validate_after_resolution
  @validator.validate_after_resolution
  self
end