/** * @dataProvider provideInstaller */ public function testInstaller(PackageInterface $rootPackage, $repositories, array $options) { $io = $this->getMock('Composer\\IO\\IOInterface'); $downloadManager = $this->getMock('Composer\\Downloader\\DownloadManager'); $config = $this->getMock('Composer\\Config'); $repositoryManager = new RepositoryManager($io, $config); $repositoryManager->setLocalRepository(new WritableRepositoryMock()); $repositoryManager->setLocalDevRepository(new WritableRepositoryMock()); if (!is_array($repositories)) { $repositories = array($repositories); } foreach ($repositories as $repository) { $repositoryManager->addRepository($repository); } $locker = $this->getMockBuilder('Composer\\Package\\Locker')->disableOriginalConstructor()->getMock(); $installationManager = new InstallationManagerMock(); $eventDispatcher = $this->getMockBuilder('Composer\\Script\\EventDispatcher')->disableOriginalConstructor()->getMock(); $autoloadGenerator = $this->getMock('Composer\\Autoload\\AutoloadGenerator'); $installer = new Installer($io, $config, clone $rootPackage, $downloadManager, $repositoryManager, $locker, $installationManager, $eventDispatcher, $autoloadGenerator); $result = $installer->run(); $this->assertTrue($result); $expectedInstalled = isset($options['install']) ? $options['install'] : array(); $expectedUpdated = isset($options['update']) ? $options['update'] : array(); $expectedUninstalled = isset($options['uninstall']) ? $options['uninstall'] : array(); $installed = $installationManager->getInstalledPackages(); $this->assertSame($expectedInstalled, $installed); $updated = $installationManager->getUpdatedPackages(); $this->assertSame($expectedUpdated, $updated); $uninstalled = $installationManager->getUninstalledPackages(); $this->assertSame($expectedUninstalled, $uninstalled); }
public function mapContrib(InstallationManager $im, RepositoryManager $rm) { $typePathMap = $this->getTypePathMap(); $typeInstallMap = []; $packages = $rm->getLocalRepository()->getCanonicalPackages(); foreach ($packages as $package) { if ($drupalType = $this->getDrupalType($package)) { if (!isset($typePathMap[$drupalType])) { continue; } $installPath = self::changeSlashes($im->getInstaller($package->getType())->getInstallPath($package)); if (strpos($installPath, $root = $this->getRoot()) !== false) { $installPath = self::changeSlashes($this->getFS()->makePathRelative($installPath, $root)); } $name = explode('/', $package->getPrettyName())[1]; $mapRef =& $typeInstallMap[$drupalType][rtrim($installPath, DIRECTORY_SEPARATOR)]; if (in_array($drupalType, ['module', 'theme'])) { $mapRef = sprintf($typePathMap[$drupalType] . DIRECTORY_SEPARATOR . '%s', 'contrib', $name); } else { $mapRef = sprintf($typePathMap[$drupalType], $name); } } } return array_intersect_key($typeInstallMap, $typePathMap); }
/** * Sets vcs type repositories. * * @param RepositoryManager $rm */ public static function setVcsTypeRepositories(RepositoryManager $rm) { foreach (Assets::getTypes() as $assetType) { foreach (Assets::getVcsRepositoryDrivers() as $driverType => $repositoryClass) { $rm->setRepositoryClass($assetType . '-' . $driverType, $repositoryClass); } } }
/** * Add a repository to collection of repositories. * * @param \Composer\Repository\RepositoryManager $repoManager * @param array $repositories * @param array $repoJson */ private function addRepository(RepositoryManager $repoManager, array &$repositories, $repoJson) { if (isset($repoJson['type'])) { $this->getLogger()->info("Prepending {$repoJson['type']} repository"); $repository = $repoManager->createRepository($repoJson['type'], $repoJson); $repoManager->prependRepository($repository); $repositories[] = $repository; } }
/** * Add repository instance. * * @param IOInterface $io The IO instance * @param RepositoryManager $rm The repository mamanger * @param array $repos The list of already repository added (passed by reference) * @param string $name The name of the new repository * @param RepositoryInterface $repo The repository instance * @param Pool|null $pool The pool */ public static function addRepositoryInstance(IOInterface $io, RepositoryManager $rm, array &$repos, $name, RepositoryInterface $repo, Pool $pool = null) { if (!isset($repos[$name])) { static::writeAddRepository($io, $name); $repos[$name] = $repo; $rm->addRepository($repo); if (null !== $pool) { $pool->addRepository($repo); } } }
/** * @param RepositoryManager $rm The repository mamanger * @param array $repos The list of already repository added (passed by reference) * @param string $name The name of the new repository * @param array $repoConfig The config of the new repository * @param Pool|null $pool The pool */ public static function addRepository(RepositoryManager $rm, array &$repos, $name, array $repoConfig, Pool $pool = null) { if (!isset($repos[$name])) { $repo = $rm->createRepository($repoConfig['type'], $repoConfig); $repos[$name] = $repo; $rm->addRepository($repo); if (null !== $pool) { $pool->addRepository($repo); } } }
protected function setUp() { $this->tempDir = TestUtil::makeTempDir('puli-composer-plugin', __CLASS__); $filesystem = new Filesystem(); $filesystem->mirror(__DIR__ . '/Fixtures/root', $this->tempDir); $this->io = $this->getMock('Composer\\IO\\IOInterface'); $this->config = new Config(false, $this->tempDir); $this->config->merge(array('config' => array('vendor-dir' => 'the-vendor'))); $this->installationManager = $this->getMockBuilder('Composer\\Installer\\InstallationManager')->disableOriginalConstructor()->getMock(); $this->installationManager->expects($this->any())->method('getInstallPath')->will($this->returnCallback(array($this, 'getInstallPath'))); $this->rootPackage = new RootPackage('vendor/root', '1.0', '1.0'); $this->rootPackage->setRequires(array('vendor/package1' => new Link('vendor/root', 'vendor/package1'), 'vendor/package2' => new Link('vendor/root', 'vendor/package2'))); $this->localRepository = new TestLocalRepository(array(new Package('vendor/package1', '1.0', '1.0'), new Package('vendor/package2', '1.0', '1.0'))); $this->repositoryManager = new RepositoryManager($this->io, $this->config); $this->repositoryManager->setLocalRepository($this->localRepository); $this->installPaths = array(); $this->composer = new Composer(); $this->composer->setRepositoryManager($this->repositoryManager); $this->composer->setInstallationManager($this->installationManager); $this->composer->setConfig($this->config); $this->composer->setPackage($this->rootPackage); $this->puliRunner = $this->getMockBuilder('Puli\\ComposerPlugin\\PuliRunner')->disableOriginalConstructor()->getMock(); $this->previousWd = getcwd(); chdir($this->tempDir); $this->plugin = new PuliPlugin($this->puliRunner); }
protected function setUp() { while (false === mkdir($this->tempDir = sys_get_temp_dir() . '/puli-plugin/PuliPluginTest_root' . rand(10000, 99999), 0777, true)) { } $filesystem = new Filesystem(); $filesystem->mirror(__DIR__ . '/Fixtures/root', $this->tempDir); $this->io = $this->getMock('Composer\\IO\\IOInterface'); $this->config = new Config(false, $this->tempDir); $this->config->merge(array('config' => array('vendor-dir' => 'the-vendor'))); $this->installationManager = $this->getMockBuilder('Composer\\Installer\\InstallationManager')->disableOriginalConstructor()->getMock(); $this->installationManager->expects($this->any())->method('getInstallPath')->will($this->returnCallback(array($this, 'getInstallPath'))); $this->rootPackage = new RootPackage('vendor/root', '1.0', '1.0'); $this->localRepository = new TestLocalRepository(array(new Package('vendor/package1', '1.0', '1.0'), new Package('vendor/package2', '1.0', '1.0'))); $this->repositoryManager = new RepositoryManager($this->io, $this->config); $this->repositoryManager->setLocalRepository($this->localRepository); $this->installPaths = array(); $this->composer = new Composer(); $this->composer->setRepositoryManager($this->repositoryManager); $this->composer->setInstallationManager($this->installationManager); $this->composer->setConfig($this->config); $this->composer->setPackage($this->rootPackage); $this->puliRunner = $this->getMockBuilder('Puli\\ComposerPlugin\\PuliRunner')->disableOriginalConstructor()->getMock(); $this->previousWd = getcwd(); chdir($this->tempDir); $this->plugin = new PuliPlugin($this->puliRunner); }
public function mapContrib(InstallationManager $im, RepositoryManager $rm) { $typePathMap = $this->getTypePathMap(); $typeInstallMap = []; $packages = $rm->getLocalRepository()->getCanonicalPackages(); foreach ($packages as $package) { if ($drupalType = $this->getDrupalType($package)) { $installPath = $im->getInstaller($package->getType())->getInstallPath($package); if (strpos($installPath, $root = $this->getRoot()) !== false) { $installPath = $this->getFS()->makePathRelative($installPath, $root); } $name = explode('/', $package->getPrettyName())[1]; $typeInstallMap[$drupalType][rtrim($installPath, '/')] = sprintf($typePathMap[$drupalType] . '/%s', 'contrib', $name); } } return array_intersect_key($typeInstallMap, $typePathMap); }
public function load(array $config, $class = 'Composer\\Package\\RootPackage') { if (!isset($config['name'])) { $config['name'] = '__root__'; } $autoVersioned = false; if (!isset($config['version'])) { // override with env var if available if (getenv('COMPOSER_ROOT_VERSION')) { $version = getenv('COMPOSER_ROOT_VERSION'); } else { $version = $this->versionGuesser->guessVersion($config, getcwd()); } if (!$version) { $version = '1.0.0'; $autoVersioned = true; } $config['version'] = $version; } $realPackage = $package = parent::load($config, $class); if ($realPackage instanceof AliasPackage) { $realPackage = $package->getAliasOf(); } if ($autoVersioned) { $realPackage->replaceVersion($realPackage->getVersion(), 'No version set (parsed as 1.0.0)'); } if (isset($config['minimum-stability'])) { $realPackage->setMinimumStability(VersionParser::normalizeStability($config['minimum-stability'])); } $aliases = array(); $stabilityFlags = array(); $references = array(); foreach (array('require', 'require-dev') as $linkType) { if (isset($config[$linkType])) { $linkInfo = BasePackage::$supportedLinkTypes[$linkType]; $method = 'get' . ucfirst($linkInfo['method']); $links = array(); foreach ($realPackage->{$method}() as $link) { $links[$link->getTarget()] = $link->getConstraint()->getPrettyString(); } $aliases = $this->extractAliases($links, $aliases); $stabilityFlags = $this->extractStabilityFlags($links, $stabilityFlags, $realPackage->getMinimumStability()); $references = $this->extractReferences($links, $references); } } $realPackage->setAliases($aliases); $realPackage->setStabilityFlags($stabilityFlags); $realPackage->setReferences($references); if (isset($config['prefer-stable'])) { $realPackage->setPreferStable((bool) $config['prefer-stable']); } $repos = Factory::createDefaultRepositories(null, $this->config, $this->manager); foreach ($repos as $repo) { $this->manager->addRepository($repo); } $realPackage->setRepositories($this->config->getRepositories()); return $package; }
/** * Checks if the package vcs repository is already include in repository manager. * * @param string $name The package name of the vcs repository * * @return bool */ protected function hasVcsRepository($name) { foreach ($this->repositoryManager->getRepositories() as $mRepo) { if ($mRepo instanceof AssetVcsRepository && $name === $mRepo->getComposerPackageName()) { return true; } } return false; }
public function testOverridingVcsRepositoryConfig() { $name = $this->getType() . '-asset/foobar'; $rfs = $this->replaceRegistryRfsByMock(); $rfs->expects($this->any())->method('getContents')->will($this->returnValue(json_encode($this->getMockPackageForVcsConfig()))); $repo = $this->getMockBuilder('Fxp\\Composer\\AssetPlugin\\Repository\\AssetVcsRepository')->disableOriginalConstructor()->getMock(); $repo->expects($this->any())->method('getComposerPackageName')->will($this->returnValue($name)); /* @var AssetVcsRepository $repo */ $this->rm->addRepository($repo); $this->assertCount(0, $this->registry->whatProvides($this->pool, $name)); }
protected function setUp() { $this->last_wdir = getcwd(); chdir(__DIR__ . '/../'); $this->plugin = new Plugin(); $this->composer = new Composer(); $this->io = new BufferIO('', StreamOutput::VERBOSITY_VERY_VERBOSE); $config = new Config(false); $config->merge(['config' => ['vendor-dir' => __DIR__]]); $repo_manager = new RepositoryManager($this->io, $config); $repository = new InstalledArrayRepository(); $package = new RootPackage('foobar', 1, 1); $event_dispatcher = new EventDispatcher($this->composer, $this->io); $autoload_generator = new AutoloadGenerator($event_dispatcher, $this->io); $package->setType('hostnet-entity'); $repo_manager->setLocalRepository($repository); $this->composer->setConfig($config); $this->composer->setRepositoryManager($repo_manager); $this->composer->setPackage($package); $this->composer->setAutoloadGenerator($autoload_generator); }
private function aliasPackages() { if (!$this->update && $this->locker->isLocked()) { $aliases = $this->locker->getAliases(); } else { $aliases = $this->package->getAliases(); } foreach ($aliases as $alias) { foreach ($this->repositoryManager->findPackages($alias['package'], $alias['version']) as $package) { $package->setAlias($alias['alias_normalized']); $package->setPrettyAlias($alias['alias']); $package->getRepository()->addPackage($aliasPackage = new AliasPackage($package, $alias['alias_normalized'], $alias['alias'])); $aliasPackage->setRootPackageAlias(true); } } return $aliases; }
/** * @param Repository\RepositoryManager $rm * @param string $vendorDir */ protected function addLocalRepository(IOInterface $io, RepositoryManager $rm, $vendorDir) { $rm->setLocalRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed.json', null, $io))); }
/** * @return RepositoryInterface[] */ private static function createRepos(RepositoryManager $rm, array $repoConfigs) { $repos = array(); foreach ($repoConfigs as $index => $repo) { if (is_string($repo)) { throw new \UnexpectedValueException('"repositories" should be an array of repository definitions, only a single repository was given'); } if (!is_array($repo)) { throw new \UnexpectedValueException('Repository "' . $index . '" (' . json_encode($repo) . ') should be an array, ' . gettype($repo) . ' given'); } if (!isset($repo['type'])) { throw new \UnexpectedValueException('Repository "' . $index . '" (' . json_encode($repo) . ') must have a type defined'); } $name = is_int($index) && isset($repo['url']) ? preg_replace('{^https?://}i', '', $repo['url']) : $index; while (isset($repos[$name])) { $name .= '2'; } if ($repo['type'] === 'filesystem') { $repos[$name] = new FilesystemRepository($repo['json']); } else { $repos[$name] = $rm->createRepository($repo['type'], $repo); } } return $repos; }
/** * @param Repository\RepositoryManager $rm * @param Installer\InstallationManager $im */ protected function purgePackages(Repository\RepositoryManager $rm, Installer\InstallationManager $im) { $repo = $rm->getLocalRepository(); foreach ($repo->getPackages() as $package) { if (!$im->isPackageInstalled($repo, $package)) { $repo->removePackage($package); } } }
public function createComposer() { $cwd = sprintf('%s/%s', getcwd(), '.eva'); $factory = new Factory(); if (false) { $composer = $factory->createComposer($this->io, $config, true, $cwd); } // ----------------- // ----------------- // ----------------- $fullLoad = true; $composerFile = $cwd . '/manifest.composer.json'; $file = new JsonFile($composerFile); $file->validateSchema(JsonFile::LAX_SCHEMA); $localConfig = $file->read(); // ----------------- // ----------------- // ----------------- // Load config and override with local config/auth config // $config = Factory::createConfig($this->io, $cwd); $vendorDir = $cwd . '/manifests/vendor'; $config = $factory::createConfig($this->io, $cwd); $config->merge($localConfig); $config->merge(['config' => ['vendor-dir' => $vendorDir]]); $localAuthFile = new JsonFile(dirname(realpath($composerFile)) . '/auth.json'); if ($localAuthFile->exists()) { if ($this->io && $this->io->isDebug()) { $this->io->writeError('Loading config file ' . $localAuthFile->getPath()); } $config->merge(array('config' => $localAuthFile->read())); $config->setAuthConfigSource(new JsonConfigSource($localAuthFile, true)); } // initialize composer $composer = new Composer(); $composer->setConfig($config); // initialize event dispatcher $dispatcher = new EventDispatcher($composer, $this->io); $composer->setEventDispatcher($dispatcher); // initialize repository manager // $rm = $this->createRepositoryManager($io, $config, $dispatcher); // $composer->setRepositoryManager($rm); $rm = new RepositoryManager($this->io, $config, $dispatcher); $rm->setRepositoryClass('composer', ComposerRepository::class); $composer->setRepositoryManager($rm); // load local repository $rm->setLocalRepository(new InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed.json'))); // load package $parser = new VersionParser(); $guesser = new VersionGuesser($config, new ProcessExecutor($this->io), $parser); $loader = new RootPackageLoader($rm, $config, $parser, $guesser); $package = $loader->load($localConfig); $composer->setPackage($package); // initialize installation manager $im = new InstallationManager(); $composer->setInstallationManager($im); if ($fullLoad) { // initialize download manager $dm = $factory->createDownloadManager($this->io, $config, $dispatcher); $composer->setDownloadManager($dm); // initialize autoload generator $generator = new AutoloadGenerator($dispatcher, $this->io); $composer->setAutoloadGenerator($generator); } // add installers to the manager (must happen after download manager is created since they read it out of $composer) $im->addInstaller(new Installer\LibraryInstaller($this->io, $composer, null)); $im->addInstaller(new Installer\PearInstaller($this->io, $composer, 'pear-library')); $im->addInstaller(new Installer\PluginInstaller($this->io, $composer)); $im->addInstaller(new Installer\MetapackageInstaller($this->io)); // if ($fullLoad) { // $globalComposer = $this->createGlobalComposer($io, $config, $disablePlugins); // $pm = $this->createPluginManager($io, $composer, $globalComposer); // $composer->setPluginManager($pm); // // if (!$disablePlugins) { // $pm->loadInstalledPlugins(); // } // // // once we have plugins and custom installers we can // // purge packages from local repos if they have been deleted on the filesystem // if ($rm->getLocalRepository()) { // $this->purgePackages($rm->getLocalRepository(), $im); // } // } // init locker if possible if ($fullLoad && isset($composerFile)) { $lockFile = "json" === pathinfo($composerFile, PATHINFO_EXTENSION) ? substr($composerFile, 0, -4) . 'lock' : $composerFile . '.lock'; $locker = new Locker($this->io, new JsonFile($lockFile, new RemoteFilesystem($this->io, $config)), $rm, $im, file_get_contents($composerFile)); $composer->setLocker($locker); } // ----------------- // ----------------- // ----------------- return $composer; }
protected function addLocalRepository(RepositoryManager $rm, $vendorDir) { // TODO BC feature, remove after June 15th if (file_exists($vendorDir . '/.composer/installed.json')) { if (!is_dir($vendorDir . '/composer')) { mkdir($vendorDir . '/composer/', 0777, true); } rename($vendorDir . '/.composer/installed.json', $vendorDir . '/composer/installed.json'); } if (file_exists($vendorDir . '/.composer/installed_dev.json')) { if (!is_dir($vendorDir . '/composer')) { mkdir($vendorDir . '/composer/', 0777, true); } rename($vendorDir . '/.composer/installed_dev.json', $vendorDir . '/composer/installed_dev.json'); } if (file_exists($vendorDir . '/installed.json')) { if (!is_dir($vendorDir . '/composer')) { mkdir($vendorDir . '/composer/', 0777, true); } rename($vendorDir . '/installed.json', $vendorDir . '/composer/installed.json'); } if (file_exists($vendorDir . '/installed_dev.json')) { if (!is_dir($vendorDir . '/composer')) { mkdir($vendorDir . '/composer/', 0777, true); } rename($vendorDir . '/installed_dev.json', $vendorDir . '/composer/installed_dev.json'); } $rm->setLocalRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed.json'))); $rm->setLocalDevRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed_dev.json'))); }
/** * Replace local repositories with InstalledArrayRepository instances * * This is to prevent any accidental modification of the existing repos on disk * * @param RepositoryManager $rm */ private function mockLocalRepositories(RepositoryManager $rm) { $packages = array_map(function ($p) { return clone $p; }, $rm->getLocalRepository()->getPackages()); foreach ($packages as $key => $package) { if ($package instanceof AliasPackage) { unset($packages[$key]); } } $rm->setLocalRepository(new InstalledArrayRepository($packages)); $packages = array_map(function ($p) { return clone $p; }, $rm->getLocalDevRepository()->getPackages()); foreach ($packages as $key => $package) { if ($package instanceof AliasPackage) { unset($packages[$key]); } } $rm->setLocalDevRepository(new InstalledArrayRepository($packages)); }
/** * Run installation (or update) * * @param Boolean $preferSource * @param Boolean $dryRun * @param Boolean $verbose * @param Boolean $noInstallRecommends * @param Boolean $installSuggests * @param Boolean $update * @param RepositoryInterface $additionalInstalledRepository */ public function run($preferSource = false, $dryRun = false, $verbose = false, $noInstallRecommends = false, $installSuggests = false, $update = false, RepositoryInterface $additionalInstalledRepository = null) { if ($dryRun) { $verbose = true; } if ($preferSource) { $this->downloadManager->setPreferSource(true); } $this->repositoryManager = $this->repositoryManager; // create local repo, this contains all packages that are installed in the local project $localRepo = $this->repositoryManager->getLocalRepository(); // create installed repo, this contains all local packages + platform packages (php & extensions) $installedRepo = new CompositeRepository(array($localRepo, new PlatformRepository())); if ($additionalInstalledRepository) { $installedRepo->addRepository($additionalInstalledRepository); } // prepare aliased packages if (!$update && $this->locker->isLocked()) { $aliases = $this->locker->getAliases(); } else { $aliases = $this->package->getAliases(); } foreach ($aliases as $alias) { foreach ($this->repositoryManager->findPackages($alias['package'], $alias['version']) as $package) { $package->getRepository()->addPackage(new AliasPackage($package, $alias['alias_normalized'], $alias['alias'])); } foreach ($this->repositoryManager->getLocalRepository()->findPackages($alias['package'], $alias['version']) as $package) { $this->repositoryManager->getLocalRepository()->addPackage(new AliasPackage($package, $alias['alias_normalized'], $alias['alias'])); $this->repositoryManager->getLocalRepository()->removePackage($package); } } // creating repository pool $pool = new Pool(); $pool->addRepository($installedRepo); foreach ($this->repositoryManager->getRepositories() as $repository) { $pool->addRepository($repository); } // dispatch pre event if (!$dryRun) { $eventName = $update ? ScriptEvents::PRE_UPDATE_CMD : ScriptEvents::PRE_INSTALL_CMD; $this->eventDispatcher->dispatchCommandEvent($eventName); } // creating requirements request $installFromLock = false; $request = new Request($pool); if ($update) { $this->io->write('<info>Updating dependencies</info>'); $request->updateAll(); $links = $this->collectLinks($noInstallRecommends, $installSuggests); foreach ($links as $link) { $request->install($link->getTarget(), $link->getConstraint()); } } elseif ($this->locker->isLocked()) { $installFromLock = true; $this->io->write('<info>Installing from lock file</info>'); if (!$this->locker->isFresh()) { $this->io->write('<warning>Your lock file is out of sync with your composer.json, run "composer.phar update" to update dependencies</warning>'); } foreach ($this->locker->getLockedPackages() as $package) { $version = $package->getVersion(); foreach ($aliases as $alias) { if ($alias['package'] === $package->getName() && $alias['version'] === $package->getVersion()) { $version = $alias['alias']; break; } } $constraint = new VersionConstraint('=', $version); $request->install($package->getName(), $constraint); } } else { $this->io->write('<info>Installing dependencies</info>'); $links = $this->collectLinks($noInstallRecommends, $installSuggests); foreach ($links as $link) { $request->install($link->getTarget(), $link->getConstraint()); } } // prepare solver $policy = new DefaultPolicy(); $solver = new Solver($policy, $pool, $installedRepo); // solve dependencies $operations = $solver->solve($request); // force dev packages to be updated to latest reference on update if ($update) { foreach ($localRepo->getPackages() as $package) { if ($package instanceof AliasPackage) { $package = $package->getAliasOf(); } // skip non-dev packages if (!$package->isDev()) { continue; } // skip packages that will be updated/uninstalled foreach ($operations as $operation) { if ('update' === $operation->getJobType() && $package === $operation->getInitialPackage() || 'uninstall' === $operation->getJobType() && $package === $operation->getPackage()) { continue 2; } } // force update $newPackage = $this->repositoryManager->findPackage($package->getName(), $package->getVersion()); if ($newPackage && $newPackage->getSourceReference() !== $package->getSourceReference()) { $operations[] = new UpdateOperation($package, $newPackage); } } } // anti-alias local repository to allow updates to work fine foreach ($this->repositoryManager->getLocalRepository()->getPackages() as $package) { if ($package instanceof AliasPackage) { $this->repositoryManager->getLocalRepository()->addPackage(clone $package->getAliasOf()); $this->repositoryManager->getLocalRepository()->removePackage($package); } } // execute operations if (!$operations) { $this->io->write('<info>Nothing to install/update</info>'); } foreach ($operations as $operation) { if ($verbose) { $this->io->write((string) $operation); } if (!$dryRun) { $this->eventDispatcher->dispatchPackageEvent(constant('Composer\\Script\\ScriptEvents::PRE_PACKAGE_' . strtoupper($operation->getJobType())), $operation); // if installing from lock, restore dev packages' references to their locked state if ($installFromLock) { $package = null; if ('update' === $operation->getJobType()) { $package = $operation->getTargetPackage(); } elseif ('install' === $operation->getJobType()) { $package = $operation->getPackage(); } if ($package && $package->isDev()) { $lockData = $this->locker->getLockData(); foreach ($lockData['packages'] as $lockedPackage) { if (!empty($lockedPackage['source-reference']) && strtolower($lockedPackage['package']) === $package->getName()) { $package->setSourceReference($lockedPackage['source-reference']); break; } } } } $this->installationManager->execute($operation); $this->eventDispatcher->dispatchPackageEvent(constant('Composer\\Script\\ScriptEvents::POST_PACKAGE_' . strtoupper($operation->getJobType())), $operation); } } if (!$dryRun) { if ($update || !$this->locker->isLocked()) { $this->locker->setLockData($localRepo->getPackages(), $aliases); $this->io->write('<info>Writing lock file</info>'); } $localRepo->write(); $this->io->write('<info>Generating autoload files</info>'); $generator = new AutoloadGenerator(); $generator->dump($localRepo, $this->package, $this->installationManager, $this->installationManager->getVendorPath() . '/.composer'); // dispatch post event $eventName = $update ? ScriptEvents::POST_UPDATE_CMD : ScriptEvents::POST_INSTALL_CMD; $this->eventDispatcher->dispatchCommandEvent($eventName); } }
protected function doInstall($localRepo, $installedRepo, $aliases, $devMode = false) { $minimumStability = $this->package->getMinimumStability(); $stabilityFlags = $this->package->getStabilityFlags(); // initialize locker to create aliased packages if (!$this->update && $this->locker->isLocked($devMode)) { $lockedPackages = $this->locker->getLockedPackages($devMode); $minimumStability = $this->locker->getMinimumStability(); $stabilityFlags = $this->locker->getStabilityFlags(); } $this->whitelistUpdateDependencies($localRepo, $devMode, $this->package->getRequires(), $this->package->getDevRequires()); $this->io->write('<info>Loading composer repositories with package information</info>'); // creating repository pool $pool = new Pool($minimumStability, $stabilityFlags); $pool->addRepository($installedRepo, $aliases); $repositories = $this->repositoryManager->getRepositories(); foreach ($repositories as $repository) { $pool->addRepository($repository, $aliases); } // creating requirements request $installFromLock = false; $request = new Request($pool); $constraint = new VersionConstraint('=', $this->package->getVersion()); $request->install($this->package->getName(), $constraint); if ($this->update) { $this->io->write('<info>Updating ' . ($devMode ? 'dev ' : '') . 'dependencies</info>'); $request->updateAll(); $links = $devMode ? $this->package->getDevRequires() : $this->package->getRequires(); foreach ($links as $link) { $request->install($link->getTarget(), $link->getConstraint()); } } elseif ($this->locker->isLocked($devMode)) { $installFromLock = true; $this->io->write('<info>Installing ' . ($devMode ? 'dev ' : '') . 'dependencies from lock file</info>'); if (!$this->locker->isFresh() && !$devMode) { $this->io->write('<warning>Your lock file is out of sync with your composer.json, run "composer.phar update" to update dependencies</warning>'); } foreach ($lockedPackages as $package) { $version = $package->getVersion(); if (isset($aliases[$package->getName()][$version])) { $version = $aliases[$package->getName()][$version]['alias_normalized']; } $constraint = new VersionConstraint('=', $version); $request->install($package->getName(), $constraint); } } else { $this->io->write('<info>Installing ' . ($devMode ? 'dev ' : '') . 'dependencies</info>'); $links = $devMode ? $this->package->getDevRequires() : $this->package->getRequires(); foreach ($links as $link) { $request->install($link->getTarget(), $link->getConstraint()); } } // fix the version of all installed packages (+ platform) that are not // in the current local repo to prevent rogue updates (e.g. non-dev // updating when in dev) foreach ($installedRepo->getPackages() as $package) { if ($package->getRepository() === $localRepo) { continue; } $constraint = new VersionConstraint('=', $package->getVersion()); $request->install($package->getName(), $constraint); } // if the updateWhitelist is enabled, packages not in it are also fixed // to the version specified in the lock, or their currently installed version if ($this->update && $this->updateWhitelist) { if ($this->locker->isLocked($devMode)) { $currentPackages = $this->locker->getLockedPackages($devMode); } else { $currentPackages = $installedRepo->getPackages(); } // collect links from composer as well as installed packages $candidates = array(); foreach ($links as $link) { $candidates[$link->getTarget()] = true; } foreach ($localRepo->getPackages() as $package) { $candidates[$package->getName()] = true; } // fix them to the version in lock (or currently installed) if they are not updateable foreach ($candidates as $candidate => $dummy) { foreach ($currentPackages as $curPackage) { if ($curPackage->getName() === $candidate) { if ($this->isUpdateable($curPackage)) { break; } $constraint = new VersionConstraint('=', $curPackage->getVersion()); $request->install($curPackage->getName(), $constraint); } } } } // prepare solver $policy = new DefaultPolicy(); $solver = new Solver($policy, $pool, $installedRepo); // solve dependencies try { $operations = $solver->solve($request); } catch (SolverProblemsException $e) { $this->io->write('<error>Your requirements could not be resolved to an installable set of packages.</error>'); $this->io->write($e->getMessage()); return false; } // force dev packages to be updated if we update or install from a (potentially new) lock foreach ($localRepo->getPackages() as $package) { // skip non-dev packages if (!$package->isDev()) { continue; } if ($package instanceof AliasPackage) { continue; } // skip packages that will be updated/uninstalled foreach ($operations as $operation) { if ('update' === $operation->getJobType() && $operation->getInitialPackage()->equals($package) || 'uninstall' === $operation->getJobType() && $operation->getPackage()->equals($package)) { continue 2; } } // force update to locked version if it does not match the installed version if ($installFromLock) { $lockData = $this->locker->getLockData(); unset($lockedReference); foreach ($lockData['packages'] as $lockedPackage) { if (!empty($lockedPackage['source-reference']) && strtolower($lockedPackage['package']) === $package->getName()) { $lockedReference = $lockedPackage['source-reference']; break; } } if (isset($lockedReference) && $lockedReference !== $package->getSourceReference()) { // changing the source ref to update to will be handled in the operations loop below $operations[] = new UpdateOperation($package, clone $package); } } else { // force update to latest on update if ($this->update) { // skip package if the whitelist is enabled and it is not in it if ($this->updateWhitelist && !$this->isUpdateable($package)) { continue; } $newPackage = null; $matches = $pool->whatProvides($package->getName(), new VersionConstraint('=', $package->getVersion())); foreach ($matches as $match) { // skip local packages if (!in_array($match->getRepository(), $repositories, true)) { continue; } // skip providers/replacers if ($match->getName() !== $package->getName()) { continue; } $newPackage = $match; break; } if ($newPackage && $newPackage->getSourceReference() !== $package->getSourceReference()) { $operations[] = new UpdateOperation($package, $newPackage); } } // force installed package to update to referenced version if it does not match the installed version $references = $this->package->getReferences(); if (isset($references[$package->getName()]) && $references[$package->getName()] !== $package->getSourceReference()) { // changing the source ref to update to will be handled in the operations loop below $operations[] = new UpdateOperation($package, clone $package); } } } // execute operations if (!$operations) { $this->io->write('Nothing to install or update'); } foreach ($operations as $operation) { // collect suggestions if ('install' === $operation->getJobType()) { foreach ($operation->getPackage()->getSuggests() as $target => $reason) { $this->suggestedPackages[] = array('source' => $operation->getPackage()->getPrettyName(), 'target' => $target, 'reason' => $reason); } } $event = 'Composer\\Script\\ScriptEvents::PRE_PACKAGE_' . strtoupper($operation->getJobType()); if (defined($event) && $this->runScripts) { $this->eventDispatcher->dispatchPackageEvent(constant($event), $operation); } // if installing from lock, restore dev packages' references to their locked state if ($installFromLock) { $package = null; if ('update' === $operation->getJobType()) { $package = $operation->getTargetPackage(); } elseif ('install' === $operation->getJobType()) { $package = $operation->getPackage(); } if ($package && $package->isDev()) { $lockData = $this->locker->getLockData(); foreach ($lockData['packages'] as $lockedPackage) { if (!empty($lockedPackage['source-reference']) && strtolower($lockedPackage['package']) === $package->getName()) { // update commit date to allow recovery in case the commit disappeared if (!empty($lockedPackage['commit-date'])) { $package->setReleaseDate(new \DateTime('@' . $lockedPackage['commit-date'])); } $package->setSourceReference($lockedPackage['source-reference']); break; } } } } else { // not installing from lock, force dev packages' references if they're in root package refs $package = null; if ('update' === $operation->getJobType()) { $package = $operation->getTargetPackage(); } elseif ('install' === $operation->getJobType()) { $package = $operation->getPackage(); } if ($package && $package->isDev()) { $references = $this->package->getReferences(); if (isset($references[$package->getName()])) { $package->setSourceReference($references[$package->getName()]); } } } // output alias operations in verbose mode, or all ops in dry run if ($this->dryRun || $this->verbose && false !== strpos($operation->getJobType(), 'Alias')) { $this->io->write(' - ' . $operation); } $this->installationManager->execute($localRepo, $operation); $event = 'Composer\\Script\\ScriptEvents::POST_PACKAGE_' . strtoupper($operation->getJobType()); if (defined($event) && $this->runScripts) { $this->eventDispatcher->dispatchPackageEvent(constant($event), $operation); } if (!$this->dryRun) { $localRepo->write(); } } return true; }
/** * @param Repository\RepositoryManager $rm * @param string $vendorDir */ protected function addLocalRepository(RepositoryManager $rm, $vendorDir) { $rm->setLocalRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed.json'))); $rm->setLocalDevRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir . '/composer/installed_dev.json'))); }
protected function createInstallationManager(Repository\RepositoryManager $rm, Downloader\DownloadManager $dm, $vendorDir, $binDir, IOInterface $io) { $im = new Installer\InstallationManager($vendorDir); $im->addInstaller(new Installer\LibraryInstaller($vendorDir, $binDir, $dm, $rm->getLocalRepository(), $io, null)); $im->addInstaller(new Installer\InstallerInstaller($vendorDir, $binDir, $dm, $rm->getLocalRepository(), $io, $im)); return $im; }
protected function addPackagistRepository(RepositoryManager $rm) { $rm->addRepository(new Repository\ComposerRepository(array('url' => 'http://packagist.org'))); }
/** * Find the dev-master package. * * @param RepositoryManager $manager Composer repository manger * @param string $name Package's name * * @return PackageInterface The found package */ protected function findDevPackage(RepositoryManager $manager, $name) { return $manager->findPackage($name, '9999999-dev'); }
/** * Replace local repositories with InstalledArrayRepository instances * * This is to prevent any accidental modification of the existing repos on disk * * @param RepositoryManager $rm */ private function mockLocalRepositories(RepositoryManager $rm) { $packages = array(); foreach ($rm->getLocalRepository()->getPackages() as $package) { $packages[(string) $package] = clone $package; } foreach ($packages as $key => $package) { if ($package instanceof AliasPackage) { $alias = (string) $package->getAliasOf(); $packages[$key] = new AliasPackage($packages[$alias], $package->getVersion(), $package->getPrettyVersion()); } } $rm->setLocalRepository(new InstalledArrayRepository($packages)); }
public function __construct() { require_once ABSPATH . 'wp-admin/includes/plugin.php'; $this->config = new Config(); $this->repositoryManager = $rm = new RepositoryManager(new NullIO(), $this->config); $rm->setRepositoryClass('composer', 'Composer\\Repository\\ComposerRepository'); $rm->setRepositoryClass('vcs', 'Composer\\Repository\\VcsRepository'); $rm->setRepositoryClass('package', 'Composer\\Repository\\PackageRepository'); $rm->setRepositoryClass('pear', 'Composer\\Repository\\PearRepository'); $rm->setRepositoryClass('git', 'Composer\\Repository\\VcsRepository'); $rm->setRepositoryClass('svn', 'Composer\\Repository\\VcsRepository'); $rm->setRepositoryClass('perforce', 'Composer\\Repository\\VcsRepository'); $rm->setRepositoryClass('hg', 'Composer\\Repository\\VcsRepository'); $rm->setRepositoryClass('artifact', 'Composer\\Repository\\ArtifactRepository'); $home = $this->getHomeDir(); $cache = $this->getCacheDir($home); $this->config->merge(array('config' => array('home' => $home, 'cache-dir' => $cache))); foreach ($this->config->getRepositories() as $index => $repo) { if (!is_array($repo)) { throw new \UnexpectedValueException('Repository ' . $index . ' (' . json_encode($repo) . ') should be an array, ' . gettype($repo) . ' given'); } if (!isset($repo['type'])) { throw new \UnexpectedValueException('Repository ' . $index . ' (' . json_encode($repo) . ') must have a type defined'); } $name = is_int($index) && isset($repo['url']) ? preg_replace('{^https?://}i', '', $repo['url']) : $index; while (isset($repos[$name])) { $name .= '2'; } $repo_object = $rm->createRepository($repo['type'], $repo); $rm->addRepository($repo_object); } }
private function mockRepositoryManager() { $repository_manager = new RepositoryManager($this->mockIO(), $this->mockConfig()); $repository_manager->setLocalRepository(new WritableArrayRepository()); return $repository_manager; }
/** * @param Repository\RepositoryManager $rm * @param Installer\InstallationManager $im */ protected function purgePackages(Repository\RepositoryManager $rm, Installer\InstallationManager $im) { foreach ($rm->getLocalRepositories() as $repo) { /* @var $repo Repository\WritableRepositoryInterface */ foreach ($repo->getPackages() as $package) { if (!$im->isPackageInstalled($repo, $package)) { $repo->removePackage($package); } } } }