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); }