class Gem::Specification

# File rubygems/specification.rb, line 189
def removed_method_calls
  @removed_method_calls ||= []
end

# File rubygems/specification.rb, line 548
def add_dependency(gem, *requirements)
  if requirements.uniq.size != requirements.size
    warn "WARNING: duplicated #{gem} dependency #{requirements}"
  end

  add_dependency_with_type(gem, :runtime, requirements)
end

# File rubygems/specification.rb, line 537
def add_development_dependency(gem, *requirements)
  add_dependency_with_type(gem, :development, requirements)
end

# File rubygems/specification.rb, line 415
def author=(o)
  self.authors = [o]
end

# File rubygems/specification.rb, line 571
def executables
  @executables ||= []
end

# File rubygems/specification.rb, line 588
def extensions
  @extensions ||= []
end

# File rubygems/specification.rb, line 604
def extra_rdoc_files
  @extra_rdoc_files ||= []
end

# File rubygems/specification.rb, line 466
def platform=(platform)
  @original_platform = platform

  case platform
  when Gem::Platform::CURRENT then
    @new_platform = Gem::Platform.local
    @original_platform = @new_platform.to_s

  when Gem::Platform then
    @new_platform = platform

  # legacy constants
  when nil, Gem::Platform::RUBY then
    @new_platform = Gem::Platform::RUBY
  when "mswin32" then # was Gem::Platform::WIN32
    @new_platform = Gem::Platform.new "x86-mswin32"
  when "i586-linux" then # was Gem::Platform::LINUX_586
    @new_platform = Gem::Platform.new "x86-linux"
  when "powerpc-darwin" then # was Gem::Platform::DARWIN
    @new_platform = Gem::Platform.new "ppc-darwin"
  else
    @new_platform = Gem::Platform.new platform
  end

  @platform = @new_platform.to_s

  invalidate_memoized_attributes
end

# File rubygems/specification.rb, line 634
def rdoc_options
  @rdoc_options ||= []
end

# File rubygems/specification.rb, line 512
def require_paths=(val)
  @require_paths = Array(val)
end

# File rubygems/specification.rb, line 664
def required_ruby_version=(req)
  @required_ruby_version = Gem::Requirement.create req

  @required_ruby_version.requirements.map! do |op, v|
    if v >= LATEST_RUBY_WITHOUT_PATCH_VERSIONS && v.release.segments.size == 4
      [op == "~>" ? "=" : op, Gem::Version.new(v.segments.tap {|s| s.delete_at(3) }.join("."))]
    else
      [op, v]
    end
  end
end

# File rubygems/specification.rb, line 679
def required_rubygems_version=(req)
  @required_rubygems_version = Gem::Requirement.create req
end

# File rubygems/specification.rb, line 692
def requirements
  @requirements ||= []
end

# File rubygems/specification.rb, line 719
def extensions_dir
  @extensions_dir ||= super
end

# File rubygems/specification.rb, line 351
def license=(o)
  self.licenses = [o]
end

# File rubygems/specification.rb, line 368
def licenses=(licenses)
  @licenses = Array licenses
end

# File rubygems/specification.rb, line 270
def authors=(value)
  @authors = Array(value).flatten.grep(String)
end

# File rubygems/specification.rb, line 250
def files
  # DO NOT CHANGE TO ||= ! This is not a normal accessor. (yes, it sucks)
  # DOC: Why isn't it normal? Why does it suck? How can we fix this?
  @files = [@files,
            @test_files,
            add_bindir(@executables),
            @extra_rdoc_files,
            @extensions].flatten.compact.uniq.sort
end

