/** * Returns a list of Contao paths. * Multiple paths mean there's likely a problem with the installation (e.g. Contao in root and vendor folder). * * @param RootPackageInterface $package The package to check if a root has been specified in the extra section. * * @return array * * @throws RuntimeException When the current working directory could not be determined. */ public static function findContaoRoots(RootPackageInterface $package = null) { $roots = array(); $cwd = getcwd(); if (!$cwd) { throw new RuntimeException('Could not determine current working directory.'); } // Check if we have a Contao installation in the current working dir. See #15. if (static::isContao($cwd)) { $roots['root'] = $cwd; } if (static::isContao(dirname($cwd))) { $roots['parent'] = dirname($cwd); } if (null !== $package) { $extra = $package->getExtra(); if (!empty($extra['contao']['root']) && static::isContao($cwd . DIRECTORY_SEPARATOR . $extra['contao']['root'])) { $roots['extra'] = $cwd . DIRECTORY_SEPARATOR . $extra['contao']['root']; } } // test, do we have the core within vendor/contao/core. $vendorRoot = $cwd . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'contao' . DIRECTORY_SEPARATOR . 'core'; if (static::isContao($vendorRoot)) { $roots['vendor'] = $vendorRoot; } return $roots; }
/** * Returns the version for the given package either from the "require" or "require-dev" packages array. * * @param RootPackageInterface $package * @param string $packageName * @throws \RuntimeException * @return mixed */ public static function getRequiredVersion(RootPackageInterface $package, $packageName = 'jerome-breton/casperjs-installer') { foreach (array($package->getRequires(), $package->getDevRequires()) as $requiredPackages) { if (isset($requiredPackages[$packageName])) { return $requiredPackages[$packageName]->getPrettyConstraint(); } } throw new \RuntimeException('Can not determine required version of ' . $packageName); }
/** * * @param PackageInterface $package * * @return string a path relative to the root of the composer.json that is being installed. */ public function getInstallPath(PackageInterface $package) { // custom install path only when it is the keeko/keeko package if ($this->root->getName() == 'keeko/keeko') { return 'packages/' . $package->getName(); } // ... anyway return the default return parent::getInstallPath($package); }
/** * Get extra config. * * @param \Composer\Package\RootPackageInterface $root * @param \Arcanedev\Composer\Entities\PluginState $state * @param array $extra * * @return array */ private function getExtra(RootPackageInterface $root, PluginState $state, $extra) { $rootExtra = $root->getExtra(); if ($state->replaceDuplicateLinks()) { return self::mergeExtraArray($state->shouldMergeExtraDeep(), $rootExtra, $extra); } if (!$state->shouldMergeExtraDeep()) { foreach (array_intersect(array_keys($extra), array_keys($rootExtra)) as $key) { $this->getLogger()->info("Ignoring duplicate <comment>{$key}</comment> in " . "<comment>{$this->getPath()}</comment> extra config."); } } return static::mergeExtraArray($state->shouldMergeExtraDeep(), $extra, $rootExtra); }
/** * Initialize. */ protected function initialize() { $this->requires = array_merge( $this->package->getRequires(), $this->package->getDevRequires() ); }
/** * @test */ public function removePackageUsageWithData() { $this->initializePackageData(); $dataManager = new SharedPackageDataManager($this->composer); $dataManager->setVendorDir($this->vendorDir); $this->rootPackage->expects($this->exactly(2))->method('getName')->will($this->onConsecutiveCalls('letudiant/root-package', 'letudiant/root-package2')); $package = $this->getMock('Composer\\Package\\PackageInterface'); $package->expects($this->exactly(4))->method('getPrettyName')->willReturn('letudiant/foo-bar'); $package->expects($this->exactly(4))->method('getPrettyVersion')->willReturn('dev-develop'); $package->expects($this->exactly(0))->method('getInstallationSource'); // Remove the right package $this->initializePackageData(); $dataManager->removePackageUsage($package); $this->assertFileExists($this->vendorDir . '/' . SharedPackageDataManager::PACKAGE_DATA_FILENAME); $content = file_get_contents($this->vendorDir . '/' . SharedPackageDataManager::PACKAGE_DATA_FILENAME); $this->assertJson($content); $this->assertEquals(array(), json_decode($content, true)); // Remove another package, should not remove the initial package $this->initializePackageData(); $dataManager = new SharedPackageDataManager($this->composer); $dataManager->setVendorDir($this->vendorDir); $dataManager->removePackageUsage($package); $this->assertFileExists($this->vendorDir . '/' . SharedPackageDataManager::PACKAGE_DATA_FILENAME); $content = file_get_contents($this->vendorDir . '/' . SharedPackageDataManager::PACKAGE_DATA_FILENAME); $this->assertJson($content); $this->assertEquals(array('letudiant/foo-bar/dev-develop' => array('installation-source' => 'source', 'project-usage' => array('letudiant/root-package'))), json_decode($content, true)); }
public function testCreateWithCustomIgnoreSection() { $extra = array('custom-ignore-files' => array('foo-asset/foo' => array('PATTERN'), 'foo-asset/bar' => array())); $this->rootPackage->expects($this->any())->method('getExtra')->will($this->returnValue($extra)); $manager = IgnoreFactory::create($this->composer, $this->package, null, 'custom-ignore-files'); $this->assertTrue($manager->isEnabled()); $this->assertTrue($manager->hasPattern()); $this->validateInstallDir($manager, $this->config->get('vendor-dir') . '/' . $this->package->getName()); }
/** * Initialize the installed package. */ private function initInstalledPackages() { /* @var PackageInterface $package */ foreach ($this->installedRepository->getPackages() as $package) { $operator = $this->getFilterOperator($package); /* @var Link $link */ $link = current($this->arrayLoader->parseLinks($this->package->getName(), $this->package->getVersion(), 'installed', array($package->getName() => $operator . $package->getPrettyVersion()))); $link = $this->includeRootConstraint($package, $link); $this->requires[$package->getName()] = $link; } }
private function getRootAliases() { if (!$this->update && $this->locker->isLocked()) { $aliases = $this->locker->getAliases(); } else { $aliases = $this->package->getAliases(); } $normalizedAliases = array(); foreach ($aliases as $alias) { $normalizedAliases[$alias['package']][$alias['version']] = array('alias' => $alias['alias'], 'alias_normalized' => $alias['alias_normalized']); } return $normalizedAliases; }
/** * Determine the constraint defined for a given package (if required via root project). * * @param string $packageName The name of the package to retrieve the constraint for. * * @return string|null */ private function getConstraint($packageName) { $requires = $this->rootPackage->getRequires(); if (isset($requires[$packageName])) { /** @var Link $link */ $link = $requires[$packageName]; return $link->getConstraint()->getPrettyString(); } foreach ($requires as $link) { /** @var Link $link */ if ($link->getTarget() == $packageName) { return $link->getConstraint()->getPrettyString(); } } return null; }
/** * @param Pool $pool * @param PolicyInterface $policy * @param WritableRepositoryInterface $localRepo * @param array $repositories */ private function processPackageUrls($pool, $policy, $localRepo, $repositories) { if (!$this->update) { return; } $rootRefs = $this->package->getReferences(); foreach ($localRepo->getCanonicalPackages() as $package) { // 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]); // update the dist and source URLs $sourceUrl = $package->getSourceUrl(); $newSourceUrl = $newPackage->getSourceUrl(); $newReference = $newPackage->getSourceReference(); if ($package->isDev() && isset($rootRefs[$package->getName()]) && $package->getSourceReference() === $rootRefs[$package->getName()]) { $newReference = $rootRefs[$package->getName()]; } $this->updatePackageUrl($package, $newSourceUrl, $newPackage->getSourceType(), $newReference, $newPackage->getDistUrl()); if ($package instanceof CompletePackage && $newPackage instanceof CompletePackage) { $package->setAbandoned($newPackage->getReplacementPackage() ?: $newPackage->isAbandoned()); } } } }
/** * @param array $tag * @param string $current_version * @param int $result * * @return UpdateCommand */ protected function getCommandToExecute(array $tag, $current_version, $result) { $that = $this; $installer = $this->getMockBuilder('\\Composer\\Installer')->disableOriginalConstructor()->getMock(); $installer->expects($this->once())->method('run')->will($this->returnValue($result)); $this->container->expects($that->at(0))->method('get')->will($this->returnValue($this->composer))->with('anime_db.composer'); $this->container->expects($that->at(1))->method('get')->will($this->returnValue($this->github))->with('anime_db.client.github'); $this->composer->expects($this->once())->method('setIO')->will($this->returnCallback(function ($io) use($that) { $that->assertInstanceOf('\\Composer\\IO\\ConsoleIO', $io); })); $this->github->expects($this->once())->method('getLastRelease')->will($this->returnValue($tag))->with('anime-db/anime-db'); $this->composer->expects($this->atLeastOnce())->method('getRootPackage')->will($this->returnValue($this->package)); $this->composer->expects($this->once())->method('getInstaller')->will($this->returnValue($installer)); $this->package->expects($this->once())->method('getPrettyVersion')->will($this->returnValue($current_version)); /* @var $helper_set HelperSet */ $helper_set = $this->getMockBuilder('\\Symfony\\Component\\Console\\Helper\\HelperSet')->disableOriginalConstructor()->getMock(); $this->output->expects($this->at(0))->method('writeln')->with('Search for a new version of the application'); $command = new UpdateCommand(); $command->setHelperSet($helper_set); $command->setContainer($this->container); return $command; }
/** * Update Links with a 'self.version' constraint with the root package's * version. * * @param string $type Link type * @param array $links * @param RootPackageInterface $root * @return array */ protected function replaceSelfVersionDependencies($type, array $links, RootPackageInterface $root) { $linkType = BasePackage::$supportedLinkTypes[$type]; $version = $root->getVersion(); $prettyVersion = $root->getPrettyVersion(); $vp = $this->versionParser; return array_map(function ($link) use($linkType, $version, $prettyVersion, $vp) { if ('self.version' === $link->getPrettyConstraint()) { return new Link($link->getSource(), $link->getTarget(), $vp->parseConstraints($version), $linkType['description'], $prettyVersion); } return $link; }, $links); }
private function getRootAliases(RootPackageInterface $rootPackage) { $aliases = $rootPackage->getAliases(); $normalizedAliases = array(); foreach ($aliases as $alias) { $normalizedAliases[$alias['package']][$alias['version']] = array('alias' => $alias['alias'], 'alias_normalized' => $alias['alias_normalized']); } return $normalizedAliases; }
/** * Returns the version for the given package either from the "require" or "require-dev" packages array. * * @param RootPackageInterface $package * @param string $packageName * @throws \RuntimeException * @return mixed */ public static function getRequiredVersion(RootPackageInterface $package) { foreach (array($package->getRequires(), $package->getDevRequires()) as $requiredPackages) { if (isset($requiredPackages[self::PACKAGE_NAME])) { return $requiredPackages[self::PACKAGE_NAME]->getPrettyConstraint(); } } throw new \RuntimeException('Can not determine required version of ' . self::PACKAGE_NAME); }
/** * Rewrites the class map to have lowercased keys to be able to load classes with wrong casing * Defaults to case sensitivity (composer loader default) * * @param RootPackageInterface $mainPackage * @param string $targetDir * @return bool */ protected static function caseSensitiveClassLoading(RootPackageInterface $mainPackage, $targetDir) { $extra = $mainPackage->getExtra(); $caseSensitiveClassLoading = true; if (isset($extra['autoload-case-sensitivity'])) { $caseSensitiveClassLoading = (bool) $extra['autoload-case-sensitivity']; } if (!$caseSensitiveClassLoading) { $classMapContents = file_get_contents($targetDir . '/autoload_classmap.php'); $classMapContents = preg_replace_callback('/ \'[^\']*\' => /', function ($match) { return strtolower($match[0]); }, $classMapContents); file_put_contents($targetDir . '/autoload_classmap.php', $classMapContents); } return $caseSensitiveClassLoading; }
/** * Update Links with a 'self.version' constraint with the root package's * version. * * @param string $type Link type * @param array $links * @param RootPackageInterface $root * @return array */ protected function replaceSelfVersionDependencies($type, array $links, RootPackageInterface $root) { $linkType = BasePackage::$supportedLinkTypes[$type]; $version = $root->getVersion(); $prettyVersion = $root->getPrettyVersion(); $vp = $this->versionParser; $method = 'get' . ucfirst($linkType['method']); $packages = $root->{$method}(); return array_map(function ($link) use($linkType, $version, $prettyVersion, $vp, $packages) { if ('self.version' === $link->getPrettyConstraint()) { if (isset($packages[$link->getSource()])) { /** @var Link $package */ $package = $packages[$link->getSource()]; return new Link($link->getSource(), $link->getTarget(), $vp->parseConstraints($package->getConstraint()->getPrettyString()), $linkType['description'], $package->getPrettyConstraint()); } return new Link($link->getSource(), $link->getTarget(), $vp->parseConstraints($version), $linkType['description'], $prettyVersion); } return $link; }, $links); }
protected function createRequest(Pool $pool, RootPackageInterface $rootPackage, PlatformRepository $platformRepo) { $request = new Request($pool); $constraint = new VersionConstraint('=', $rootPackage->getVersion()); $constraint->setPrettyString($rootPackage->getPrettyVersion()); $request->install($rootPackage->getName(), $constraint); $fixedPackages = $platformRepo->getPackages(); /*if ($this->additionalInstalledRepository) { $additionalFixedPackages = $this->additionalInstalledRepository->getPackages(); $fixedPackages = array_merge($fixedPackages, $additionalFixedPackages); }*/ // fix the version of all platform packages + additionally installed packages // to prevent the solver trying to remove or update those $provided = $rootPackage->getProvides(); foreach ($fixedPackages as $package) { $constraint = new VersionConstraint('=', $package->getVersion()); $constraint->setPrettyString($package->getPrettyVersion()); // skip platform packages that are provided by the root package if ($package->getRepository() !== $platformRepo || !isset($provided[$package->getName()]) || !$provided[$package->getName()]->getConstraint()->matches($constraint)) { $request->install($package->getName(), $constraint); } } return $request; }
/** * Check the extra option. * * @param RootPackageInterface $package The root package * @param string $name The extra option name * * @return bool */ public static function checkExtraOption(RootPackageInterface $package, $name) { $extra = $package->getExtra(); return !array_key_exists($name, $extra) || true === $extra[$name]; }
/** * @param Locker $locker * @param RootPackageInterface $rootPackage * * @return \Generator|\string[] */ private static function getVersions(Locker $locker, RootPackageInterface $rootPackage) { $lockData = $locker->getLockData(); $lockData['packages-dev'] = isset($lockData['packages-dev']) ? $lockData['packages-dev'] : []; foreach (array_merge($lockData['packages'], $lockData['packages-dev']) as $package) { (yield $package['name'] => $package['version'] . '@' . (isset($package['source']['reference']) ? $package['source']['reference'] : (isset($package['dist']['reference']) ? $package['dist']['reference'] : ''))); } (yield $rootPackage->getName() => $rootPackage->getVersion() . '@' . $rootPackage->getSourceReference()); }
private function processFetches(RootPackageInterface $package, $fetches) { $targets = array(); $requires = $package->getRequires(); foreach ($fetches as $key => $data) { if ($key == 'base-dir') { continue; } $data = $this->handleShortSyntax($key, $data); $name = $this->packageName($data['source']); try { $fetcher = $this->createFetcher($this->determineType($data)); $targets += $fetcher->fetch($data, $name); } catch (\Exception $e) { throw new \Exception("Cannot fetch [{$key}]: " . $e->getMessage(), 0, $e); } $requires[$name] = new Link($package->getName(), $name); } $package->setRequires($requires); return $targets; }
/** * @param Locker $locker * @param RootPackageInterface $rootPackage * * @return \Generator|\string[] */ private static function getVersions(Locker $locker, RootPackageInterface $rootPackage) : \Generator { $lockData = $locker->getLockData(); foreach (array_merge($lockData['packages'], $lockData['packages-dev']) as $package) { (yield $package['name'] => $package['version'] . '@' . $package['source']['reference']); } (yield $rootPackage->getName() => $rootPackage->getVersion() . '@' . $rootPackage->getSourceReference()); }
/** * Extract and merge stability flags from the given collection of * requires and merge them into a RootPackage. * * @param \Composer\Package\RootPackageInterface $root * @param \Composer\Package\Link[] $requires */ protected function mergeStabilityFlags(RootPackageInterface $root, array $requires) { $flags = StabilityFlags::extract($root->getStabilityFlags(), $root->getMinimumStability(), $requires); self::unwrapIfNeeded($root, 'setStabilityFlags')->setStabilityFlags($flags); }
/** * Add a collection of repositories described by the given configuration * to the given package and the global repository manager. * * @param array $repositories * @param RootPackageInterface $root */ protected function addRepositories(array $repositories, RootPackageInterface $root) { $repoManager = $this->composer->getRepositoryManager(); $newRepos = array(); foreach ($repositories as $repoJson) { $this->debug("Adding {$repoJson['type']} repository"); $repo = $repoManager->createRepository($repoJson['type'], $repoJson); $repoManager->addRepository($repo); $newRepos[] = $repo; } $root->setRepositories(array_merge($newRepos, $root->getRepositories())); }
/** * 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; }
private function createRequest(Pool $pool, RootPackageInterface $rootPackage, PlatformRepository $platformRepo) { $request = new Request($pool); $constraint = new VersionConstraint('=', $rootPackage->getVersion()); $constraint->setPrettyString($rootPackage->getPrettyVersion()); $request->install($rootPackage->getName(), $constraint); $fixedPackages = $platformRepo->getPackages(); if ($this->additionalInstalledRepository) { $additionalFixedPackages = $this->additionalInstalledRepository->getPackages(); $fixedPackages = array_merge($fixedPackages, $additionalFixedPackages); } $provided = $rootPackage->getProvides(); foreach ($fixedPackages as $package) { $constraint = new VersionConstraint('=', $package->getVersion()); $constraint->setPrettyString($package->getPrettyVersion()); if ($package->getRepository() !== $platformRepo || !isset($provided[$package->getName()]) || !$provided[$package->getName()]->getConstraint()->matches($constraint)) { $request->install($package->getName(), $constraint); } } return $request; }