public function onPostUpdate(Event $event)
{
$requires = [];
$overrides = [];
$resolutions = [];
if ($event->isDevMode()) {
$extra = $this->composer->getPackage()->getExtra();
$bower = isset($extra['bower']) ? $extra['bower'] : [];
if (isset($bower['require-dev'])) {
$requires = $this->_mergeDependencyVersions($requires, $bower['require-dev']);
}
}
$packages = [$this->composer->getPackage()];
$packages = array_merge($packages, $this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages());
foreach ($packages as $package) {
if ($package instanceof CompletePackage) {
$extra = $package->getExtra();
$bower = isset($extra['bower']) ? $extra['bower'] : [];
if (isset($bower['require'])) {
$requires = $this->_mergeDependencyVersions($requires, $bower['require']);
}
if (isset($bower['overrides'])) {
$overrides = array_merge_recursive($overrides, $bower['overrides']);
}
if (isset($bower['resolutions'])) {
$resolutions = $bower['resolutions'];
}
}
}
if (!$requires) {
$this->info("No Bower packages are required by the application or by any installed Composer package");
}
$dependencies = $this->_installBower($requires, $overrides, $resolutions);
$this->info((count($dependencies) ?: "No") . " bower packages are installed");
}
/**
* Register all managed paths with Composer.
*
* This function configures Composer to treat all Studio-managed paths as local path repositories, so that packages
* therein will be symlinked directly.
*/
public function registerStudioPackages()
{
$repoManager = $this->composer->getRepositoryManager();
$composerConfig = $this->composer->getConfig();
foreach ($this->getManagedPaths() as $path) {
$this->io->writeError("[Studio] Loading path {$path}");
$repoManager->prependRepository(new PathRepository(['url' => $path], $this->io, $composerConfig));
}
}
private function registerLoader()
{
$package = $this->composer->getPackage();
$generator = $this->composer->getAutoloadGenerator();
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
$packageMap = $generator->buildPackageMap($this->composer->getInstallationManager(), $package, $packages);
$map = $generator->parseAutoloads($packageMap, $package);
$this->loader = $generator->createLoader($map);
$this->loader->register();
}
/**
* Function to run after a package has been updated
*
* @param CommandEvent $event
*/
public function onPostInstallUpdateCmd(CommandEvent $event)
{
/** @var \Composer\Repository\WritableRepositoryInterface $repository */
$repository = $this->composer->getRepositoryManager()->getLocalRepository();
/** @var \Composer\Package\CompletePackage $package */
foreach ($repository->getPackages() as $package) {
if ($package instanceof BasePackage) {
$this->cleanPackage($package);
}
}
}
public function onPostUpdate(Event $event)
{
// Load global plugin configuration
$globalCfg = $this->getGlobalConfig();
if ($globalCfg) {
$extra = self::get($globalCfg, 'extra', []);
$myConfig = self::get($extra, self::EXTRA_KEY, []);
if ($myConfig) {
$this->info("Global configuration loaded");
}
} else {
$myConfig = [];
}
// Merge project-specific configuration.
// Ignore it if Composer is running in global mode.
$package = $this->composer->getPackage();
if ($package->getName() != '__root__') {
$projCfg = self::get($package->getExtra(), self::EXTRA_KEY, []);
$myConfig = array_merge_recursive($myConfig, $projCfg);
$this->info("Project-specific configuration loaded");
}
// Setup
$rules = array_unique(self::get($myConfig, self::RULES_KEY, []));
$sharedDir = str_replace('~', getenv('HOME'), self::get($myConfig, self::SHARED_DIR_KEY, self::DEFAULT_SHARED_DIR));
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
$rulesInfo = implode(', ', $rules);
$this->info("Shared directory: <info>{$sharedDir}</info>");
$this->info("Match packages: <info>{$rulesInfo}</info>");
$fsUtil = new FilesystemUtil();
$fs = new Filesystem();
// Do useful work
$count = 0;
foreach ($packages as $package) {
$srcDir = $this->getInstallPath($package);
$packageName = $package->getName();
if (self::globMatchAny($rules, $packageName) && !$fsUtil->isSymlinkedDirectory($srcDir)) {
$destPath = "{$sharedDir}/{$packageName}";
if (!file_exists($destPath)) {
$fsUtil->copyThenRemove($srcDir, $destPath);
$this->info("Moved <info>{$packageName}</info> to shared directory and symlinked to it");
} else {
$fs->remove($srcDir);
$this->info("Symlinked to existing <info>{$packageName}</info> on shared directory");
}
$fs->symlink($destPath, $srcDir);
++$count;
}
}
if (!$count) {
$this->info("No packages matched");
}
}
/**
* @param bool $optimize
* @param bool $reload
*/
protected function dumpAutoloads($optimize = true, $reload = false)
{
if ($reload) {
$this->composer = Factory::create($this->io, null, $this->disablePluginsByDefault);
}
$config = $this->composer->getConfig();
$generator = $this->composer->getAutoloadGenerator();
$installationManager = $this->composer->getInstallationManager();
$localRepository = $this->composer->getRepositoryManager()->getLocalRepository();
$package = $this->composer->getPackage();
$generator->dump($config, $localRepository, $package, $installationManager, 'composer', $optimize);
$this->info('Composer DumpAutoloads Completed!');
}
/**
* @param string $baseDir Root directory of composer package.
*/
public function __construct($baseDir)
{
$this->baseDir = $baseDir;
$io = new NullIO();
$this->composer = (new Factory())->createComposer($io, $baseDir . '/composer.json', true, $baseDir, false);
$generator = new AutoloadGenerator($this->composer->getEventDispatcher(), $io);
$generator->setDevMode(true);
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
$packageMap = $generator->buildPackageMap($this->composer->getInstallationManager(), $this->composer->getPackage(), $packages);
$packageMap[0][1] = $baseDir;
// To make root package paths absolute too.
$autoloads = $generator->parseAutoloads($packageMap, $this->composer->getPackage());
$this->classLoader = $generator->createLoader($autoloads);
}
/**
* Get an array of packages that depend on the target package
*
* @param bool $isDevMode
* @return PackageWrapper[]
*/
public function getDependentPackages($isDevMode)
{
$packages = [];
$rootPackage = $this->composer->getPackage();
if ($this->isDependentPackage($rootPackage, (bool) $isDevMode)) {
$packages[] = new PackageWrapper($rootPackage, getcwd());
}
$manager = $this->composer->getInstallationManager();
foreach ($this->composer->getRepositoryManager()->getLocalRepository()->getPackages() as $package) {
if ($this->isDependentPackage($package, $isDevMode)) {
$packages[] = new PackageWrapper($package, $manager->getInstallPath($package));
}
}
return $packages;
}
/**
* Call extra recursive
* @param Composer $composer
* @param IExtra $extra
*/
private function callRecursive(Composer $composer, IExtra $extra)
{
$extra->run($composer->getPackage(), true);
foreach ($composer->getRepositoryManager()->getLocalRepository()->getPackages() as $package) {
$extra->run($package, false);
}
}
/**
* @param \Composer\Composer
* @param string
* @param string
*/
public function dumpFiles(Composer $composer, $paths, $targetDir = 'composer')
{
$installationManager = $composer->getInstallationManager();
$localRepo = $composer->getRepositoryManager()->getLocalRepository();
$mainPackage = $composer->getPackage();
$config = $composer->getConfig();
$filesystem = new Filesystem();
$basePath = $filesystem->normalizePath(realpath(getcwd()));
$vendorPath = $filesystem->normalizePath(realpath($config->get('vendor-dir')));
$targetDir = $vendorPath . '/' . $targetDir;
$vendorPathCode = $filesystem->findShortestPathCode(realpath($targetDir), $vendorPath, true);
$vendorPathCode52 = str_replace('__DIR__', 'dirname(__FILE__)', $vendorPathCode);
$appBaseDirCode = $filesystem->findShortestPathCode($vendorPath, $basePath, true);
$appBaseDirCode = str_replace('__DIR__', '$vendorDir', $appBaseDirCode);
$packageMap = $this->buildPackageMap($installationManager, $mainPackage, $localRepo->getCanonicalPackages());
$autoloads = $this->parseAutoloads($packageMap, $mainPackage);
$paths = $this->parseAutoloadsTypeFiles($paths, $mainPackage);
$autoloads['files'] = array_merge($paths, $autoloads['files']);
$includeFilesFilePath = $targetDir . '/autoload_files.php';
if ($includeFilesFileContents = $this->getIncludeFilesFile($autoloads['files'], $filesystem, $basePath, $vendorPath, $vendorPathCode52, $appBaseDirCode)) {
file_put_contents($includeFilesFilePath, $includeFilesFileContents);
} elseif (file_exists($includeFilesFilePath)) {
unlink($includeFilesFilePath);
}
}
/**
* finds a list of packages which depend on another package
*
* @param InputInterface $input
* @param OutputInterface $output
* @param Composer $composer
* @return array
* @throws \InvalidArgumentException
*/
private function getReferences(InputInterface $input, OutputInterface $output, Composer $composer)
{
$needle = $input->getArgument('package');
$references = array();
$verbose = (bool) $input->getOption('verbose');
$repos = $composer->getRepositoryManager()->getRepositories();
$types = $input->getOption('link-type');
foreach ($repos as $repository) {
foreach ($repository->getPackages() as $package) {
foreach ($types as $type) {
$type = rtrim($type, 's');
if (!isset($this->linkTypes[$type])) {
throw new \InvalidArgumentException('Unexpected link type: ' . $type . ', valid types: ' . implode(', ', array_keys($this->linkTypes)));
}
foreach ($package->{'get' . $this->linkTypes[$type]}() as $link) {
if ($link->getTarget() === $needle) {
if ($verbose) {
$references[] = array($type, $package, $link);
} else {
$references[$package->getName()] = $package->getPrettyName();
}
}
}
}
}
}
return $references;
}
/**
* Returns the PhantomJS version number.
*
* Firstly, we search for a version number in the local repository,
* secondly, in the root package.
* A version specification of "dev-master#<commit-reference>" is disallowed.
*
* @param Composer $composer
* @return string $version Version
*/
public static function getVersion($composer)
{
$packages = $composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
$os = self::getOS();
foreach ($packages as $package) {
if ($package->getName() === 'triplekdev/phantomjs-installer') {
$version = $package->getPrettyVersion();
}
}
// version was not found in the local repository, let's take a look at the root package
if ($version == null) {
$version = self::getRequiredVersion($composer->getPackage(), 'triplekdev/phantomjs-installer');
}
// fallback to a hardcoded version number, if "dev-master" was set
if ($version === 'dev-master') {
return $os === 'macosx' ? '2.0.1' : '1.9.8';
}
// grab version from commit-reference, e.g. "dev-master#<commit-ref> as version"
if (preg_match('/dev-master#(?:.*)(\\d.\\d.\\d)/i', $version, $matches)) {
return $matches[1];
}
// grab version from a git version tag with a patch level, like "1.9.8-2"
if (preg_match('/(\\d.\\d.\\d)(?:(?:-\\d)?)/i', $version, $matches)) {
return $matches[1];
}
// grab version from a Composer patch version tag with a patch level, like "1.9.8-p02"
if (preg_match('/(\\d.\\d.\\d)(?:(?:-p\\d{2})?)/i', $version, $matches)) {
return $matches[1];
}
return $version;
}
/**
* Get filtered packages array
*/
public function getStaticPackages() : array
{
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
return array_filter($packages, function (PackageInterface $package) {
return $package->getType() == static::PACKAGE_TYPE && $this->getStaticMaps($package->getName());
});
}
/**
* @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 testSetGetRepositoryManager()
{
$composer = new Composer();
$manager = $this->getMockBuilder('Composer\\Repository\\RepositoryManager')->disableOriginalConstructor()->getMock();
$composer->setRepositoryManager($manager);
$this->assertSame($manager, $composer->getRepositoryManager());
}
/**
* Get the patches and packages that are not already in $history
*
* @param \Composer\Package\PackageInterface $initialPackage
* @param array &$history
* @return array
*/
protected function getPatches(PackageInterface $initialPackage, array &$history)
{
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
$patchSets = array();
foreach ($packages as $package) {
$extra = $package->getExtra();
if (isset($extra['patches']) && $initialPackage->getName() != $package->getName()) {
$patchSets[$package->getName()] = array($extra['patches'], array($initialPackage));
}
}
$extra = $initialPackage->getExtra();
if (isset($extra['patches'])) {
$patchSets[$initialPackage->getName()] = array($extra['patches'], $packages);
}
$patchesAndPackages = array();
foreach ($patchSets as $sourceName => $patchConfAndPackages) {
$patchSet = new PatchSet($patchConfAndPackages[0], $this->downloader);
foreach ($patchConfAndPackages[1] as $package) {
$id = $sourceName . '->' . $package->getName();
$patches = $patchSet->getPatches($package->getName(), $package->getVersion());
if (!array_key_exists($id, $history) && count($patches)) {
$patchesAndPackages[$id] = array($patches, $package);
$history[$id] = TRUE;
}
}
}
return $patchesAndPackages;
}
/**
* @inheritdoc
*/
public function activate(Composer $composer, IOInterface $io)
{
$this->io = $io;
//Extend download manager
$dm = $composer->getDownloadManager();
$executor = new ProcessExecutor($io);
$fs = new Filesystem($executor);
$config = $composer->getConfig();
$dm->setDownloader('svn-export', new Downloader($io, $config, $executor, $fs));
//Extend RepositoryManager Classes
$rm = $composer->getRepositoryManager();
$rm->setRepositoryClass('svn-export', 'LinearSoft\\Composer\\SvnExport\\Repository\\VcsRepository');
$rm->setRepositoryClass('svn-export-composer', 'LinearSoft\\Composer\\SvnExport\\Repository\\ComposerRepository');
//Load Extra Data
$extra = $composer->getPackage()->getExtra();
if (isset($extra['svn-export-repositories']) && is_array($extra['svn-export-repositories'])) {
foreach ($extra['svn-export-repositories'] as $index => $repoConfig) {
$this->validateRepositories($index, $repoConfig);
if (isset($repoConfig['name'])) {
$name = $repoConfig['name'];
} else {
$name = is_int($index) ? preg_replace('{^https?://}i', '', $repoConfig['url']) : $index;
}
if ($repoConfig['type'] === 'svn') {
$repoConfig['type'] = 'svn-export';
} else {
$repoConfig['type'] = 'svn-export-composer';
}
$repo = $rm->createRepository($repoConfig['type'], $repoConfig);
$rm->addRepository($repo);
$this->io->write("Added SvnExport repo: {$name}");
}
}
}
/**
* Adds vcs repositories in manager from asset dependencies with url version.
*
* @param VcsRepositoryEvent $event
*/
public function onAddVcsRepositories(VcsRepositoryEvent $event)
{
if (null !== $this->composer) {
$rm = $this->composer->getRepositoryManager();
$this->addRepositories($rm, $event->getRepositories(), $this->pool);
}
}
protected static function getPackageLocation(Composer $composer, $name)
{
$packages = $composer->getRepositoryManager()->getLocalRepository()->findPackages($name);
if (empty($packages)) {
throw new \RuntimeException(sprintf('Unable to find package %s', $name));
}
return $composer->getInstallationManager()->getInstallPath(reset($packages));
}
/**
* Init multi VCS repository
*
* @param Composer $composer
* @param IOInterface $io
* @return $this
*/
protected function initMultiVcsRepositories(Composer $composer, IOInterface $io)
{
$repoDownloader = new GitMultiRepoDownloader($io, $composer->getConfig());
foreach ($this->getVcsTypes() as $type) {
$composer->getDownloadManager()->setDownloader($type, $repoDownloader);
$composer->getRepositoryManager()->setRepositoryClass($type, $this->getMultiRepositoryClassName());
}
return $this;
}
/**
* Returns all installed packages (including root)
*
* @return array
*/
private function getPackages()
{
$ourPackages = array();
// Dependencies
$installedPackages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
// Root package
array_unshift($installedPackages, $this->composer->getPackage());
foreach ($installedPackages as $pkg) {
// Resolve aliases
while ($pkg instanceof AliasPackage) {
$pkg = $pkg->getAliasOf();
}
if (!in_array($pkg, $ourPackages)) {
$ourPackages[] = $pkg;
}
}
return $ourPackages;
}
/**
* Loads Composer's currently installed packages.
*
* @return PackageInterface[] The installed packages indexed by their names.
*/
private function loadComposerPackages()
{
$repository = $this->composer->getRepositoryManager()->getLocalRepository();
$packages = array();
foreach ($repository->getPackages() as $package) {
/* @var PackageInterface $package */
$packages[$package->getName()] = $package;
}
return $packages;
}
/**
* Find all NPM bridge enabled vendor packages.
*
* @param Composer $composer The Composer object for the root project.
* @param NpmBridge $bridge The bridge to use.
*
* @return array<integer,PackageInterface> The list of NPM bridge enabled vendor packages.
*/
public function find(Composer $composer, NpmBridge $bridge)
{
$packages = $composer->getRepositoryManager()->getLocalRepository()->getPackages();
$dependantPackages = array();
foreach ($packages as $package) {
if ($bridge->isDependantPackage($package, false)) {
$dependantPackages[] = $package;
}
}
return $dependantPackages;
}
/**
* Return the full install path of a package
*
* @param Composer $composer
* @param string $packageName
* @return string install path
*/
public static function getPackagePath(Composer $composer, $packageName)
{
$repo = $composer->getRepositoryManager()->getLocalRepository();
$install_mgr = $composer->getInstallationManager();
$packages = $repo->findPackages($packageName, null);
foreach ($packages as $package) {
if ($install_mgr->getInstaller($package->getType())->isInstalled($repo, $package)) {
return $install_mgr->getInstallPath($package);
}
}
}
protected function deployLibraries()
{
$packages = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();
$autoloadDirectories = array();
$libraryPath = $this->config->getLibraryPath();
if ($libraryPath === null) {
if ($this->io->isDebug()) {
$this->io->write('jump over deployLibraries as no Magento libraryPath is set');
}
return;
}
$vendorDir = rtrim($this->composer->getConfig()->get('vendor-dir'), '/');
$filesystem = $this->filesystem;
$filesystem->removeDirectory($libraryPath);
$filesystem->ensureDirectoryExists($libraryPath);
foreach ($packages as $package) {
/** @var PackageInterface $package */
$packageConfig = $this->config->getLibraryConfigByPackagename($package->getName());
if ($packageConfig === null) {
continue;
}
if (!isset($packageConfig['autoload'])) {
$packageConfig['autoload'] = array('/');
}
foreach ($packageConfig['autoload'] as $path) {
$autoloadDirectories[] = $libraryPath . '/' . $package->getName() . "/" . $path;
}
if ($this->io->isDebug()) {
$this->io->write('Magento deployLibraries executed for ' . $package->getName());
}
$libraryTargetPath = $libraryPath . '/' . $package->getName();
$filesystem->removeDirectory($libraryTargetPath);
$filesystem->ensureDirectoryExists($libraryTargetPath);
$this->copyRecursive($vendorDir . '/' . $package->getPrettyName(), $libraryTargetPath);
}
$autoloadGenerator = new AutoloadGenerator(new EventDispatcher($this->composer, $this->io));
$classmap = ClassMapGenerator::createMap($libraryPath);
$executable = $this->composer->getConfig()->get('bin-dir') . '/phpab';
if (!file_exists($executable)) {
$executable = $this->composer->getConfig()->get('vendor-dir') . '/theseer/autoload/composer/bin/phpab';
}
if (file_exists($executable)) {
if ($this->io->isDebug()) {
$this->io->write('Magento deployLibraries executes autoload generator');
}
$process = new Process($executable . " -o {$libraryPath}/autoload.php " . implode(' ', $autoloadDirectories));
$process->run();
} else {
if ($this->io->isDebug()) {
$this->io->write('Magento deployLibraries autoload generator not availabel, you should require "theseer/autoload"');
var_dump($executable, getcwd());
}
}
}
/**
* 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()));
}
/**
* Inject the currently installed contao/core as meta package.
*
* @return void
*
* @throws ConstantsNotFoundException When the root path could not be determined.
*/
public function injectContaoCore()
{
$roots = Environment::findContaoRoots($this->composer->getPackage());
if (0 === count($roots)) {
throw new ConstantsNotFoundException('Could not find contao root path and therefore no constants.php');
}
// Duplicate installation, remove from vendor folder
$removeVendor = count($roots) > 1 && isset($roots['vendor']);
$root = $this->getContaoRoot($this->composer->getPackage());
$repositoryManager = $this->composer->getRepositoryManager();
$localRepository = $repositoryManager->getLocalRepository();
$versionParser = new VersionParser();
$prettyVersion = $this->prepareContaoVersion($this->getContaoVersion(), $this->getContaoBuild());
$version = $versionParser->normalize($prettyVersion);
// @codingStandardsIgnoreStart
// Sadly we can not add the bundles as provided packages, as the Pool cleans them up.
// See also: https://github.com/composer/composer/blob/2d19cf/src/Composer/DependencyResolver/Pool.php#L174
// The skipping in there ignores any provided packages, even from already installed ones, and therefore makes
// this approach impossible.
// We therefore register them all as meta packages in the local repository and require them in the same version
// below then.
// @codingStandardsIgnoreEnd
$this->injectContaoBundles($localRepository, $version, $prettyVersion);
/** @var PackageInterface $localPackage */
foreach ($localRepository->getPackages() as $localPackage) {
if ($localPackage->getName() === 'contao/core') {
if ($removeVendor) {
$this->composer->getInstallationManager()->uninstall($localRepository, new UninstallOperation($localPackage));
} elseif ($this->isNotMetaPackageOrHasSameVersion($localPackage, $version)) {
// stop if the contao package is required somehow and must not be injected or
// if the virtual contao package is already injected
return;
}
// Remove package otherwise.
$localRepository->removePackage($localPackage);
break;
}
}
$contaoCore = new CompletePackage('contao/core', $version, $prettyVersion);
$contaoCore->setType('metapackage');
$this->injectSwiftMailer($root, $contaoCore);
$clientLink = new Link('contao/core', 'contao-community-alliance/composer-client', $this->createEmptyConstraint('~0.14'), 'requires', '~0.14');
$requires = array('contao-community-alliance/composer-client' => $clientLink);
// Add the bundles now.
foreach (Environment::$bundleNames as $bundleName) {
if ($package = $localRepository->findPackage($bundleName, '*')) {
$requires[$bundleName] = new Link('contao/core', $bundleName, $this->createEmptyConstraint($package->getVersion()), 'requires', $package->getVersion());
}
}
$contaoCore->setRequires($requires);
$localRepository->addPackage($contaoCore);
}
private function hasFeatureBranch(Link $require, Constraint $requiredConstraint)
{
if ($this->isFeatureBranchRepository($require)) {
$this->io->write(sprintf('<info>%s</info>', $require->getTarget()), false);
$package = $this->composer->getRepositoryManager()->findPackage($require->getTarget(), $requiredConstraint);
if ($package) {
$this->io->write(" - <info>switching to branch</info>", false);
return true;
}
$this->io->write(" - <warning>branch not found</warning>", false);
}
return false;
}
public function activate(Composer $composer, IOInterface $io)
{
if ($package = $composer->getPackage()) {
$this->setConfig(Config::createFromPackage($package));
}
$repo = new CompositeRepository(array(new WordPressCoreRepository($io, $composer->getConfig()), new WordPressThemeRepository($io, $composer->getConfig()), new WordPressPluginRepository($io, $composer->getConfig())));
$composer->getRepositoryManager()->addRepository($repo);
$im = $composer->getInstallationManager();
$im->addInstaller(new CoreInstaller($io, $composer, $this));
$im->addInstaller(new ThemeInstaller($io, $composer, $this));
$im->addInstaller(new PluginInstaller($io, $composer, $this));
$im->addInstaller(new MuPluginInstaller($io, $composer, $this));
}
/**
* Returns the PhantomJS version number.
*
* Firstly, we search for a version number in the local repository,
* secondly, in the root package.
* A version specification of "dev-master#<commit-reference>" is disallowed.
*
* @param Composer $composer
* @return string $version Version
*/
public static function getVersion($composer)
{
$packages = $composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
foreach ($packages as $package) {
if ($package->getName() === 'jerome-breton/casperjs-installer') {
$version = $package->getPrettyVersion();
}
}
// version was not found in the local repository, let's take a look at the root package
if ($version == null) {
$version = self::getRequiredVersion($composer->getPackage(), 'jerome-breton/casperjs-installer');
}
if ($version == 'dev-master') {
return 'master';
}
return $version;
}