# File rubygems/specification.rb, line 1245
def self._load(str)
  Gem.load_yaml
  Gem.load_safe_marshal

  yaml_set = false
  retry_count = 0

  array = begin
    Gem::SafeMarshal.safe_load str
  rescue ArgumentError => e
    # Avoid an infinite retry loop when the argument error has nothing to do
    # with the classes not being defined.
    # 1 retry each allowed in case all 3 of
    # - YAML
    # - YAML::Syck::DefaultKey
    # - YAML::PrivateType
    # need to be defined
    raise if retry_count >= 3

    #
    # Some very old marshaled specs included references to `YAML::PrivateType`
    # and `YAML::Syck::DefaultKey` constants due to bugs in the old emitter
    # that generated them. Workaround the issue by defining the necessary
    # constants and retrying.
    #
    message = e.message
    raise unless message.include?("YAML::")

    unless Object.const_defined?(:YAML)
      Object.const_set "YAML", Psych
      yaml_set = true
    end

    if message.include?("YAML::Syck::")
      YAML.const_set "Syck", YAML unless YAML.const_defined?(:Syck)

      YAML::Syck.const_set "DefaultKey", Class.new if message.include?("YAML::Syck::DefaultKey") && !YAML::Syck.const_defined?(:DefaultKey)
    elsif message.include?("YAML::PrivateType") && !YAML.const_defined?(:PrivateType)
      YAML.const_set "PrivateType", Class.new
    end

    retry_count += 1
    retry
  ensure
    Object.__send__(:remove_const, "YAML") if yaml_set
  end

  spec = Gem::Specification.new
  spec.instance_variable_set :@specification_version, array[1]

  current_version = CURRENT_SPECIFICATION_VERSION

  field_count = if spec.specification_version > current_version
    spec.instance_variable_set :@specification_version,
                               current_version
    MARSHAL_FIELDS[current_version]
  else
    MARSHAL_FIELDS[spec.specification_version]
  end

  if array.size < field_count
    raise TypeError, "invalid Gem::Specification format #{array.inspect}"
  end

  spec.instance_variable_set :@rubygems_version,          array[0]
  # spec version
  spec.instance_variable_set :@name,                      array[2]
  spec.instance_variable_set :@version,                   array[3]
  spec.date =                                             array[4]
  spec.instance_variable_set :@summary,                   array[5]
  spec.instance_variable_set :@required_ruby_version,     array[6]
  spec.instance_variable_set :@required_rubygems_version, array[7]
  spec.platform =                                         array[8]
  spec.instance_variable_set :@dependencies,              array[9]
  # offset due to rubyforge_project removal
  spec.instance_variable_set :@email,                     array[11]
  spec.instance_variable_set :@authors,                   array[12]
  spec.instance_variable_set :@description,               array[13]
  spec.instance_variable_set :@homepage,                  array[14]
  spec.instance_variable_set :@has_rdoc,                  array[15]
  spec.instance_variable_set :@licenses,                  [array[17]]
  spec.instance_variable_set :@metadata,                  array[18]
  spec.instance_variable_set :@loaded,                    false
  spec.instance_variable_set :@activated,                 false

  spec
end

# File rubygems/specification.rb, line 858
def self.add_spec(spec)
  specification_record.add_spec(spec)
end

# File rubygems/specification.rb, line 873
def self.all
  warn "NOTE: Specification.all called from #{caller(1, 1).first}" unless
    Gem::Deprecate.skip
  _all
end

# File rubygems/specification.rb, line 882
def self.all=(specs)
  specification_record.all = specs
end

# File rubygems/specification.rb, line 889
def self.all_names
  specification_record.all_names
end

# File rubygems/specification.rb, line 898
def self.array_attributes
  @@array_attributes.dup
end

# File rubygems/specification.rb, line 907
def self.attribute_names
  @@attributes.dup
end

# File rubygems/specification.rb, line 805
def self.default_stubs(pattern = "*.gemspec")
  base_dir = Gem.default_dir
  gems_dir = File.join base_dir, "gems"
  gemspec_stubs_in(Gem.default_specifications_dir, pattern) do |path|
    Gem::StubSpecification.default_gemspec_stub(path, base_dir, gems_dir)
  end
end

# File rubygems/specification.rb, line 914
def self.dirs
  @@dirs ||= Gem::SpecificationRecord.dirs_from(gem_path)
end

# File rubygems/specification.rb, line 922
def self.dirs=(dirs)
  reset

  @@dirs = Gem::SpecificationRecord.dirs_from(Array(dirs))
end

# File rubygems/specification.rb, line 934
def self.each(&block)
  specification_record.each(&block)
end

# File rubygems/specification.rb, line 987
def self.find_active_stub_by_path(path)
  specification_record.find_active_stub_by_path(path)
end

# File rubygems/specification.rb, line 948
def self.find_all_by_full_name(full_name)
  stubs.select {|s| s.full_name == full_name }.map(&:to_spec)
end

# File rubygems/specification.rb, line 941
def self.find_all_by_name(name, *requirements)
  specification_record.find_all_by_name(name, *requirements)
