public function getMissingVersions($currentVersion, $requiredVersion)
{
$currentVersion = trim($currentVersion);
$missingVersions = array();
if (empty($currentVersion)) {
if (!empty($requiredVersion)) {
$missingVersions[] = (string) $requiredVersion;
}
return $missingVersions;
}
$requiredVersion = $this->makeVersionBackwardsCompatibleIfNoComparisonDefined($requiredVersion);
$version = new VersionParser();
$constraintsExisting = $version->parseConstraints($currentVersion);
$requiredVersions = explode(',', (string) $requiredVersion);
foreach ($requiredVersions as $required) {
$required = trim($required);
if (empty($required)) {
continue;
}
$required = $this->makeVersionBackwardsCompatibleIfNoComparisonDefined($required);
$constraintRequired = $version->parseConstraints($required);
if (!$constraintRequired->matches($constraintsExisting)) {
$missingVersions[] = $required;
}
}
return $missingVersions;
}
/**
* Check that the provided constraint is compatible with the current version of core
*
* @param string $constraint Something like ">= 1.26"
* @return bool
*/
public function check($constraint)
{
if ($this->coreVersion === false) {
// Couldn't parse the core version, so we can't check anything
return true;
}
return $this->versionParser->parseConstraints($constraint)->matches($this->coreVersion);
}
public function testLatestVersionIsReturnedThatMatchesPhpRequirement()
{
$packageName = 'foobar';
$parser = new VersionParser();
$package1 = $this->createPackage('1.0.0');
$package2 = $this->createPackage('2.0.0');
$package1->setRequires(array('php' => new Link($packageName, 'php', $parser->parseConstraints('>=5.4'), 'requires', '>=5.4')));
$package2->setRequires(array('php' => new Link($packageName, 'php', $parser->parseConstraints('>=5.6'), 'requires', '>=5.6')));
$packages = array($package1, $package2);
$pool = $this->createMockPool();
$pool->expects($this->once())->method('whatProvides')->with($packageName, null, true)->will($this->returnValue($packages));
$versionSelector = new VersionSelector($pool);
$best = $versionSelector->findBestCandidate($packageName, null, '5.5.0');
$this->assertSame($package1, $best, 'Latest version supporting php 5.5 should be returned (1.0.0)');
}
/**
* {@inheritDoc}
*/
public function parseConstraints($constraints)
{
if (!isset(self::$constraints[$constraints])) {
self::$constraints[$constraints] = parent::parseConstraints($constraints);
}
return self::$constraints[$constraints];
}
/**
* Execute.
*
* @param string $packageName Package to inspect.
* @param string $textConstraint Optional version constraint
* @param bool $onlyLocal
*
* @return Dependency[]|null
*/
public function execute($packageName, $textConstraint = '*', $onlyLocal = true)
{
// Find packages that are or provide the requested package first
$pool = $this->getRequiredPool($packageName, $textConstraint, $onlyLocal);
$packages = $pool->whatProvides($packageName);
if (empty($packages)) {
// sprintf('Could not find package "%s" in your project', $packageName),
return null;
}
// Get the needle stack
$needles = $this->getNeedles($packageName, $packages, $this->inverted);
// Parse constraint if one was supplied
$constraint = null;
if ($textConstraint !== '*') {
$versionParser = new VersionParser();
$constraint = $versionParser->parseConstraints($textConstraint);
}
$extra = $constraint !== null ? sprintf(' in versions %s "%s"', $this->inverted ? 'not matching' : 'matching', $textConstraint) : '';
// Resolve dependencies
/** @var InstalledFilesystemRepository $repository */
$repository = $this->getComposer()->getRepositoryManager()->getLocalRepository();
$results = $repository->getDependents($needles, $constraint, $this->inverted, $this->recursive);
if (empty($results)) {
// sprintf('There is no installed package depending on "%s"%s', $packageName, $extra),
return null;
}
// sprintf('The following packages are involved in the dependency on "%s"%s', $packageName, $extra),
return $this->getDependencies($results);
}
/**
* finds a package by name and version if provided
*
* @param RepositoryInterface $installedRepo
* @param RepositoryInterface $repos
* @param string $name
* @param ConstraintInterface|string $version
*
* @throws \InvalidArgumentException
* @return CompletePackageInterface
*/
private function getPackage(RepositoryInterface $installedRepo, RepositoryInterface $repos, $name, $version = null)
{
$name = strtolower($name);
$constraint = is_string($version) ? $this->versionParser->parseConstraints($version) : $version;
$policy = new DefaultPolicy();
$pool = new Pool('dev');
$pool->addRepository($repos);
$matchedPackage = null;
$matches = $pool->whatProvides($name, $constraint);
foreach ($matches as $index => $package) {
// skip providers/replacers
if ($package->getName() !== $name) {
unset($matches[$index]);
continue;
}
// select an exact match if it is in the installed repo and no specific version was required
if (null === $version && $installedRepo->hasPackage($package)) {
$matchedPackage = $package;
}
$matches[$index] = $package->getId();
}
// select preferred package according to policy rules
if (!$matchedPackage && $matches && ($preferred = $policy->selectPreferredPackages($pool, [], $matches))) {
$matchedPackage = $pool->literalToPackage($preferred[0]);
}
return $matchedPackage;
}
private function getPackageMatches($repository, $name, $version = null)
{
$pool = new Pool('dev');
$pool->addRepository($repository);
$constraint = null;
if ($version) {
$parser = new VersionParser();
$constraint = $parser->parseConstraints($version);
}
return $pool->whatProvides($name, $constraint);
}
/**
* @param \Composer\Package\Link $packageLink
* @param bool $ignoreRequiredVersion
* @param bool $exactAsTilda
* @return \Composer\Package\PackageInterface[]
*/
private function getVersionsByPackageLink(Link $packageLink, $ignoreRequiredVersion = FALSE, $exactAsTilda = FALSE)
{
$constraint = $packageLink->getConstraint();
if ($this->versionParser->parseStability($constraint->getPrettyString()) !== 'dev') {
if ($ignoreRequiredVersion) {
$constraint = NULL;
} elseif ($exactAsTilda && $this->isExact($constraint)) {
$constraint = $this->versionParser->parseConstraints(sprintf('~%s', $constraint->getPrettyString()));
}
}
return $this->getVersions($packageLink->getTarget(), $constraint);
}
public function resolve($name, $constraint, $isDevelopment)
{
$name = strtolower($name);
if (array_key_exists($name, $this->dependencies)) {
return;
}
if (!$constraint instanceof ConstraintInterface) {
$constraint = $this->versionParser->parseConstraints($constraint);
}
$package = $this->manager->findPackage($name, $constraint);
if (!$package) {
throw new RuntimeException(sprintf('Unable to find package "%s"', $name));
}
foreach ($package->getDependencies() as $dependencyName => $dependencyVersion) {
$this->resolve($dependencyName, $dependencyVersion, false);
}
foreach ($package->getDevelopmentDependencies() as $dependencyName => $dependencyVersion) {
$this->resolve($dependencyName, $dependencyVersion, true);
}
$package->setDevelopmentPackage($isDevelopment);
$this->dependencies[$name] = $package;
}
/**
* Loops over packages and adjusts the dependency constraints
*
* @param array $packages
* @return array
*/
protected function adjustGitFlowPackages(array $packages)
{
$newRequires = [];
$versionParser = new VersionParser();
foreach ($packages as $packageName => $package) {
if ('dev-master' === $package->getPrettyConstraint()) {
$branch = $this->findStabilityBranch($packageName);
$this->getIO()->writeError(' - Adjusting ' . $packageName . ' to ' . $branch);
$link = new Link($package->getSource(), $package->getTarget(), $versionParser->parseConstraints($branch), $package->getDescription(), $branch);
$newRequires[$packageName] = $link;
}
}
return $newRequires;
}
/**
* {@inheritDoc}
*/
public function findPackages($name, $constraint = null)
{
// normalize name
$name = strtolower($name);
$packages = array();
if (null !== $constraint && !$constraint instanceof ConstraintInterface) {
$versionParser = new VersionParser();
$constraint = $versionParser->parseConstraints($constraint);
}
foreach ($this->getPackages() as $package) {
if ($name === $package->getName()) {
$pkgConstraint = new Constraint('==', $package->getVersion());
if (null === $constraint || $constraint->matches($pkgConstraint)) {
$packages[] = $package;
}
}
}
return $packages;
}
/**
* Builds CompletePackages from PEAR package definition data.
*
* @param ChannelInfo $channelInfo
* @param SemverVersionParser $versionParser
* @return CompletePackage
*/
private function buildComposerPackages(ChannelInfo $channelInfo, SemverVersionParser $versionParser)
{
$result = array();
foreach ($channelInfo->getPackages() as $packageDefinition) {
foreach ($packageDefinition->getReleases() as $version => $releaseInfo) {
try {
$normalizedVersion = $versionParser->normalize($version);
} catch (\UnexpectedValueException $e) {
$this->io->writeError('Could not load ' . $packageDefinition->getPackageName() . ' ' . $version . ': ' . $e->getMessage(), true, IOInterface::VERBOSE);
continue;
}
$composerPackageName = $this->buildComposerPackageName($packageDefinition->getChannelName(), $packageDefinition->getPackageName());
// distribution url must be read from /r/{packageName}/{version}.xml::/r/g:text()
// but this location is 'de-facto' standard
$urlBits = parse_url($this->url);
$scheme = isset($urlBits['scheme']) && 'https' === $urlBits['scheme'] && extension_loaded('openssl') ? 'https' : 'http';
$distUrl = "{$scheme}://{$packageDefinition->getChannelName()}/get/{$packageDefinition->getPackageName()}-{$version}.tgz";
$requires = array();
$suggests = array();
$conflicts = array();
$replaces = array();
// alias package only when its channel matches repository channel,
// cause we've know only repository channel alias
if ($channelInfo->getName() == $packageDefinition->getChannelName()) {
$composerPackageAlias = $this->buildComposerPackageName($channelInfo->getAlias(), $packageDefinition->getPackageName());
$aliasConstraint = new Constraint('==', $normalizedVersion);
$replaces[] = new Link($composerPackageName, $composerPackageAlias, $aliasConstraint, 'replaces', (string) $aliasConstraint);
}
// alias package with user-specified prefix. it makes private pear channels looks like composer's.
if (!empty($this->vendorAlias) && ($this->vendorAlias != 'pear-' . $channelInfo->getAlias() || $channelInfo->getName() != $packageDefinition->getChannelName())) {
$composerPackageAlias = "{$this->vendorAlias}/{$packageDefinition->getPackageName()}";
$aliasConstraint = new Constraint('==', $normalizedVersion);
$replaces[] = new Link($composerPackageName, $composerPackageAlias, $aliasConstraint, 'replaces', (string) $aliasConstraint);
}
foreach ($releaseInfo->getDependencyInfo()->getRequires() as $dependencyConstraint) {
$dependencyPackageName = $this->buildComposerPackageName($dependencyConstraint->getChannelName(), $dependencyConstraint->getPackageName());
$constraint = $versionParser->parseConstraints($dependencyConstraint->getConstraint());
$link = new Link($composerPackageName, $dependencyPackageName, $constraint, $dependencyConstraint->getType(), $dependencyConstraint->getConstraint());
switch ($dependencyConstraint->getType()) {
case 'required':
$requires[] = $link;
break;
case 'conflicts':
$conflicts[] = $link;
break;
case 'replaces':
$replaces[] = $link;
break;
}
}
foreach ($releaseInfo->getDependencyInfo()->getOptionals() as $group => $dependencyConstraints) {
foreach ($dependencyConstraints as $dependencyConstraint) {
$dependencyPackageName = $this->buildComposerPackageName($dependencyConstraint->getChannelName(), $dependencyConstraint->getPackageName());
$suggests[$group . '-' . $dependencyPackageName] = $dependencyConstraint->getConstraint();
}
}
$package = new CompletePackage($composerPackageName, $normalizedVersion, $version);
$package->setType('pear-library');
$package->setDescription($packageDefinition->getDescription());
$package->setLicense(array($packageDefinition->getLicense()));
$package->setDistType('file');
$package->setDistUrl($distUrl);
$package->setAutoload(array('classmap' => array('')));
$package->setIncludePaths(array('/'));
$package->setRequires($requires);
$package->setConflicts($conflicts);
$package->setSuggests($suggests);
$package->setReplaces($replaces);
$result[] = $package;
}
}
return $result;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$composer = $this->getComposer();
$commandEvent = new CommandEvent(PluginEvents::COMMAND, 'depends', $input, $output);
$composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
$platformOverrides = $composer->getConfig()->get('platform') ?: array();
$repo = new CompositeRepository(array(new ArrayRepository(array($composer->getPackage())), $composer->getRepositoryManager()->getLocalRepository(), new PlatformRepository(array(), $platformOverrides)));
$needle = $input->getArgument('package');
$pool = new Pool();
$pool->addRepository($repo);
$packages = $pool->whatProvides($needle);
if (empty($packages)) {
throw new \InvalidArgumentException('Could not find package "' . $needle . '" in your project.');
}
$linkTypes = $this->linkTypes;
$types = array_map(function ($type) use($linkTypes) {
$type = rtrim($type, 's');
if (!isset($linkTypes[$type])) {
throw new \InvalidArgumentException('Unexpected link type: ' . $type . ', valid types: ' . implode(', ', array_keys($linkTypes)));
}
return $type;
}, $input->getOption('link-type'));
$versionParser = new VersionParser();
$constraint = $versionParser->parseConstraints($input->getOption('match-constraint'));
$matchInvert = $input->getOption('invert-match-constraint');
$needles = array($needle);
if (true === $input->getOption('with-replaces')) {
foreach ($packages as $package) {
$needles = array_merge($needles, array_map(function (Link $link) {
return $link->getTarget();
}, $package->getReplaces()));
}
}
$messages = array();
$outputPackages = array();
$io = $this->getIO();
/** @var PackageInterface $package */
foreach ($repo->getPackages() as $package) {
foreach ($types as $type) {
/** @var Link $link */
foreach ($package->{'get' . $linkTypes[$type][0]}() as $link) {
foreach ($needles as $needle) {
if ($link->getTarget() === $needle && ($link->getConstraint()->matches($constraint) ? !$matchInvert : $matchInvert)) {
if (!isset($outputPackages[$package->getName()])) {
$messages[] = '<info>' . $package->getPrettyName() . '</info> ' . $linkTypes[$type][1] . ' ' . $needle . ' (<info>' . $link->getPrettyConstraint() . '</info>)';
$outputPackages[$package->getName()] = true;
}
}
}
}
}
}
if ($messages) {
sort($messages);
$io->write($messages);
} else {
$matchText = '';
if ($input->getOption('match-constraint') !== '*') {
$matchText = ' in versions ' . ($matchInvert ? 'not ' : '') . 'matching ' . $input->getOption('match-constraint');
}
$io->writeError('<info>There is no installed package depending on "' . $needle . '"' . $matchText . '.</info>');
}
}
/**
* {@inheritDoc}
*/
public function findPackages($name, $constraint = null)
{
if (!$this->hasProviders()) {
return parent::findPackages($name, $constraint);
}
// normalize name
$name = strtolower($name);
if (null !== $constraint && !$constraint instanceof ConstraintInterface) {
$versionParser = new VersionParser();
$constraint = $versionParser->parseConstraints($constraint);
}
$packages = array();
foreach ($this->getProviderNames() as $providerName) {
if ($name === $providerName) {
$candidates = $this->whatProvides(new Pool('dev'), $providerName);
foreach ($candidates as $package) {
if ($name === $package->getName()) {
$pkgConstraint = new Constraint('==', $package->getVersion());
if (null === $constraint || $constraint->matches($pkgConstraint)) {
$packages[] = $package;
}
}
}
}
}
return $packages;
}
/**
* @return \Composer\Semver\Constraint\ConstraintInterface
*/
public function getLatestVersion()
{
return $this->versionParser->parseConstraints($this->latestPackage->getPrettyVersion());
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$file = Factory::getComposerFile();
$io = $this->getIO();
$newlyCreated = !file_exists($file);
if (!file_exists($file) && !file_put_contents($file, "{\n}\n")) {
$io->writeError('<error>' . $file . ' could not be created.</error>');
return 1;
}
if (!is_readable($file)) {
$io->writeError('<error>' . $file . ' is not readable.</error>');
return 1;
}
if (!is_writable($file)) {
$io->writeError('<error>' . $file . ' is not writable.</error>');
return 1;
}
if (filesize($file) === 0) {
file_put_contents($file, "{\n}\n");
}
$json = new JsonFile($file);
$composerDefinition = $json->read();
$composerBackup = file_get_contents($json->getPath());
$composer = $this->getComposer();
$repos = $composer->getRepositoryManager()->getRepositories();
$this->repos = new CompositeRepository(array_merge(array(new PlatformRepository()), $repos));
$requirements = $this->determineRequirements($input, $output, $input->getArgument('packages'));
$requireKey = $input->getOption('dev') ? 'require-dev' : 'require';
$removeKey = $input->getOption('dev') ? 'require' : 'require-dev';
$baseRequirements = array_key_exists($requireKey, $composerDefinition) ? $composerDefinition[$requireKey] : array();
$requirements = $this->formatRequirements($requirements);
// validate requirements format
$versionParser = new VersionParser();
foreach ($requirements as $constraint) {
$versionParser->parseConstraints($constraint);
}
$sortPackages = $input->getOption('sort-packages');
if (!$this->updateFileCleanly($json, $baseRequirements, $requirements, $requireKey, $removeKey, $sortPackages)) {
foreach ($requirements as $package => $version) {
$baseRequirements[$package] = $version;
if (isset($composerDefinition[$removeKey][$package])) {
unset($composerDefinition[$removeKey][$package]);
}
}
$composerDefinition[$requireKey] = $baseRequirements;
$json->write($composerDefinition);
}
$io->writeError('<info>' . $file . ' has been ' . ($newlyCreated ? 'created' : 'updated') . '</info>');
if ($input->getOption('no-update')) {
return 0;
}
$updateDevMode = !$input->getOption('update-no-dev');
$optimize = $input->getOption('optimize-autoloader') || $composer->getConfig()->get('optimize-autoloader');
$authoritative = $input->getOption('classmap-authoritative') || $composer->getConfig()->get('classmap-authoritative');
// Update packages
$this->resetComposer();
$composer = $this->getComposer();
$composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
$commandEvent = new CommandEvent(PluginEvents::COMMAND, 'require', $input, $output);
$composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
$install = Installer::create($io, $composer);
$install->setVerbose($input->getOption('verbose'))->setPreferSource($input->getOption('prefer-source'))->setPreferDist($input->getOption('prefer-dist'))->setDevMode($updateDevMode)->setOptimizeAutoloader($optimize)->setClassMapAuthoritative($authoritative)->setUpdate(true)->setUpdateWhitelist(array_keys($requirements))->setWhitelistDependencies($input->getOption('update-with-dependencies'))->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'));
$status = $install->run();
if ($status !== 0) {
if ($newlyCreated) {
$io->writeError("\n" . '<error>Installation failed, deleting ' . $file . '.</error>');
unlink($json->getPath());
} else {
$io->writeError("\n" . '<error>Installation failed, reverting ' . $file . ' to its original content.</error>');
file_put_contents($json->getPath(), $composerBackup);
}
}
return $status;
}
/**
* Try to validate the version constraint.
*
* @param Request $request The request.
*
* @return JsonResponse
*
* @throws \RuntimeException For invalid user classes.
*
* @ApiDoc(
* section="misc",
* statusCodes = {
* 200 = "When everything worked out ok",
* 400 = "When the request payload was invalid."
* },
* authentication = true,
* authenticationRoles = {
* "ROLE_NONE"
* }
* )
* @ApiDescription(
* request={
* "constraint" = {
* "description" = "The constraint to test.",
* "dataType" = "string",
* "required" = true
* }
* },
* response={
* "status" = {
* "dataType" = "choice",
* "description" = "OK or ERROR",
* "format" = "['OK', 'ERROR']",
* },
* "error" = {
* "dataType" = "string",
* "description" = "The error message (if any).",
* }
* }
* )
*/
public function checkVersionConstraintAction(Request $request)
{
try {
$inputData = new JsonArray($request->getContent());
} catch (\Exception $exception) {
return new JsonResponse(['status' => 'ERROR', 'error' => 'invalid payload'], JsonResponse::HTTP_BAD_REQUEST);
}
$versionParser = new VersionParser();
if (!$inputData->has('constraint')) {
return new JsonResponse(['status' => 'ERROR', 'error' => 'invalid payload'], JsonResponse::HTTP_BAD_REQUEST);
}
try {
$versionParser->parseConstraints($inputData->get('constraint'));
} catch (\Exception $exception) {
return new JsonResponse(['status' => 'ERROR', 'error' => $exception->getMessage()], JsonResponse::HTTP_OK);
}
return new JsonResponse(['status' => 'OK'], JsonResponse::HTTP_OK);
}
