/**
* Decorate a package.
*
* @param string $packageName The name of the package to decorate.
*
* @return VersionedPackage
*
* @throws \InvalidArgumentException When the package could not be found.
*/
protected function decorate($packageName)
{
$results = $this->repository->findPackages($packageName);
if (!count($results)) {
throw new \InvalidArgumentException('Could not find package with specified name ' . $packageName);
}
$latest = array_slice($results, 0, 1)[0];
$versions = array_slice($results, 1);
$package = new VersionedPackage($latest, $versions);
return $this->decorateWithPackagistStats($package);
}
/**
* prints all available versions of this package and highlights the installed one if any
*/
protected function printVersions(InputInterface $input, OutputInterface $output, PackageInterface $package, RepositoryInterface $installedRepo, RepositoryInterface $repos)
{
if ($input->getArgument('version')) {
$output->writeln('<info>version</info> : ' . $package->getPrettyVersion());
return;
}
$versions = array();
foreach ($repos->findPackages($package->getName()) as $version) {
$versions[$version->getPrettyVersion()] = $version->getVersion();
}
uasort($versions, 'version_compare');
$versions = implode(', ', array_keys(array_reverse($versions)));
// highlight installed version
if ($installedRepo->hasPackage($package)) {
$versions = str_replace($package->getPrettyVersion(), '<info>* ' . $package->getPrettyVersion() . '</info>', $versions);
}
$output->writeln('<info>versions</info> : ' . $versions);
}
/**
* @param WritableRepositoryInterface $localRepo
* @param Pool $pool
* @param PolicyInterface $policy
* @param array $repositories
* @param RepositoryInterface $installedRepo
* @param RepositoryInterface $lockedRepository
* @param string $task
* @param array|null $operations
* @return array
*/
private function processDevPackages($localRepo, $pool, $policy, $repositories, $installedRepo, $lockedRepository, $task, array $operations = null)
{
if ($task === 'force-updates' && null === $operations) {
throw new \InvalidArgumentException('Missing operations argument');
}
if ($task === 'force-links') {
$operations = array();
}
if ($this->update && $this->updateWhitelist) {
$currentPackages = $this->getCurrentPackages($installedRepo);
}
foreach ($localRepo->getCanonicalPackages() as $package) {
// skip non-dev packages
if (!$package->isDev()) {
continue;
}
// skip packages that will be updated/uninstalled
foreach ($operations as $operation) {
if ('update' === $operation->getJobType() && $operation->getInitialPackage()->equals($package) || 'uninstall' === $operation->getJobType() && $operation->getPackage()->equals($package)) {
continue 2;
}
}
if ($this->update) {
// skip package if the whitelist is enabled and it is not in it
if ($this->updateWhitelist && !$this->isUpdateable($package)) {
// check if non-updateable packages are out of date compared to the lock file to ensure we don't corrupt it
foreach ($currentPackages as $curPackage) {
if ($curPackage->isDev() && $curPackage->getName() === $package->getName() && $curPackage->getVersion() === $package->getVersion()) {
if ($task === 'force-links') {
$package->setRequires($curPackage->getRequires());
$package->setConflicts($curPackage->getConflicts());
$package->setProvides($curPackage->getProvides());
$package->setReplaces($curPackage->getReplaces());
} elseif ($task === 'force-updates') {
if ($curPackage->getSourceReference() && $curPackage->getSourceReference() !== $package->getSourceReference() || $curPackage->getDistReference() && $curPackage->getDistReference() !== $package->getDistReference()) {
$operations[] = new UpdateOperation($package, $curPackage);
}
}
break;
}
}
continue;
}
// find similar packages (name/version) in all repositories
$matches = $pool->whatProvides($package->getName(), new Constraint('=', $package->getVersion()));
foreach ($matches as $index => $match) {
// skip local packages
if (!in_array($match->getRepository(), $repositories, true)) {
unset($matches[$index]);
continue;
}
// skip providers/replacers
if ($match->getName() !== $package->getName()) {
unset($matches[$index]);
continue;
}
$matches[$index] = $match->getId();
}
// select preferred package according to policy rules
if ($matches && ($matches = $policy->selectPreferredPackages($pool, array(), $matches))) {
$newPackage = $pool->literalToPackage($matches[0]);
if ($task === 'force-links' && $newPackage) {
$package->setRequires($newPackage->getRequires());
$package->setConflicts($newPackage->getConflicts());
$package->setProvides($newPackage->getProvides());
$package->setReplaces($newPackage->getReplaces());
}
if ($task === 'force-updates' && $newPackage && ($newPackage->getSourceReference() && $newPackage->getSourceReference() !== $package->getSourceReference() || $newPackage->getDistReference() && $newPackage->getDistReference() !== $package->getDistReference())) {
$operations[] = new UpdateOperation($package, $newPackage);
continue;
}
}
if ($task === 'force-updates') {
// force installed package to update to referenced version in root package if it does not match the installed version
$references = $this->package->getReferences();
if (isset($references[$package->getName()]) && $references[$package->getName()] !== $package->getSourceReference()) {
// changing the source ref to update to will be handled in the operations loop
$operations[] = new UpdateOperation($package, clone $package);
}
}
} else {
// force update to locked version if it does not match the installed version
foreach ($lockedRepository->findPackages($package->getName()) as $lockedPackage) {
if ($lockedPackage->isDev() && $lockedPackage->getVersion() === $package->getVersion()) {
if ($task === 'force-links') {
$package->setRequires($lockedPackage->getRequires());
$package->setConflicts($lockedPackage->getConflicts());
$package->setProvides($lockedPackage->getProvides());
$package->setReplaces($lockedPackage->getReplaces());
} elseif ($task === 'force-updates') {
if ($lockedPackage->getSourceReference() && $lockedPackage->getSourceReference() !== $package->getSourceReference() || $lockedPackage->getDistReference() && $lockedPackage->getDistReference() !== $package->getDistReference()) {
$operations[] = new UpdateOperation($package, $lockedPackage);
}
}
break;
}
}
}
}
return $operations;
}
/**
* Gets All or filtered Packages of a Repository.
*
* @param RepositoryInterface $repo a Repository
*
* @return PackageInterface[]
*/
private function getPackages(RepositoryInterface $repo)
{
$packages = array();
if ($this->hasFilterForPackages()) {
// apply package filter if defined
foreach ($this->packagesFilter as $filter) {
$packages += $repo->findPackages($filter);
}
} else {
// process other repos directly
$packages = $repo->getPackages();
}
return $packages;
}
/**
* Search the repository for a package.
*
* @param string $name The pretty name of the package to search.
*
* @param RepositoryInterface $repository The repository to be searched.
*
* @return null|PackageInterface
*/
private function findPackage($name, RepositoryInterface $repository)
{
/** @var PackageInterface[] $packages */
$packages = $repository->findPackages($name);
while (!empty($packages) && $packages[0] instanceof AliasPackage) {
array_shift($packages);
}
if (empty($packages)) {
return null;
}
return $packages[0];
}
/**
* Build a list of not yet installed packages.
*
* @param RepositoryInterface $repository
*
* @return array
*/
public function buildNotInstalledList(RootPackageInterface $rootPackage, RepositoryInterface $localRepository)
{
$requires = $rootPackage->getRequires();
$notInstalledList = array();
/** @var Link $requiredConstraint */
foreach ($requires as $requiredName => $requiredConstraint) {
$packages = $localRepository->findPackages($requiredName);
if (empty($packages)) {
$notInstalledList[$requiredName] = $requiredConstraint;
}
}
return $notInstalledList;
}
/**
* Retrieve the installed version of a package (if any).
*
* @param RepositoryInterface $localRepository The local repository.
*
* @param string $packageName The name of the package to search.
*
* @return null|string
*/
private function getInstalledVersion($localRepository, $packageName)
{
if (count($installed = $localRepository->findPackages($packageName))) {
/** @var PackageInterface[] $installed */
return $installed[0]->getPrettyVersion();
}
return null;
}