end

# File rubygems/specification.rb, line 964
def self.find_by_full_name(full_name)
  stubs.find {|s| s.full_name == full_name }&.to_spec
end

# File rubygems/specification.rb, line 956
def self.find_by_name(name, *requirements)
  requirements = Gem::Requirement.default if requirements.empty?

  Gem::Dependency.new(name, *requirements).to_spec
end

# File rubygems/specification.rb, line 971
def self.find_by_path(path)
  specification_record.find_by_path(path)
end

# File rubygems/specification.rb, line 994
def self.find_in_unresolved(path)
  unresolved_specs.find_all {|spec| spec.contains_requirable_file? path }
end

# File rubygems/specification.rb, line 1002
def self.find_in_unresolved_tree(path)
  unresolved_specs.each do |spec|
    spec.traverse do |_from_spec, _dep, to_spec, trail|
      if to_spec.has_conflicts? || to_spec.conficts_when_loaded_with?(trail)
        :next
      else
        return trail.reverse if to_spec.contains_requirable_file? path
      end
    end
  end

  []
end

# File rubygems/specification.rb, line 979
def self.find_inactive_by_path(path)
  specification_record.find_inactive_by_path(path)
end

# File rubygems/specification.rb, line 1029
def self.from_yaml(input)
  Gem.load_yaml

  input = normalize_yaml_input input
  spec = Gem::SafeYAML.safe_load input

  if spec && spec.class == FalseClass
    raise Gem::EndOfYAMLException
  end

  unless Gem::Specification === spec
    raise Gem::Exception, "YAML data doesn't evaluate to gem specification"
  end

  spec.specification_version ||= NONEXISTENT_SPECIFICATION_VERSION
  spec.reset_nil_attributes_to_default
  spec.flatten_require_paths

  spec
end

# File rubygems/specification.rb, line 1061
def self.latest_spec_for(name)
  specification_record.latest_spec_for(name)
end

# File rubygems/specification.rb, line 1054
def self.latest_specs(prerelease = false)
  specification_record.latest_specs(prerelease)
end

# File rubygems/specification.rb, line 1082
def self.load(file)
  return unless file

  spec = @load_cache_mutex.synchronize { @load_cache[file] }
  return spec if spec

  return unless File.file?(file)

  code = Gem.open_file(file, "r:UTF-8:-", &:read)

  begin
    spec = eval code, binding, file

    if Gem::Specification === spec
      spec.loaded_from = File.expand_path file.to_s
      @load_cache_mutex.synchronize do
        prev = @load_cache[file]
        if prev
          spec = prev
        else
          @load_cache[file] = spec
        end
      end
      return spec
    end

    warn "[#{file}] isn't a Gem::Specification (#{spec.class} instead)."
  rescue SignalException, SystemExit
    raise
  rescue SyntaxError, StandardError => e
    warn "Invalid gemspec in [#{file}]: #{e}"
  end

  nil
end

# File rubygems/specification.rb, line 846
def self.load_defaults
  each_spec([Gem.default_specifications_dir]) do |spec|
    # #load returns nil if the spec is bad, so we just ignore
    # it at this stage
    Gem.register_default_spec(spec)
  end
end

# File rubygems/specification.rb, line 1994
def initialize(name = nil, version = nil)
  super()
  @gems_dir              = nil
  @base_dir              = nil
  @loaded = false
  @activated = false
  @loaded_from = nil
  @original_platform = nil
  @installed_by_version = nil

  set_nil_attributes_to_nil
  set_not_nil_attributes_to_default_values

  @new_platform = Gem::Platform::RUBY

  self.name = name if name
  self.version = version if version

  if (platform = Gem.platforms.last) && platform != Gem::Platform::RUBY && platform != Gem::Platform.local
    self.platform = platform
  end

  yield self if block_given?
end

# File rubygems/specification.rb, line 1121
def self.non_nil_attributes
  @@non_nil_attributes.dup
end

# File rubygems/specification.rb, line 1128
def self.normalize_yaml_input(input)
  result = input.respond_to?(:read) ? input.read : input
  result = "--- " + result unless result.start_with?("--- ")
  result = result.dup
  result.gsub!(/ !!null \n/, " \n")
  # date: 2011-04-26 00:00:00.000000000Z
  # date: 2011-04-26 00:00:00.000000000 Z
  result.gsub!(/^(date: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+?)Z/, '\1 Z')
  result
