/**
* Initializes library installer.
*
* @param IOInterface $io
* @param Composer $composer
* @param Filesystem $filesystem
*/
public function __construct(IOInterface $io, Composer $composer, Filesystem $filesystem = null)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->io = $io;
$this->filesystem = $filesystem ?: new Filesystem();
}
public function testSetGetDownloadManager()
{
$composer = new Composer();
$manager = $this->getMock('Composer\\Downloader\\DownloadManager');
$composer->setDownloadManager($manager);
$this->assertSame($manager, $composer->getDownloadManager());
}
/**
* @param bool $reload
*
* @return int
*/
protected function updateComposer($reload = false)
{
if ($reload) {
$this->composer = Factory::create($this->io, null, $this->disablePluginsByDefault);
}
ini_set('memory_limit', '1024M');
$this->composer->getDownloadManager()->setOutputProgress(true);
$install = Installer::create($this->io, $this->composer);
$config = $this->composer->getConfig();
$preferSource = false;
$preferDist = true;
switch ($config->get('preferred-install')) {
case 'source':
$preferSource = true;
break;
case 'dist':
$preferDist = true;
break;
case 'auto':
default:
break;
}
$optimize = $config->get('optimize-autoloader');
$authoritative = $config->get('classmap-authoritative');
$install->setPreferSource($preferSource);
$install->setPreferDist($preferDist);
$install->setDevMode(true);
$install->setDumpAutoloader(true);
$install->setOptimizeAutoloader(true);
$install->setUpdate(true);
return $install->run();
}
/**
* @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}");
}
}
}
/**
* @param \Composer\Composer $composer
* @param \Composer\Util\Filesystem $filesystem
*/
public function __construct(\Composer\Composer $composer, \Composer\Util\Filesystem $filesystem = NULL)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->filesystem = $filesystem ?: new \Composer\Util\Filesystem();
$this->extensionDir = self::TYPO3_CONF_DIR . DIRECTORY_SEPARATOR . self::TYPO3_EXT_DIR;
}
/**
* @param \Composer\Composer $composer
* @param Filesystem $filesystem
*/
public function __construct(\Composer\Composer $composer, Filesystem $filesystem, CoreInstaller\GetTypo3OrgService $getTypo3OrgService)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->filesystem = $filesystem;
$this->getTypo3OrgService = $getTypo3OrgService;
$this->symlinks = array(self::TYPO3_SRC_DIR . DIRECTORY_SEPARATOR . self::TYPO3_INDEX_PHP => self::TYPO3_INDEX_PHP, self::TYPO3_SRC_DIR . DIRECTORY_SEPARATOR . self::TYPO3_DIR => self::TYPO3_DIR);
}
/**
* @param \Composer\Composer $composer
* @param Filesystem $filesystem
*/
public function __construct(\Composer\Composer $composer, Filesystem $filesystem)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->filesystem = $filesystem;
$this->initializeConfiguration();
$this->initializeSymlinks();
}
/**
* @param \Composer\Composer $composer
* @param \Composer\Util\Filesystem $filesystem
*/
public function __construct(\Composer\Composer $composer, \Composer\Util\Filesystem $filesystem = NULL)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->filesystem = $filesystem ?: new \Composer\Util\Filesystem();
$this->initializeConfiguration();
$this->initializeExtensionDir();
}
public function testSetGetDownloadManager()
{
$composer = new Composer();
$io = $this->getMock('Composer\\IO\\IOInterface');
$manager = $this->getMock('Composer\\Downloader\\DownloadManager', array(), array($io));
$composer->setDownloadManager($manager);
$this->assertSame($manager, $composer->getDownloadManager());
}
/**
* @param \Composer\Composer $composer
* @param Filesystem $filesystem
*/
public function __construct(\Composer\Composer $composer, Filesystem $filesystem, CoreInstaller\GetTypo3OrgService $getTypo3OrgService)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->filesystem = $filesystem;
$this->getTypo3OrgService = $getTypo3OrgService;
$this->initializeConfiguration();
$this->initializeSymlinks();
}
/**
* 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;
}
/**
* Initializes library installer.
*
* @param IOInterface $io
* @param Composer $composer
* @param string $type
* @param Filesystem $filesystem
* @param BinaryInstaller $binaryInstaller
*/
public function __construct(IOInterface $io, Composer $composer, $type = 'library', Filesystem $filesystem = null, BinaryInstaller $binaryInstaller = null)
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->io = $io;
$this->type = $type;
$this->filesystem = $filesystem ?: new Filesystem();
$this->vendorDir = rtrim($composer->getConfig()->get('vendor-dir'), '/');
$this->binaryInstaller = $binaryInstaller ?: new BinaryInstaller($this->io, rtrim($composer->getConfig()->get('bin-dir'), '/'), $composer->getConfig()->get('bin-compat'), $this->filesystem);
}
/**
* Initializes library installer.
*
* @param IOInterface $io
* @param Composer $composer
* @param string $type
*/
public function __construct(IOInterface $io, Composer $composer, $type = 'library')
{
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
$this->io = $io;
$this->type = $type;
$this->filesystem = new Filesystem();
$this->vendorDir = rtrim($composer->getConfig()->get('vendor-dir'), '/');
$this->binDir = rtrim($composer->getConfig()->get('bin-dir'), '/');
}
/**
* @param Composer $composer
* @param IOInterface $io
*/
public function activate(Composer $composer, IOInterface $io)
{
$dm = $composer->getDownloadManager();
// yes, it is bad
$r = new \ReflectionObject($dm);
$property = $r->getProperty('downloaders');
$property->setAccessible(true);
$downloaders = $property->getValue($dm);
$downloaders['git'] = new \Sonata\Composer\Downloader\GitDownloader($io, $composer->getConfig());
$property->setValue($dm, $downloaders);
}
/**
* {@inheritDoc}
*/
public function activate(Composer $composer, IOInterface $io)
{
$filesystem = new Filesystem();
$composer->getInstallationManager()->addInstaller(new CoreInstaller($composer, $filesystem, new CoreInstaller\GetTypo3OrgService($io)));
$composer->getInstallationManager()->addInstaller(new ExtensionInstaller($composer, $filesystem));
$cache = null;
if ($composer->getConfig()->get('cache-files-ttl') > 0) {
$cache = new Cache($io, $composer->getConfig()->get('cache-files-dir'), 'a-z0-9_./');
}
$composer->getDownloadManager()->setDownloader('t3x', new Downloader\T3xDownloader($io, $composer->getConfig(), null, $cache));
}
public function activate(Composer $composer, IOInterface $io)
{
$this->composer = $composer;
$this->io = $io;
// check if there already are scripts in .profile.d, or INI files (because we got invoked before), then calculate new starting point for file names
foreach (['profileCounter' => (getenv('profile_dir_path') ?: '/dev/null') . '/[0-9][0-9][0-9]-*.sh', 'configCounter' => self::CONF_D_PATHNAME . '/[0-9][0-9][0-9]-*.ini'] as $var => $glob) {
if ($matches = glob($glob)) {
$this->{$var} = ceil(max(array_merge([$this->{$var}], array_map(function ($e) {
return explode('-', pathinfo($e, PATHINFO_FILENAME), 2)[0];
}, $matches))) / 10) + 1;
}
}
$composer->getDownloadManager()->setDownloader('heroku-sys-tar', new Downloader($io, $composer->getConfig(), $composer->getEventDispatcher()));
$composer->getInstallationManager()->addInstaller(new ComposerInstaller($io, $composer));
}
/**
* Installation package
*
* @param Composer $composer
*/
public function install(Composer $composer)
{
$this->init();
/* Create Composer in-memory package */
$versionParser = new VersionParser();
$normVersion = $versionParser->normalize($this->version);
$package = new Package($this->name, $normVersion, $this->version);
$package->setInstallationSource('dist');
$package->setDistUrl($this->url);
$package->setDistType($this->distType);
$package->setTargetDir($this->targetDir);
/* Download the Archive */
$downloadManager = $composer->getDownloadManager();
$downloadManager->download($package, $this->targetDir, false);
/* Copy binary to the "bin" file */
$binDir = $composer->getConfig()->get('bin-dir');
$this->copyToBinFolder($binDir);
}
/**
* @param IOInterface $io
* @param Composer $composer
*/
public function __construct(IOInterface $io, Composer $composer)
{
$this->io = $io;
$this->composer = $composer;
$this->downloadManager = $composer->getDownloadManager();
}
/**
* Create an Installer instance.
*
* Private static factory, to allow slip-streaming in a mock as needed for
* testing.
*/
private static function createInstaller(Composer $composer, IOInterface $io, PackageInterface $package)
{
$eventDispatcher = new EventDispatcher($composer, $io);
return new ComposerInstaller($io, $composer->getConfig(), $package, $composer->getDownloadManager(), $composer->getRepositoryManager(), $composer->getLocker(), $composer->getInstallationManager(), $eventDispatcher, $composer->getAutoloadGenerator());
}
/**
* Register TAR CLI Downloader
*
* @param Composer $composer
* @param IOInterface $io
* @return $this
*/
protected function _registerTarCliDownloader(Composer $composer, IOInterface $io)
{
$composer->getDownloadManager()->setDownloader(TarDownloader::ARCHIVE_CODE, new TarDownloader($io, $composer->getConfig()));
return $this;
}
public function activate(Composer $composer, IOInterface $io)
{
$composer->getDownloadManager()->setDownloader('heroku-sys-tar', new Downloader($io, $composer->getConfig(), $composer->getEventDispatcher()));
$composer->getInstallationManager()->addInstaller(new ComposerInstaller($io, $composer));
}
/**
* Create Installer
*
* @param IOInterface $io
* @param Composer $composer
* @return Installer
*/
public static function create(IOInterface $io, Composer $composer)
{
return new static($io, $composer->getConfig(), $composer->getPackage(), $composer->getDownloadManager(), $composer->getRepositoryManager(), $composer->getLocker(), $composer->getInstallationManager(), $composer->getEventDispatcher(), $composer->getAutoloadGenerator());
}
public function activate(Composer $composer, IOInterface $io)
{
$installer = new PlatformInstaller($io, $composer);
$composer->getInstallationManager()->addInstaller($installer);
// Look for extra platform-installer definition
$pi = false;
$package = $composer->getPackage();
$config = $composer->getConfig();
$extra = $package->getExtra();
if (!empty($extra['platform-installer'])) {
$pi = $extra['platform-installer'];
}
if (false === $pi) {
return;
}
// Cycle through platform installers
$installNow = array();
foreach ($pi as $platform => $installer) {
if ('all' === strtolower($platform)) {
foreach ($installer as $install) {
if (!empty($install['url'])) {
if (empty($install['dir'])) {
$install['dir'] = $config->get('vendor-dir') . '/steveorevo/platform/' . strtolower($platform);
}
if (!is_dir($install['dir'])) {
array_push($installNow, $install);
}
}
}
} else {
foreach ($installer as $install) {
if (empty($install['dir'])) {
$install['dir'] = $config->get('vendor-dir') . '/steveorevo/platform/' . strtolower($platform);
}
// Check for architecture
$arch = "";
if (substr($platform, -3) === "_64" || substr($platform, -3) === "_32") {
$arch = substr($platform, -3);
$platform = substr($platform, 0, -3);
}
// Prevent matching 'win' within 'Darwin' and computer name conflicts on Mac
$uname = php_uname();
if (PHP_OS === "Darwin") {
$platform = str_ireplace('Darwin', 'Macintosh', $platform);
$uname = str_ireplace('Darwin', 'Macintosh', $uname);
$uname = str_ireplace(gethostname(), '', $uname);
}
if (false !== stripos($uname, $platform)) {
if ($arch !== "") {
if ($arch === '_' . 8 * PHP_INT_SIZE) {
if (!is_dir($install['dir'])) {
array_push($installNow, $install);
}
}
} else {
if (!is_dir($install['dir'])) {
array_push($installNow, $install);
}
}
}
}
}
}
// Download platform installers
foreach ($installNow as $install) {
$targetDir = $install['dir'];
$url = $install['url'];
$downloadManager = $composer->getDownloadManager();
$version = $package->getVersion();
$versionParser = new VersionParser();
$normVersion = $versionParser->normalize($version);
$package = new Package($url, $normVersion, $version);
$package->setTargetDir($targetDir);
$package->setInstallationSource('dist');
if (false === strpos($url, '.zip')) {
$package->setDistType('tar');
} else {
$package->setDistType('zip');
}
$package->setDistUrl($url);
try {
$downloadManager->download($package, $targetDir, false);
} catch (\Exception $e) {
if ($e instanceof \Composer\Downloader\TransportException && $e->getStatusCode() === 404) {
$io->write("<warning>File not found: {$url}</warning>");
} else {
$io->write("<warning>Error downloading: {$url}</warning>");
}
}
}
}
public function install(IOInterface $io, Composer $composer, EventDispatcher $eventDispatcher, $preferSource = false, $dryRun = false, $verbose = false, $noInstallRecommends = false, $installSuggests = false, $update = false, RepositoryInterface $additionalInstalledRepository = null)
{
if ($dryRun) {
$verbose = true;
}
if ($preferSource) {
$composer->getDownloadManager()->setPreferSource(true);
}
// create local repo, this contains all packages that are installed in the local project
$localRepo = $composer->getRepositoryManager()->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);
}
// creating repository pool
$pool = new Pool();
$pool->addRepository($installedRepo);
foreach ($composer->getRepositoryManager()->getRepositories() as $repository) {
$pool->addRepository($repository);
}
// dispatch pre event
if (!$dryRun) {
$eventName = $update ? ScriptEvents::PRE_UPDATE_CMD : ScriptEvents::PRE_INSTALL_CMD;
$eventDispatcher->dispatchCommandEvent($eventName);
}
// creating requirements request
$installFromLock = false;
$request = new Request($pool);
if ($update) {
$io->write('<info>Updating dependencies</info>');
$installedPackages = $installedRepo->getPackages();
$links = $this->collectLinks($composer->getPackage(), $noInstallRecommends, $installSuggests);
$request->updateAll();
foreach ($links as $link) {
$request->install($link->getTarget(), $link->getConstraint());
}
} elseif ($composer->getLocker()->isLocked()) {
$installFromLock = true;
$io->write('<info>Installing from lock file</info>');
if (!$composer->getLocker()->isFresh()) {
$io->write('<warning>Your lock file is out of sync with your composer.json, run "composer.phar update" to update dependencies</warning>');
}
foreach ($composer->getLocker()->getLockedPackages() as $package) {
$constraint = new VersionConstraint('=', $package->getVersion());
$request->install($package->getName(), $constraint);
}
} else {
$io->write('<info>Installing dependencies</info>');
$links = $this->collectLinks($composer->getPackage(), $noInstallRecommends, $installSuggests);
foreach ($links as $link) {
$request->install($link->getTarget(), $link->getConstraint());
}
}
// prepare solver
$installationManager = $composer->getInstallationManager();
$policy = new DependencyResolver\DefaultPolicy();
$solver = new DependencyResolver\Solver($policy, $pool, $installedRepo);
// solve dependencies
$operations = $solver->solve($request);
// execute operations
if (!$operations) {
$io->write('<info>Nothing to install/update</info>');
}
// force dev packages to be updated to latest reference on update
if ($update) {
foreach ($localRepo->getPackages() as $package) {
// 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 = $composer->getRepositoryManager()->findPackage($package->getName(), $package->getVersion());
if ($newPackage && $newPackage->getSourceReference() !== $package->getSourceReference()) {
$operations[] = new UpdateOperation($package, $newPackage);
}
}
}
foreach ($operations as $operation) {
if ($verbose) {
$io->write((string) $operation);
}
if (!$dryRun) {
$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 = $composer->getLocker()->getLockData();
foreach ($lockData['packages'] as $lockedPackage) {
if (!empty($lockedPackage['source-reference']) && strtolower($lockedPackage['package']) === $package->getName()) {
$package->setSourceReference($lockedPackage['source-reference']);
break;
}
}
}
}
$installationManager->execute($operation);
$eventDispatcher->dispatchPackageEvent(constant('Composer\\Script\\ScriptEvents::POST_PACKAGE_' . strtoupper($operation->getJobType())), $operation);
}
}
if (!$dryRun) {
if ($update || !$composer->getLocker()->isLocked()) {
$composer->getLocker()->lockPackages($localRepo->getPackages());
$io->write('<info>Writing lock file</info>');
}
$localRepo->write();
$io->write('<info>Generating autoload files</info>');
$generator = new AutoloadGenerator();
$generator->dump($localRepo, $composer->getPackage(), $installationManager, $installationManager->getVendorPath() . '/.composer');
// dispatch post event
$eventName = $update ? ScriptEvents::POST_UPDATE_CMD : ScriptEvents::POST_INSTALL_CMD;
$eventDispatcher->dispatchCommandEvent($eventName);
}
}
/**
* Create Installer
*
* @param IOInterface $io
* @param Composer $composer
* @param EventDispatcher $eventDispatcher
* @param AutoloadGenerator $autoloadGenerator
* @return Installer
*/
public static function create(IOInterface $io, Composer $composer, EventDispatcher $eventDispatcher = null, AutoloadGenerator $autoloadGenerator = null)
{
$eventDispatcher = $eventDispatcher ?: new EventDispatcher($composer, $io);
$autoloadGenerator = $autoloadGenerator ?: new AutoloadGenerator();
return new static($io, $composer->getConfig(), $composer->getPackage(), $composer->getDownloadManager(), $composer->getRepositoryManager(), $composer->getLocker(), $composer->getInstallationManager(), $eventDispatcher, $autoloadGenerator);
}
/**
* @param Composer $composer
* @param IOInterface $io
*/
public function activate(Composer $composer, IOInterface $io)
{
$this->io = $io;
$repositoryManager = $composer->getRepositoryManager();
$extra = $composer->getPackage()->getExtra();
if (!isset($extra['connect-packages'])) {
return;
}
$composer->getDownloadManager()->setDownloader(TarDownloader::ARCHIVE_CODE, new TarDownloader($io, $composer->getConfig()));
$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>';
$this->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();
$this->io->writeError(sprintf($message, $connectPackage), true);
continue;
}
$repository = $this->addPackages($releases, $connectPackage, $versionParser);
$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);
}
}
