Class: Gem::Commands::PristineCommand

# File 'lib/rubygems/commands/pristine_command.rb', line 71

def defaults_str # :nodoc:
  "--extensions"
end

# File 'lib/rubygems/commands/pristine_command.rb', line 75

def description # :nodoc:
  <<-EOF
The pristine command compares an installed gem with the contents of its
cached .gem file and restores any files that don't match the cached .gem's
copy.

If you have made modifications to an installed gem, the pristine command
will revert them.  All extensions are rebuilt and all bin stubs for the gem
are regenerated after checking for modifications.

If the cached gem cannot be found it will be downloaded.

If --no-extensions is provided pristine will not attempt to restore a gem
with an extension.

If --extensions is given (but not --all or gem names) only gems with
extensions will be restored.
  EOF
end

# File 'lib/rubygems/commands/pristine_command.rb', line 99

def execute
  specs = if options[:all]
    Gem::Specification.map

  # `--extensions` must be explicitly given to pristine only gems
  # with extensions.
  elsif options[:extensions_set] &&
        options[:extensions] && options[:args].empty?
    Gem::Specification.select do |spec|
      spec.extensions && !spec.extensions.empty?
    end
  else
    get_all_gem_names.sort.map do |gem_name|
      Gem::Specification.find_all_by_name(gem_name, options[:version]).reverse
    end.flatten
  end

  specs = specs.select {|spec| RUBY_ENGINE == spec.platform || Gem::Platform.local === spec.platform || spec.platform == Gem::Platform::RUBY }

  if specs.to_a.empty?
    raise Gem::Exception,
          "Failed to find gems #{options[:args]} #{options[:version]}"
  end

  say "Restoring gems to pristine condition..."

  specs.each do |spec|
    if spec.default_gem?
      say "Skipped #{spec.full_name}, it is a default gem"
      next
    end

    if options.has_key? :skip
      if options[:skip].include? spec.name
        say "Skipped #{spec.full_name}, it was given through options"
        next
      end
    end

    unless spec.extensions.empty? || options[:extensions] || options[:only_executables] || options[:only_plugins]
      say "Skipped #{spec.full_name}, it needs to compile an extension"
      next
    end

    gem = spec.cache_file

    unless File.exist?(gem) || options[:only_executables] || options[:only_plugins]
      require_relative "../remote_fetcher"

      say "Cached gem for #{spec.full_name} not found, attempting to fetch..."

      dep = Gem::Dependency.new spec.name, spec.version
      found, _ = Gem::SpecFetcher.fetcher.spec_for_dependency dep

      if found.empty?
        say "Skipped #{spec.full_name}, it was not found from cache and remote sources"
        next
      end

      spec_candidate, source = found.first
      Gem::RemoteFetcher.fetcher.download spec_candidate, source.uri.to_s, spec.base_dir
    end

    env_shebang =
      if options.include? :env_shebang
        options[:env_shebang]
      else
        install_defaults = Gem::ConfigFile::PLATFORM_DEFAULTS["install"]
        install_defaults.to_s["--env-shebang"]
      end

    bin_dir = options[:bin_dir] if options[:bin_dir]
    install_dir = options[:install_dir] if options[:install_dir]

    installer_options = {
      :wrappers => true,
      :force => true,
      :install_dir => install_dir || spec.base_dir,
      :env_shebang => env_shebang,
      :build_args => spec.build_args,
      :bin_dir => bin_dir,
    }

    if options[:only_executables]
      installer = Gem::Installer.for_spec(spec, installer_options)
      installer.generate_bin
    elsif options[:only_plugins]
      installer = Gem::Installer.for_spec(spec, installer_options)
      installer.generate_plugins
    else
      installer = Gem::Installer.at(gem, installer_options)
      installer.install
    end

    say "Restored #{spec.full_name}"
  end
end

# File 'lib/rubygems/commands/pristine_command.rb', line 95

def usage # :nodoc:
  "#{program_name} [GEMNAME ...]"
end