end

# File rubygems/specification.rb, line 1146
def self.outdated
  outdated_and_latest_version.map {|local, _| local.name }
end

# File rubygems/specification.rb, line 1157
def self.outdated_and_latest_version
  return enum_for __method__ unless block_given?

  # TODO: maybe we should switch to rubygems' version service?
  fetcher = Gem::SpecFetcher.fetcher

  latest_specs(true).each do |local_spec|
    dependency =
      Gem::Dependency.new local_spec.name, ">= #{local_spec.version}"

    remotes, = fetcher.search_for_dependency dependency
    remotes  = remotes.map {|n, _| n.version }

    latest_remote = remotes.sort.last

    yield [local_spec, latest_remote] if
      latest_remote && local_spec.version < latest_remote
  end

  nil
end

# File rubygems/specification.rb, line 865
def self.remove_spec(spec)
  specification_record.remove_spec(spec)
end

# File rubygems/specification.rb, line 1182
def self.required_attribute?(name)
  @@required_attributes.include? name.to_sym
end

# File rubygems/specification.rb, line 1189
def self.required_attributes
  @@required_attributes.dup
end

# File rubygems/specification.rb, line 1197
def self.reset
  @@dirs = nil
  Gem.pre_reset_hooks.each(&:call)
  @specification_record = nil
  clear_load_cache

  unless unresolved_deps.empty?
    unresolved = unresolved_deps.filter_map do |name, dep|
      matching_versions = find_all_by_name(name)
      next if dep.latest_version? && matching_versions.any?(&:default_gem?)

      [dep, matching_versions.uniq(&:full_name)]
    end.to_h

    unless unresolved.empty?
      warn "WARN: Unresolved or ambiguous specs during Gem::Specification.reset:"
      unresolved.each do |dep, versions|
        warn "      #{dep}"

        unless versions.empty?
          warn "      Available/installed versions of this gem:"
          versions.each {|s| warn "      - #{s.version}" }
        end
      end
      warn "WARN: Clearing out unresolved specs. Try 'gem cleanup <gem>'"
      warn "Please report a bug if this causes problems."
    end

    unresolved_deps.clear
  end
  Gem.post_reset_hooks.each(&:call)
end

# File rubygems/specification.rb, line 1233
def self.specification_record
  @specification_record ||= Gem::SpecificationRecord.new(dirs)
end

# File rubygems/specification.rb, line 798
def self.stubs
  specification_record.stubs
end

# File rubygems/specification.rb, line 817
def self.stubs_for(name)
  specification_record.stubs_for(name)
end

# File rubygems/specification.rb, line 1238
def self.unresolved_deps
  @unresolved_deps ||= Hash.new {|h, n| h[n] = Gem::Dependency.new n }
end

# File rubygems/specification.rb, line 1016
def self.unresolved_specs
  unresolved_deps.values.flat_map(&:to_specs)
end

# File rubygems/specification.rb, line 1350
def _dump(limit)
  Marshal.dump [
    @rubygems_version,
    @specification_version,
    @name,
    @version,
    date,
    @summary,
    @required_ruby_version,
    @required_rubygems_version,
    @original_platform,
    @dependencies,
    "", # rubyforge_project
    @email,
    @authors,
    @description,
    @homepage,
    true, # has_rdoc
    @new_platform,
    @licenses,
    @metadata,
  ]
end

# File rubygems/specification.rb, line 1441
def abbreviate
  self.files = []
  self.test_files = []
  self.rdoc_options = []
  self.extra_rdoc_files = []
  self.cert_chain = []
end

# File rubygems/specification.rb, line 1380
def activate
  other = Gem.loaded_specs[name]
  if other
    check_version_conflict other
    return false
  end

  raise_if_conflicts

  activate_dependencies
  add_self_to_load_path

  Gem.loaded_specs[name] = self
  @activated = true
  @loaded = true

  true
end

