protected function selectPackage(IOInterface $io, $packageName, $version = null) { $io->writeError('<info>Searching for the specified package.</info>'); if ($composer = $this->getComposer(false)) { $localRepo = $composer->getRepositoryManager()->getLocalRepository(); $repos = new CompositeRepository(array_merge(array($localRepo), $composer->getRepositoryManager()->getRepositories())); } else { $defaultRepos = Factory::createDefaultRepositories($this->getIO()); $io->writeError('No composer.json found in the current directory, searching packages from ' . implode(', ', array_keys($defaultRepos))); $repos = new CompositeRepository($defaultRepos); } $pool = new Pool(); $pool->addRepository($repos); $parser = new VersionParser(); $constraint = $version ? $parser->parseConstraints($version) : null; $packages = $pool->whatProvides($packageName, $constraint, true); if (count($packages) > 1) { $package = reset($packages); $io->writeError('<info>Found multiple matches, selected ' . $package->getPrettyString() . '.</info>'); $io->writeError('Alternatives were ' . implode(', ', array_map(function ($p) { return $p->getPrettyString(); }, $packages)) . '.'); $io->writeError('<comment>Please use a more specific constraint to pick a different package.</comment>'); } elseif ($packages) { $package = reset($packages); $io->writeError('<info>Found an exact match ' . $package->getPrettyString() . '.</info>'); } else { $io->writeError('<error>Could not find a package matching ' . $packageName . '.</error>'); return false; } return $package; }
protected function prepare() { if (Type::determinePickle($this->path, $matches) < 1) { throw new \Exception('Not a pickle git URI'); } $this->name = $matches['package']; $extension = $this->fetchPackageJson(); $versionParser = new VersionParser(); if ($matches['version'] == '') { $versions = array_keys($extension['packages'][$this->name]); if (count($versions) > 1) { $versionToUse = $versions[1]; } else { $versionToUse = $versions[0]; } } else { $versionConstraints = $versionParser->parseConstraints($matches['version']); /* versions are sorted decreasing */ foreach ($extension['packages'][$this->name] as $version => $release) { $constraint = new VersionConstraint('=', $versionParser->normalize($version)); if ($versionConstraints->matches($constraint)) { $versionToUse = $version; break; } } } $package = $extension['packages'][$this->name][$versionToUse]; $this->version = $versionToUse; $this->normalizedVersion = $versionParser->normalize($versionToUse); $this->name = $matches['package']; $this->prettyVersion = $this->version; $this->url = $package['source']['url']; $this->reference = $package['source']['reference']; $this->type = $package['source']['type']; }
/** * Search for a given package version. * * Usage examples : Composition::has('php', '5.3.*') // PHP version * Composition::has('ext-memcache') // PHP extension * Composition::has('vendor/package', '>2.1') // Package version * * @param type $packageName The package name * @param type $prettyString An optional version constraint * * @return boolean Wether or not the package has been found. */ public static function has($packageName, $prettyString = '*') { if (null === self::$pool) { if (null === self::$rootDir) { self::$rootDir = getcwd(); if (!file_exists(self::$rootDir . '/composer.json')) { throw new \RuntimeException('Unable to guess the project root dir, please specify it manually using the Composition::setRootDir method.'); } } $minimumStability = 'dev'; $config = new Config(); $file = new JsonFile(self::$rootDir . '/composer.json'); if ($file->exists()) { $projectConfig = $file->read(); $config->merge($projectConfig); if (isset($projectConfig['minimum-stability'])) { $minimumStability = $projectConfig['minimum-stability']; } } $vendorDir = self::$rootDir . '/' . $config->get('vendor-dir'); $pool = new Pool($minimumStability); $pool->addRepository(new PlatformRepository()); $pool->addRepository(new InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed.json'))); $pool->addRepository(new InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed_dev.json'))); self::$pool = $pool; } $parser = new VersionParser(); $constraint = $parser->parseConstraints($prettyString); $packages = self::$pool->whatProvides($packageName, $constraint); return empty($packages) ? false : true; }
/** * Tests memory package marshalling/serialization semantics * @dataProvider providerVersioningSchemes */ public function testMemoryPackageHasExpectedMarshallingSemantics($name, $version) { $versionParser = new VersionParser(); $normVersion = $versionParser->normalize($version); $package = new MemoryPackage($name, $normVersion, $version); $this->assertEquals(strtolower($name) . '-' . $normVersion, (string) $package); }
/** * Checks PHP version * * @return array */ public function checkPhpVersion() { try { $requiredVersion = $this->composerInformation->getRequiredPhpVersion(); } catch (\Exception $e) { return [ 'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR, 'data' => [ 'error' => 'phpVersionError', 'message' => 'Cannot determine required PHP version: ' . $e->getMessage() ], ]; } $multipleConstraints = $this->versionParser->parseConstraints($requiredVersion); try { $normalizedPhpVersion = $this->versionParser->normalize(PHP_VERSION); } catch (\UnexpectedValueException $e) { $prettyVersion = preg_replace('#^([^~+-]+).*$#', '$1', PHP_VERSION); $normalizedPhpVersion = $this->versionParser->normalize($prettyVersion); } $currentPhpVersion = $this->versionParser->parseConstraints($normalizedPhpVersion); $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS; if (!$multipleConstraints->matches($currentPhpVersion)) { $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR; } return [ 'responseType' => $responseType, 'data' => [ 'required' => $requiredVersion, 'current' => PHP_VERSION, ], ]; }
/** * @param PackageInterface $package * @param bool $allowDevMaster * * @return \string[] */ public function validatePackage(PackageInterface $package, $allowDevMaster = false) { $errors = []; $versionParser = new VersionParser(); /** @noinspection ExceptionsAnnotatingAndHandlingInspection */ $devMaster = new Constraint('==', $versionParser->normalize('dev-master')); foreach ($package->getRequires() as $link) { $linkConstraint = $link->getConstraint(); if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $link->getTarget())) { continue; } if ($linkConstraint->matches($devMaster)) { if ($allowDevMaster) { continue; } $errors[] = sprintf('Package "%s" is required with branch constraint %s', $link->getTarget(), $linkConstraint->getPrettyString()); } $constraints = [$linkConstraint]; if ($linkConstraint instanceof MultiConstraint) { $constraints = (new ConstraintAccessor($linkConstraint))->getConstraints(); } foreach ($constraints as $constraint) { if ('dev-' === substr($constraint->getPrettyString(), 0, 4)) { $errors[] = sprintf('Package "%s" is required with branch constraint %s', $link->getTarget(), $linkConstraint->getPrettyString()); } } } return $errors; }
/** * {@inheritDoc} */ public function getMinimalPackages() { if (isset($this->minimalPackages)) { return $this->minimalPackages; } if (null === $this->rawData) { $this->rawData = $this->loadDataFromServer(); } $this->minimalPackages = array(); $versionParser = new VersionParser(); foreach ($this->rawData as $package) { $version = !empty($package['version_normalized']) ? $package['version_normalized'] : $versionParser->normalize($package['version']); $data = array('name' => strtolower($package['name']), 'repo' => $this, 'version' => $version, 'raw' => $package); if (!empty($package['replace'])) { $data['replace'] = $package['replace']; } if (!empty($package['provide'])) { $data['provide'] = $package['provide']; } // add branch aliases if ($aliasNormalized = $this->loader->getBranchAlias($package)) { $data['alias'] = preg_replace('{(\\.9{7})+}', '.x', $aliasNormalized); $data['alias_normalized'] = $aliasNormalized; } $this->minimalPackages[] = $data; } return $this->minimalPackages; }
protected function initialize() { parent::initialize(); $versionParser = new VersionParser(); try { $prettyVersion = PHP_VERSION; $version = $versionParser->normalize($prettyVersion); } catch (\UnexpectedValueException $e) { $prettyVersion = preg_replace('#^(.+?)(-.+)?$#', '$1', PHP_VERSION); $version = $versionParser->normalize($prettyVersion); } $php = new MemoryPackage('php', $version, $prettyVersion); $php->setDescription('The PHP interpreter'); parent::addPackage($php); foreach (get_loaded_extensions() as $name) { if (in_array($name, array('standard', 'Core'))) { continue; } $reflExt = new \ReflectionExtension($name); try { $prettyVersion = $reflExt->getVersion(); $version = $versionParser->normalize($prettyVersion); } catch (\UnexpectedValueException $e) { $prettyVersion = '0'; $version = $versionParser->normalize($prettyVersion); } $ext = new MemoryPackage('ext-' . $name, $version, $prettyVersion); $ext->setDescription('The ' . $name . ' PHP extension'); parent::addPackage($ext); } }
/** * {@inheritdoc} */ protected function execute(InputInterface $input, OutputInterface $output) { if (!$this->deploymentConfig->isAvailable()) { $output->writeln("<info>No information is available: the Magento application is not installed.</info>"); return; } /** @var DbVersionInfo $dbVersionInfo */ $dbVersionInfo = $this->objectManagerProvider->get()->get('Magento\\Framework\\Module\\DbVersionInfo'); $outdated = $dbVersionInfo->getDbVersionErrors(); if (!empty($outdated)) { $output->writeln("<info>The module code base doesn't match the DB schema and data.</info>"); $versionParser = new VersionParser(); $codebaseUpdateNeeded = false; foreach ($outdated as $row) { if (!$codebaseUpdateNeeded && $row[DbVersionInfo::KEY_CURRENT] !== 'none') { // check if module code base update is needed $currentVersion = $versionParser->parseConstraints($row[DbVersionInfo::KEY_CURRENT]); $requiredVersion = $versionParser->parseConstraints('>' . $row[DbVersionInfo::KEY_REQUIRED]); if ($requiredVersion->matches($currentVersion)) { $codebaseUpdateNeeded = true; } } $output->writeln(sprintf("<info>%20s %10s: %11s -> %-11s</info>", $row[DbVersionInfo::KEY_MODULE], $row[DbVersionInfo::KEY_TYPE], $row[DbVersionInfo::KEY_CURRENT], $row[DbVersionInfo::KEY_REQUIRED])); } if ($codebaseUpdateNeeded) { $output->writeln('<info>Some modules use code versions newer or older than the database. ' . "First update the module code, then run 'setup:upgrade'.</info>"); // we must have an exit code higher than zero to indicate something was wrong return \Magento\Framework\Console\Cli::RETURN_FAILURE; } else { $output->writeln("<info>Run 'setup:upgrade' to update your DB schema and data.</info>"); } } else { $output->writeln('<info>All modules are up to date.</info>'); } }
public function updateVersion() { /* Be sure package root is set before! */ $version = new Header\Version($this); $parser = new VersionParser(); $this->version = $parser->normalize($version); $this->prettyVersion = (string) $version; }
/** * Return true if $version matches $constraint (expressed as a Composer constraint string) * * @param string $version * @param string $constraint * @return bool */ public function isVersionMatching($version, $constraint) { $versionParser = new VersionParser(); $normalizedVersion = $versionParser->normalize($version); $versionAsContraint = $versionParser->parseConstraints($normalizedVersion); $linkConstraint = $versionParser->parseConstraints($constraint); return $linkConstraint->matches($versionAsContraint); }
protected function execute(InputInterface $input, OutputInterface $output) { $file = Factory::getComposerFile(); if (!file_exists($file) && !file_put_contents($file, "{\n}\n")) { $output->writeln('<error>' . $file . ' could not be created.</error>'); return 1; } if (!is_readable($file)) { $output->writeln('<error>' . $file . ' is not readable.</error>'); return 1; } if (!is_writable($file)) { $output->writeln('<error>' . $file . ' is not writable.</error>'); return 1; } $json = new JsonFile($file); $composer = $json->read(); $composerBackup = file_get_contents($json->getPath()); $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, $composer) ? $composer[$requireKey] : array(); $requirements = $this->formatRequirements($requirements); // validate requirements format $versionParser = new VersionParser(); foreach ($requirements as $constraint) { $versionParser->parseConstraints($constraint); } if (!$this->updateFileCleanly($json, $baseRequirements, $requirements, $requireKey, $removeKey)) { foreach ($requirements as $package => $version) { $baseRequirements[$package] = $version; if (isset($composer[$removeKey][$package])) { unset($composer[$removeKey][$package]); } } $composer[$requireKey] = $baseRequirements; $json->write($composer); } $output->writeln('<info>' . $file . ' has been updated</info>'); if ($input->getOption('no-update')) { return 0; } $updateDevMode = !$input->getOption('update-no-dev'); // Update packages $composer = $this->getComposer(); $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress')); $io = $this->getIO(); $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)->setUpdate(true)->setUpdateWhitelist(array_keys($requirements))->setWhitelistDependencies($input->getOption('update-with-dependencies')); $status = $install->run(); if ($status !== 0) { $output->writeln("\n" . '<error>Installation failed, reverting ' . $file . ' to its original content.</error>'); file_put_contents($json->getPath(), $composerBackup); } return $status; }
public static function determinePickle($arg, &$matches) { $versionParser = new VersionParser(); $res = $versionParser->parseNameVersionPairs([$arg]); $argPrefix = substr($arg, 0, 1); if ($argPrefix == '/' || $argPrefix == '.') { return 0; } $matches = ['package' => $res[0]['name'], 'version' => isset($res[0]['version']) ? $res[0]['version'] : '']; return 1; }
/** * {@inheritDoc} */ public function findPackage($name, $version) { // normalize version & name $versionParser = new VersionParser(); $version = $versionParser->normalize($version); $name = strtolower($name); foreach ($this->getPackages() as $package) { if ($name === $package->getName() && $version === $package->getVersion()) { return $package; } } }
/** * Require (install) a package. * * @param array $package Package names and version to require * - Format: ['name' => '', 'version' => ''] * * @throws \Bolt\Exception\PackageManagerException * * @return int 0 on success or a positive error code on failure */ public function execute(array $package) { $this->getComposer(); $io = $this->getIO(); /** @var \Bolt\Filesystem\Handler\JsonFile $jsonFile */ $jsonFile = $this->getOptions()->composerJson(); $newlyCreated = !$jsonFile->exists(); if ($newlyCreated) { $this->app['extend.manager.json']->update(); } // Format the package array $package = $this->formatRequirements($package); // Validate requirements format $versionParser = new VersionParser(); foreach ($package as $constraint) { $versionParser->parseConstraints($constraint); } // Get a back up of the file contents $composerBackup = $jsonFile->parse(); // Update our JSON file now with a specific version. // This is what Composer will read, and use, internally during the process. // After that is complete, we'll re-save with a constraint $this->updateComposerJson($jsonFile, $package, false); // JSON file has been created/updated, if we're not installing, exit if ($this->getOptions()->noUpdate()) { return 0; } // Reload Composer config $composer = $this->resetComposer(); /** @var $install \Composer\Installer */ $install = Installer::create($io, $composer)->setVerbose($this->getOptions()->verbose())->setPreferSource($this->getOptions()->preferSource())->setPreferDist($this->getOptions()->preferDist())->setDevMode(!$this->getOptions()->updateNoDev())->setOptimizeAutoloader($this->getOptions()->optimizeAutoloader())->setClassMapAuthoritative($this->getOptions()->classmapAuthoritative())->setUpdate($this->getOptions()->update())->setUpdateWhitelist(array_keys($package))->setWhitelistDependencies($this->getOptions()->updateWithDependencies())->setIgnorePlatformRequirements($this->getOptions()->ignorePlatformReqs())->setRunScripts(!$this->getOptions()->noScripts()); try { $status = $install->run(); if ($status !== 0) { if ($newlyCreated) { // Installation failed, deleting JSON $jsonFile->delete(); } else { // Installation failed, reverting JSON to its original content $jsonFile->dump($composerBackup); } } // Update our JSON file now with a constraint $this->updateComposerJson($jsonFile, $package, true); return $status; } catch (\Exception $e) { // Installation failed, reverting JSON to its original content $jsonFile->dump($composerBackup); $msg = sprintf('%s recieved an error from Composer: %s in %s::%s', __METHOD__, $e->getMessage(), $e->getFile(), $e->getLine()); $this->app['logger.system']->critical($msg, ['event' => 'exception', 'exception' => $e]); throw new PackageManagerException($e->getMessage(), $e->getCode(), $e); } }
public function testCheckPhpVersionFailed() { $this->composerInfo->expects($this->once())->method('getRequiredPhpVersion')->willReturn('1.0'); $multipleConstraints = $this->getMockForAbstractClass('Composer\\Package\\LinkConstraint\\LinkConstraintInterface', [], '', false); $this->versionParser->expects($this->at(0))->method('parseConstraints')->willReturn($multipleConstraints); $this->versionParser->expects($this->at(1))->method('normalize')->willReturn('1.0'); $currentPhpVersion = $this->getMockForAbstractClass('Composer\\Package\\LinkConstraint\\LinkConstraintInterface', [], '', false); $this->versionParser->expects($this->at(2))->method('parseConstraints')->willReturn($currentPhpVersion); $multipleConstraints->expects($this->once())->method('matches')->willReturn(false); $expected = ['responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR, 'data' => ['required' => 1.0, 'current' => PHP_VERSION]]; $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion()); }
/** * Execute the command. * * @param InputInterface $input * @param OutputInterface $output * @param bool $inverted Whether to invert matching process (why-not vs why behaviour) * @return int|null Exit code of the operation. */ protected function doExecute(InputInterface $input, OutputInterface $output, $inverted = false) { // Emit command event on startup $composer = $this->getComposer(); $commandEvent = new CommandEvent(PluginEvents::COMMAND, $this->getName(), $input, $output); $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent); // Prepare repositories and set up a pool $platformOverrides = $composer->getConfig()->get('platform') ?: array(); $repository = new CompositeRepository(array(new ArrayRepository(array($composer->getPackage())), $composer->getRepositoryManager()->getLocalRepository(), new PlatformRepository(array(), $platformOverrides))); $pool = new Pool(); $pool->addRepository($repository); // Parse package name and constraint list($needle, $textConstraint) = array_pad(explode(':', $input->getArgument(self::ARGUMENT_PACKAGE)), 2, $input->getArgument(self::ARGUMENT_CONSTRAINT)); // Find packages that are or provide the requested package first $packages = $pool->whatProvides($needle); if (empty($packages)) { throw new \InvalidArgumentException(sprintf('Could not find package "%s" in your project', $needle)); } // Include replaced packages for inverted lookups as they are then the actual starting point to consider $needles = array($needle); if ($inverted) { foreach ($packages as $package) { $needles = array_merge($needles, array_map(function (Link $link) { return $link->getTarget(); }, $package->getReplaces())); } } // Parse constraint if one was supplied if ('*' !== $textConstraint) { $versionParser = new VersionParser(); $constraint = $versionParser->parseConstraints($textConstraint); } else { $constraint = null; } // Parse rendering options $renderTree = $input->getOption(self::OPTION_TREE); $recursive = $renderTree || $input->getOption(self::OPTION_RECURSIVE); // Resolve dependencies $results = $repository->getDependents($needles, $constraint, $inverted, $recursive); if (empty($results)) { $extra = null !== $constraint ? sprintf(' in versions %smatching %s', $inverted ? 'not ' : '', $textConstraint) : ''; $this->getIO()->writeError(sprintf('<info>There is no installed package depending on "%s"%s</info>', $needle, $extra)); } elseif ($renderTree) { $this->initStyles($output); $root = $packages[0]; $this->getIO()->write(sprintf('<info>%s</info> %s %s', $root->getPrettyName(), $root->getPrettyVersion(), $root->getDescription())); $this->printTree($results); } else { $this->printTable($output, $results); } return 0; }
public static function createComposerInMemoryPackage($targetDir, $version) { $url = self::getURL($version); $versionParser = new VersionParser(); $normVersion = $versionParser->normalize($version); $package = new Package(self::PHANTOMJS_NAME, $normVersion, $version); $package->setTargetDir($targetDir); $package->setInstallationSource('dist'); $package->setDistType(pathinfo($url, PATHINFO_EXTENSION) === 'zip' ? 'zip' : 'tar'); // set zip, tarball $package->setDistUrl($url); return $package; }
public function getPlatformRequirements($withDevReqs = false) { $lockData = $this->getLockData(); $versionParser = new VersionParser(); $requirements = array(); if (!empty($lockData['platform'])) { $requirements = $versionParser->parseLinks('__ROOT__', '1.0.0', 'requires', isset($lockData['platform']) ? $lockData['platform'] : array()); } if ($withDevReqs && !empty($lockData['platform-dev'])) { $devRequirements = $versionParser->parseLinks('__ROOT__', '1.0.0', 'requires', isset($lockData['platform-dev']) ? $lockData['platform-dev'] : array()); $requirements = array_merge($requirements, $devRequirements); } return $requirements; }
public function findPackages($name, $version = null) { $name = strtolower($name); if (null !== $version) { $versionParser = new VersionParser(); $version = $versionParser->normalize($version); } $packages = array(); foreach ($this->getPackages() as $package) { if ($package->getName() === $name && (null === $version || $version === $package->getVersion())) { $packages[] = $package; } } return $packages; }
/** * 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 array array(CompletePackageInterface, array of versions) */ protected 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; $versions = array(); $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; } $versions[$package->getPrettyVersion()] = $package->getVersion(); $matches[$index] = $package->getId(); } // select preferred package according to policy rules if (!$matchedPackage && $matches && ($preferred = $policy->selectPreferredPackages($pool, array(), $matches))) { $matchedPackage = $pool->literalToPackage($preferred[0]); } return array($matchedPackage, $versions); }
/** * {@inheritdoc} */ public function getOutput(OperationInterface $operation, UrlGenerator $urlGenerator = null) { if (!$operation instanceof UpdateOperation) { throw new \LogicException('Operation should be an instance of UpdateOperation'); } $output = []; $initialPackage = $operation->getInitialPackage(); $targetPackage = $operation->getTargetPackage(); $versionFrom = new Version($initialPackage->getVersion(), $initialPackage->getPrettyVersion(), method_exists($initialPackage, 'getFullPrettyVersion') ? $initialPackage->getFullPrettyVersion() : VersionParser::formatVersion($initialPackage)); $versionTo = new Version($targetPackage->getVersion(), $targetPackage->getPrettyVersion(), method_exists($targetPackage, 'getFullPrettyVersion') ? $targetPackage->getFullPrettyVersion() : VersionParser::formatVersion($targetPackage)); $action = 'updated'; if (Comparator::greaterThan($versionFrom->getName(), $versionTo->getName())) { $action = 'downgraded'; } $output[] = sprintf(' - <fg=green>%s</fg=green> %s from <fg=yellow>%s</fg=yellow> to <fg=yellow>%s</fg=yellow>', $initialPackage->getName(), $action, $versionFrom->getPretty(), $versionTo->getPretty()); if ($urlGenerator) { $compareUrl = $urlGenerator->generateCompareUrl($initialPackage->getSourceUrl(), $versionFrom, $targetPackage->getSourceUrl(), $versionTo); if (!empty($compareUrl)) { $output[] = sprintf(' See changes: %s', $compareUrl); } $releaseUrl = $urlGenerator->generateReleaseUrl($this->extractSourceUrl($operation), $versionTo); if (!empty($releaseUrl)) { $output[] = sprintf(' Release notes: %s', $releaseUrl); } } return $output; }
/** * @param Composer $composer * @param IOInterface $io */ public function activate(Composer $composer, IOInterface $io) { $repositoryManager = $composer->getRepositoryManager(); $extra = $composer->getPackage()->getExtra(); if (!isset($extra['connect-packages'])) { return; } $versionParser = new VersionParser(); $links = []; foreach ($extra['connect-packages'] as $connectPackage => $version) { try { $releases = $this->getVersionsForPackage($connectPackage); } catch (InvalidArgumentException $e) { $message = '<error>Could not find release manifest for module with extension key: "%s". '; $message .= 'Did you get the casing right? Error: "%s"</error>'; $io->writeError(sprintf($message, $connectPackage, $e->getMessage()), true); continue; } catch (UnexpectedValueException $e) { $message = '<error>Non valid XML return from connect for module with extension key: "%s".</error>'; $message .= $e->getMessage(); $io->writeError(sprintf($message, $connectPackage), true); continue; } $repository = $this->addPackages($releases, $connectPackage); $repositoryManager->addRepository($repository); $constraint = $versionParser->parseConstraints($version); $links[] = new Link($composer->getPackage()->getName(), $connectPackage, $constraint); } if (!empty($links)) { $requires = $composer->getPackage()->getRequires(); $requires = array_merge($requires, $links); $composer->getPackage()->setRequires($requires); } }
public function update() { $versions = $this->packagist->getPackageVersions('silverstripe/framework'); foreach ($versions as $package) { $version = $package->getVersion(); // Replace version by branch alias if applicable $extra = $package->getExtra(); if (isset($extra['branch-alias'][$version])) { $version = $extra['branch-alias'][$version]; } $stability = VersionParser::parseStability($version); $isDev = $stability === 'dev'; if (!$isDev || in_array($version, $this->versionBlacklist)) { continue; } $match = preg_match('/^([0-9]+)\\.([0-9]+)\\.x-dev$/', $version, $matches); if (!$match) { continue; } $major = $matches[1]; $minor = $matches[2]; $record = SilverStripeVersion::get()->filter('Major', $major)->filter('Minor', $minor)->first(); if (!$record) { $record = new SilverStripeVersion(); $record->Name = "{$major}.{$minor}"; $record->Major = $major; $record->Minor = $minor; $record->write(); } } }
private function updateCompatibility(Addon $addon, AddonVersion $version, CompletePackage $package) { $require = null; if ($package->getRequire()) { foreach ($package->getRequire() as $name => $link) { if ((string) $link == 'self.version') { continue; } if ($name == 'silverstripe/framework') { $require = $link; break; } if ($name == 'silverstripe/cms') { $require = $link; } } } if (!$require) { return; } $addon->CompatibleVersions()->removeAll(); $version->CompatibleVersions()->removeAll(); foreach ($this->silverstripes as $id => $link) { try { $constraint = $this->versionParser->parseConstraints($require); if ($link->matches($constraint)) { $addon->CompatibleVersions()->add($id); $version->CompatibleVersions()->add($id); } } catch (Exception $e) { // An exception here shouldn't prevent further updates. Debug::log($addon->Name . "\t" . $addon->ID . "\t" . $e->getMessage()); } } }
/** * @dataProvider getRecommendedRequireVersionPackages */ public function testFindRecommendedRequireVersion($prettyVersion, $isDev, $stability, $expectedVersion, $branchAlias = null) { $pool = $this->createMockPool(); $versionSelector = new VersionSelector($pool); $versionParser = new VersionParser(); $package = $this->getMock('\\Composer\\Package\\PackageInterface'); $package->expects($this->any())->method('getPrettyVersion')->will($this->returnValue($prettyVersion)); $package->expects($this->any())->method('getVersion')->will($this->returnValue($versionParser->normalize($prettyVersion))); $package->expects($this->any())->method('isDev')->will($this->returnValue($isDev)); $package->expects($this->any())->method('getStability')->will($this->returnValue($stability)); $branchAlias = $branchAlias === null ? array() : array('branch-alias' => array($prettyVersion => $branchAlias)); $package->expects($this->any())->method('getExtra')->will($this->returnValue($branchAlias)); $recommended = $versionSelector->findRecommendedRequireVersion($package); // assert that the recommended version is what we expect $this->assertEquals($expectedVersion, $recommended); }
/** * All descendants' constructors should call this parent constructor * * @param PackageInterface $aliasOf The package this package is an alias of * @param string $version The version the alias must report * @param string $prettyVersion The alias's non-normalized version */ public function __construct(PackageInterface $aliasOf, $version, $prettyVersion) { parent::__construct($aliasOf->getName()); $this->version = $version; $this->prettyVersion = $prettyVersion; $this->aliasOf = $aliasOf; $this->stability = VersionParser::parseStability($version); $this->dev = $this->stability === 'dev'; // replace self.version dependencies foreach (array('requires', 'devRequires') as $type) { $links = $aliasOf->{'get' . ucfirst($type)}(); foreach ($links as $index => $link) { // link is self.version, but must be replacing also the replaced version if ('self.version' === $link->getPrettyConstraint()) { $links[$index] = new Link($link->getSource(), $link->getTarget(), new VersionConstraint('=', $this->version), $type, $prettyVersion); } } $this->{$type} = $links; } // duplicate self.version provides foreach (array('conflicts', 'provides', 'replaces') as $type) { $links = $aliasOf->{'get' . ucfirst($type)}(); $newLinks = array(); foreach ($links as $link) { // link is self.version, but must be replacing also the replaced version if ('self.version' === $link->getPrettyConstraint()) { $newLinks[] = new Link($link->getSource(), $link->getTarget(), new VersionConstraint('=', $this->version), $type, $prettyVersion); } } $this->{$type} = array_merge($links, $newLinks); } }
/** * Creates a new in memory package. * * @param string $name The package's name * @param string $version The package's version * @param string $prettyVersion The package's non-normalized version */ public function __construct($name, $version, $prettyVersion) { parent::__construct($name); $this->version = $version; $this->prettyVersion = $prettyVersion; $this->dev = VersionParser::isDev($version); }
/** * Verifies php version * * @return JsonModel */ public function phpVersionAction() { try { $requiredVersion = $this->phpInformation->getRequiredPhpVersion(); } catch (\Exception $e) { return new JsonModel(['responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR, 'data' => ['error' => 'phpVersionError', 'message' => 'Cannot determine required PHP version: ' . $e->getMessage()]]); } $multipleConstraints = $this->versionParser->parseConstraints($requiredVersion); $currentPhpVersion = new VersionConstraint('=', PHP_VERSION); $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS; if (!$multipleConstraints->matches($currentPhpVersion)) { $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR; } $data = ['responseType' => $responseType, 'data' => ['required' => $requiredVersion, 'current' => PHP_VERSION]]; return new JsonModel($data); }
public function __construct($name, $version, $prettyVersion) { parent::__construct($name); $this->version = $version; $this->prettyVersion = $prettyVersion; $this->stability = VersionParser::parseStability($version); $this->dev = $this->stability === 'dev'; }