# File rubygems/specification.rb, line 1404
def activate_dependencies
  unresolved = Gem::Specification.unresolved_deps

  runtime_dependencies.each do |spec_dep|
    if loaded = Gem.loaded_specs[spec_dep.name]
      next if spec_dep.matches_spec? loaded

      msg = "can't satisfy '#{spec_dep}', already activated '#{loaded.full_name}'"
      e = Gem::LoadError.new msg
      e.name = spec_dep.name

      raise e
    end

    begin
      specs = spec_dep.to_specs.uniq(&:full_name)
    rescue Gem::MissingSpecError => e
      raise Gem::MissingSpecError.new(e.name, e.requirement, "at: #{spec_file}")
    end

    if specs.size == 1
      specs.first.activate
    else
      name = spec_dep.name
      unresolved[name] = unresolved[name].merge spec_dep
    end
  end

  unresolved.delete self.name
end

# File rubygems/specification.rb, line 1477
def add_bindir(executables)
  return nil if executables.nil?

  if @bindir
    Array(executables).map {|e| File.join(@bindir, e) }
  else
    executables
  end
rescue StandardError
  nil
end

# File rubygems/specification.rb, line 1516
def add_self_to_load_path
  return if default_gem?

  paths = full_require_paths

  Gem.add_to_load_path(*paths)
end

# File rubygems/specification.rb, line 1527
def author
  (val = authors) && val.first
end

# File rubygems/specification.rb, line 1536
def authors
  @authors ||= []
end

# File rubygems/specification.rb, line 2048
def base_dir
  return Gem.dir unless loaded_from
  @base_dir ||= if default_gem?
    File.dirname File.dirname File.dirname loaded_from
  else
    File.dirname File.dirname loaded_from
  end
end

# File rubygems/specification.rb, line 1546
def bin_dir
  @bin_dir ||= File.join gem_dir, bindir
end

# File rubygems/specification.rb, line 1553
def bin_file(name)
  File.join bin_dir, name
end

# File rubygems/specification.rb, line 1560
def build_args
  if File.exist? build_info_file
    build_info = File.readlines build_info_file
    build_info = build_info.map(&:strip)
    build_info.delete ""
    build_info
  else
    []
  end
end

# File rubygems/specification.rb, line 1608
def build_info_dir
  File.join base_dir, "build_info"
end

# File rubygems/specification.rb, line 1616
def build_info_file
  File.join build_info_dir, "#{full_name}.info"
end

# File rubygems/specification.rb, line 1624
def cache_dir
  @cache_dir ||= File.join base_dir, "cache"
end

# File rubygems/specification.rb, line 1631
def cache_file
  @cache_file ||= File.join cache_dir, "#{full_name}.gem"
end

# File rubygems/specification.rb, line 1638
def conflicts
  conflicts = {}
  runtime_dependencies.each do |dep|
    spec = Gem.loaded_specs[dep.name]
    if spec && !spec.satisfies_requirement?(dep)
      (conflicts[spec] ||= []) << dep
    end
  end
  env_req = Gem.env_requirement(name)
  (conflicts[self] ||= []) << env_req unless env_req.satisfied_by? version
  conflicts
end

# File rubygems/specification.rb, line 1682
def date
  @date ||= Time.utc(*Gem.source_date_epoch.utc.to_a[3..5].reverse)
end

# File rubygems/specification.rb, line 1702
def date=(date)
  # We want to end up with a Time object with one-day resolution.
  # This is the cleanest, most-readable, faster-than-using-Date
  # way to do it.
  @date = case date
          when String then
            if DateTimeFormat =~ date
              Time.utc($1.to_i, $2.to_i, $3.to_i)
            else
              raise(Gem::InvalidSpecificationException,
                    "invalid date format in specification: #{date.inspect}")
            end
          when Time, DateLike then
            Time.utc(date.year, date.month, date.day)
          else
            TODAY
  end
end

# File rubygems/specification.rb, line 1742
def default_value(name)
  @@default_value[name]
end

# File rubygems/specification.rb, line 1752
def dependencies
  @dependencies ||= []
end

# File rubygems/specification.rb, line 1762
def dependent_gems(check_dev=true)
  out = []
  Gem::Specification.each do |spec|
    deps = check_dev ? spec.dependencies : spec.runtime_dependencies
    deps.each do |dep|
      next unless satisfies_requirement?(dep)
      sats = []
      find_all_satisfiers(dep) do |sat|
        sats << sat
      end
      out << [spec, dep, sats]
    end
  end
  out
end

# File rubygems/specification.rb, line 1781
def dependent_specs
  runtime_dependencies.flat_map(&:to_specs)
end

# File rubygems/specification.rb, line 1788
def description=(str)
  @description = str.to_s
end

# File rubygems/specification.rb, line 1795
def development_dependencies
  dependencies.select {|d| d.type == :development }
end

# File rubygems/specification.rb, line 1807
def doc_dir(type = nil)
  @doc_dir ||= File.join base_dir, "doc", full_name

  if type
    File.join @doc_dir, type
  else
    @doc_dir
  end
end

# File rubygems/specification.rb, line 1845
def executable
  (val = executables) && val.first
end

# File rubygems/specification.rb, line 1852
def executable=(o)
  self.executables = [o]
end

# File rubygems/specification.rb, line 1859
def executables=(value)
  @executables = Array(value)
end

# File rubygems/specification.rb, line 1866
def extensions=(extensions)
  @extensions = Array extensions
end

# File rubygems/specification.rb, line 1873
def extra_rdoc_files=(files)
  @extra_rdoc_files = Array files
end

# File rubygems/specification.rb, line 1882
def file_name
  "#{full_name}.gem"
end

# File rubygems/specification.rb, line 1889
def files=(files)
  @files = Array files
end

# File rubygems/specification.rb, line 1907
def for_cache
  spec = dup

  spec.files = nil
  spec.test_files = nil

  spec
end

# File rubygems/specification.rb, line 1916
def full_name
  @full_name ||= super
end

# File rubygems/specification.rb, line 1928
def gems_dir
  @gems_dir ||= File.join(base_dir, "gems")
end

# File rubygems/specification.rb, line 1664
def has_conflicts?
  return true unless Gem.env_requirement(name).satisfied_by?(version)
  runtime_dependencies.any? do |dep|
    spec = Gem.loaded_specs[dep.name]
    spec && !spec.satisfies_requirement?(dep)
  end
rescue ArgumentError => e
  raise e, "#{name} #{version}: #{e.message}"
end

# File rubygems/specification.rb, line 2023
def initialize_copy(other_spec)
  self.class.array_attributes.each do |name|
    name = :"@#{name}"
    next unless other_spec.instance_variable_defined? name

    begin
      val = other_spec.instance_variable_get(name)
      if val
        instance_variable_set name, val.dup
      elsif Gem.configuration.really_verbose
        warn "WARNING: #{full_name} has an invalid nil value for #{name}"
      end
    rescue TypeError
      e = Gem::FormatException.new \
        "#{full_name} has an invalid value for #{name}"

      e.file_path = loaded_from
      raise e
    end
  end

  @required_ruby_version = other_spec.required_ruby_version.dup
  @required_rubygems_version = other_spec.required_rubygems_version.dup
end

# File rubygems/specification.rb, line 2587
def keep_only_files_and_directories
  @executables.delete_if      {|x| File.directory?(File.join(@bindir, x)) }
  @extensions.delete_if       {|x| File.directory?(x) && !File.symlink?(x) }
  @extra_rdoc_files.delete_if {|x| File.directory?(x) && !File.symlink?(x) }
  @files.delete_if            {|x| File.directory?(x) && !File.symlink?(x) }
  @test_files.delete_if       {|x| File.directory?(x) && !File.symlink?(x) }
end

# File rubygems/specification.rb, line 2079
def lib_files
  @files.select do |file|
    require_paths.any? do |path|
      file.start_with? path
    end
  end
end

# File rubygems/specification.rb, line 2090
def license
  licenses.first
end

# File rubygems/specification.rb, line 2099
def licenses
  @licenses ||= []
end

# File rubygems/specification.rb, line 2136
def missing_extensions?
  return false if extensions.empty?
  return false if default_gem?
  return false if File.exist? gem_build_complete_path

  true
end

# File rubygems/specification.rb, line 2167
def name_tuple
  Gem::NameTuple.new name, version, original_platform
end

# File rubygems/specification.rb, line 2150
def normalize
  if defined?(@extra_rdoc_files) && @extra_rdoc_files
    @extra_rdoc_files.uniq!
    @files ||= []
    @files.concat(@extra_rdoc_files)
  end

  @files            = @files.uniq if @files
  @extensions       = @extensions.uniq if @extensions
  @test_files       = @test_files.uniq if @test_files
  @executables      = @executables.uniq if @executables
  @extra_rdoc_files = @extra_rdoc_files.uniq if @extra_rdoc_files
end

# File rubygems/specification.rb, line 2193
def platform
  @new_platform ||= Gem::Platform::RUBY # rubocop:disable Naming/MemoizedInstanceVariableName
end

# File rubygems/specification.rb, line 2259
def rdoc_options=(options)
  @rdoc_options = Array options
end

# File rubygems/specification.rb, line 2266
def require_path
  (val = require_paths) && val.first
end

# File rubygems/specification.rb, line 2273
def require_path=(path)
  self.require_paths = Array(path)
end

# File rubygems/specification.rb, line 2280
def requirements=(req)
  @requirements = Array req
end

# File rubygems/specification.rb, line 2645
def reset_nil_attributes_to_default
  nil_attributes = self.class.non_nil_attributes.find_all do |name|
    !instance_variable_defined?("@#{name}") || instance_variable_get("@#{name}").nil?
  end

  nil_attributes.each do |attribute|
    default = default_value attribute

    value = case default
            when Time, Numeric, Symbol, true, false, nil then default
            else default.dup
    end

    instance_variable_set "@#{attribute}", value
  end

  @installed_by_version ||= nil

  nil
end

# File rubygems/specification.rb, line 2291
def ri_dir
  @ri_dir ||= File.join base_dir, "ri", full_name
end

# File rubygems/specification.rb, line 2324
def runtime_dependencies
  dependencies.select(&:runtime?)
end

# File rubygems/specification.rb, line 1454
def sanitize
  self.summary              = sanitize_string(summary)
  self.description          = sanitize_string(description)
  self.post_install_message = sanitize_string(post_install_message)
  self.authors              = authors.collect {|a| sanitize_string(a) }
end

# File rubygems/specification.rb, line 1464
def sanitize_string(string)
  return string unless string

  # HACK: the #to_s is in here because RSpec has an Array of Arrays of
  # Strings for authors.  Need a way to disallow bad values on gemspec
  # generation.  (Probably won't happen.)
  string.to_s
end

# File rubygems/specification.rb, line 2340
def satisfies_requirement?(dependency)
  @name == dependency.name &&
    dependency.requirement.satisfied_by?(@version)
end

# File rubygems/specification.rb, line 2348
def sort_obj
  [@name, @version, Gem::Platform.sort_priority(@new_platform)]
end

# File rubygems/specification.rb, line 2363
def spec_dir
  @spec_dir ||= File.join base_dir, "specifications"
end

# File rubygems/specification.rb, line 2371
def spec_file
  @spec_file ||= File.join spec_dir, "#{full_name}.gemspec"
end

# File rubygems/specification.rb, line 2380
def spec_name
  "#{full_name}.gemspec"
end

# File rubygems/specification.rb, line 2624
def stubbed?
  false
end

# File rubygems/specification.rb, line 2387
def summary=(str)
  @summary = str.to_s.strip.
    gsub(/(\w-)\n[ \t]*(\w)/, '\1\2').gsub(/\n[ \t]*/, " ") # so. weird.
end

# File rubygems/specification.rb, line 2430
def to_ruby
  result = []
  result << "# -*- encoding: utf-8 -*-"
  result << "#{Gem::StubSpecification::PREFIX}#{name} #{version} #{platform} #{raw_require_paths.join("\0")}"
  result << "#{Gem::StubSpecification::PREFIX}#{extensions.join "\0"}" unless
    extensions.empty?
  result << nil
  result << "Gem::Specification.new do |s|"

  result << "  s.name = #{ruby_code name}"
  result << "  s.version = #{ruby_code version}"
  unless platform.nil? || platform == Gem::Platform::RUBY
    result << "  s.platform = #{ruby_code original_platform}"
  end
  result << ""
  result << "  s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version="

  if metadata && !metadata.empty?
    result << "  s.metadata = #{ruby_code metadata} if s.respond_to? :metadata="
  end
  result << "  s.require_paths = #{ruby_code raw_require_paths}"

  handled = [
    :dependencies,
    :name,
    :platform,
    :require_paths,
    :required_rubygems_version,
    :specification_version,
    :version,
    :has_rdoc,
    :default_executable,
    :metadata,
    :signing_key,
  ]

  @@attributes.each do |attr_name|
    next if handled.include? attr_name
    current_value = send(attr_name)
    if current_value != default_value(attr_name) || self.class.required_attribute?(attr_name)
      result << "  s.#{attr_name} = #{ruby_code current_value}"
    end
  end

  if String === signing_key
    result << "  s.signing_key = #{ruby_code signing_key}"
  end

  if @installed_by_version
    result << nil
    result << "  s.installed_by_version = #{ruby_code Gem::VERSION}"
  end

  unless dependencies.empty?
    result << nil
    result << "  s.specification_version = #{specification_version}"
    result << nil

    dependencies.each do |dep|
      dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK
      result << "  s.add_#{dep.type}_dependency(%q<#{dep.name}>.freeze, #{ruby_code dep.requirements_list})"
    end
  end

  result << "end"
  result << nil

  result.join "\n"
end

# File rubygems/specification.rb, line 2506
def to_ruby_for_cache
  for_cache.to_ruby
end

# File rubygems/specification.rb, line 2517
def to_spec
  self
end

# File rubygems/specification.rb, line 2548
def traverse(trail = [], visited = {}, &block)
  trail.push(self)
  begin
    runtime_dependencies.each do |dep|
      dep.matching_specs(true).each do |dep_spec|
        next if visited.key?(dep_spec)
        visited[dep_spec] = true
        trail.push(dep_spec)
        begin
          result = block[self, dep, dep_spec, trail]
        ensure
          trail.pop
        end
        next if result == :next
        spec_name = dep_spec.name
        dep_spec.traverse(trail, visited, &block) unless
          trail.any? {|s| s.name == spec_name }
      end
    end
  ensure
    trail.pop
  end
end

# File rubygems/specification.rb, line 2579
def validate(packaging = true, strict = false)
  normalize

  validation_policy = Gem::SpecificationPolicy.new(self)
  validation_policy.packaging = packaging
  validation_policy.validate(strict)
end

# File rubygems/specification.rb, line 2604
def validate_dependencies
  Gem::SpecificationPolicy.new(self).validate_dependencies
end

# File rubygems/specification.rb, line 2595
def validate_for_resolution
  Gem::SpecificationPolicy.new(self).validate_for_resolution
end

# File rubygems/specification.rb, line 2599
def validate_metadata
  Gem::SpecificationPolicy.new(self).validate_metadata
end

# File rubygems/specification.rb, line 2609
def validate_permissions
  Gem::SpecificationPolicy.new(self).validate_permissions
end

# File rubygems/specification.rb, line 2617
def version=(version)
  @version = Gem::Version.create(version)
  return if @version.nil?

  invalidate_memoized_attributes
end

# File rubygems/specification.rb, line 1494
def add_dependency_with_type(dependency, type, requirements)
  requirements = if requirements.empty?
    Gem::Requirement.default
  else
    requirements.flatten
  end

  unless dependency.respond_to?(:name) &&
         dependency.respond_to?(:requirement)
    dependency = Gem::Dependency.new(dependency.to_s, requirements, type)
  end

  dependencies << dependency
end

# File rubygems/specification.rb, line 1896
def find_all_satisfiers(dep)
  Gem::Specification.each do |spec|
    yield spec if spec.satisfies_requirement? dep
  end
end

# File rubygems/specification.rb, line 2061
def invalidate_memoized_attributes
  @full_name = nil
  @cache_file = nil
end

# File rubygems/specification.rb, line 2299
def ruby_code(obj)
  case obj
  when String             then obj.dump + ".freeze"
  when Array              then "[" + obj.map {|x| ruby_code x }.join(", ") + "]"
  when Hash               then
    seg = obj.keys.sort.map {|k| "#{k.to_s.dump} => #{obj[k].to_s.dump}" }
    "{ #{seg.join(", ")} }"
  when Gem::Version       then ruby_code(obj.to_s)
  when DateLike           then obj.strftime("%Y-%m-%d").dump
  when Time               then obj.strftime("%Y-%m-%d").dump
  when Numeric            then obj.inspect
  when true, false, nil   then obj.inspect
  when Gem::Platform      then "Gem::Platform.new(#{ruby_code obj.to_a})"
  when Gem::Requirement   then
    list = obj.as_list
    "Gem::Requirement.new(#{ruby_code(list.size == 1 ? obj.to_s : list)})"
  else raise Gem::Exception, "ruby_code case not handled: #{obj.class}"
  end
end

# File rubygems/specification.rb, line 2331
def same_attributes?(spec)
  @@attributes.all? {|name, _default| send(name) == spec.send(name) }
end