/**
* Constructor
*
* @param Filesystem $filesystem
*/
public function __construct(Filesystem $filesystem)
{
$vendor = $filesystem->getDirectoryRead(DirectoryList::CONFIG)->getAbsolutePath('vendor_path.php');
$vendorPath = $filesystem->getDirectoryRead(DirectoryList::ROOT)->getAbsolutePath() . (include $vendor);
// Create Composer
$io = new \Composer\IO\BufferIO();
$this->composer = ComposerFactory::create($io, $vendorPath . '/../composer.json');
$this->locker = $this->composer->getLocker();
}
/**
* {@inheritdoc}
*/
public function init()
{
// Retrieve the configuration variables.
$this->config = $this->composer->getConfig();
if (isset($this->config)) {
if ($this->config->has('component-dir')) {
$this->componentDir = $this->config->get('component-dir');
}
}
// Get the available packages.
$allPackages = array();
/** @var \Composer\Package\Locker $locker */
$locker = $this->composer->getLocker();
if ($locker !== null && $locker->isLocked()) {
$lockData = $locker->getLockData();
$allPackages = $lockData['packages'];
// Also merge in any of the development packages.
$dev = isset($lockData['packages-dev']) ? $lockData['packages-dev'] : array();
foreach ($dev as $package) {
$allPackages[] = $package;
}
}
// Only add those packages that we can reasonably
// assume are components into our packages list
/** @var \Composer\Package\RootPackageInterface $rootPackage */
$rootPackage = $this->composer->getPackage();
$rootExtras = $rootPackage ? $rootPackage->getExtra() : array();
$customComponents = isset($rootExtras['component']) ? $rootExtras['component'] : array();
foreach ($allPackages as $package) {
$name = $package['name'];
if (isset($customComponents[$name]) && is_array($customComponents[$name])) {
$package['extra'] = array('component' => $customComponents[$name]);
$this->packages[] = $package;
} else {
$extra = isset($package['extra']) ? $package['extra'] : array();
if (isset($extra['component']) && is_array($extra['component'])) {
$this->packages[] = $package;
}
}
}
// Add the root package to the packages list.
$root = $this->composer->getPackage();
if ($root) {
$dumper = new ArrayDumper();
$package = $dumper->dump($root);
$package['is-root'] = true;
$this->packages[] = $package;
}
return true;
}
/**
* Constructor
*
* @param Filesystem $filesystem
* @param BufferIoFactory $bufferIoFactory
* @throws \Exception
*/
public function __construct(Filesystem $filesystem, BufferIoFactory $bufferIoFactory)
{
// composer.json is in same directory as vendor
$vendorPath = $filesystem->getDirectoryRead(DirectoryList::CONFIG)->getAbsolutePath('vendor_path.php');
$vendorDir = (require "{$vendorPath}");
$composerJson = $filesystem->getDirectoryRead(DirectoryList::ROOT)->getAbsolutePath() . "/{$vendorDir}/../composer.json";
$composerJsonRealPath = realpath($composerJson);
if ($composerJsonRealPath === false) {
throw new \Exception('Composer file not found: ' . $composerJson);
}
putenv('COMPOSER_HOME=' . $filesystem->getDirectoryRead(DirectoryList::COMPOSER_HOME)->getAbsolutePath());
// Create Composer
$this->composer = ComposerFactory::create($bufferIoFactory->create(), $composerJson);
$this->locker = $this->composer->getLocker();
}
public function testSetGetLocker()
{
$composer = new Composer();
$locker = $this->getMockBuilder('Composer\\Package\\Locker')->disableOriginalConstructor()->getMock();
$composer->setLocker($locker);
$this->assertSame($locker, $composer->getLocker());
}
/**
* Constructor
*
* @param MagentoComposerApplicationFactory $applicationFactory
* @throws \Exception
*/
public function __construct(
MagentoComposerApplicationFactory $applicationFactory
) {
$this->application = $applicationFactory->create();
$this->composer = $this->application->createComposer();
$this->locker = $this->composer->getLocker();
}
/**
* Returns locker data for given package
*
* @param BasePackage
* @return string
*/
private function getLockerData(BasePackage $package)
{
$data = $this->composer->getLocker()->getLockData();
foreach ((array) $data['packages'] as $pkgData) {
if ($pkgData['name'] == $package->getName()) {
return $pkgData;
}
}
return NULL;
}
/**
* 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);
}
/**
* 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());
}
/**
* 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());
}
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);
}
}
private static function generateVersionsClass(Composer $composer) : string
{
return sprintf(self::$generatedClassTemplate, var_export(iterator_to_array(self::getVersions($composer->getLocker(), $composer->getPackage())), true));
}
/**
* 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)
{
// try getting the version from the local repository
$packages = $composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
foreach ($packages as $package) {
if ($package->getName() === self::PACKAGE_NAME) {
$version = $package->getPrettyVersion();
break;
}
}
// let's take a look at the aliases
if ($package->getVersion() === '9999999-dev') {
// this indicates the version alias???
$aliases = $composer->getLocker()->getAliases();
foreach ($aliases as $idx => $alias) {
if ($alias['package'] === self::PACKAGE_NAME) {
return $alias['alias'];
}
}
}
// let's take a look at the root package
if (!empty($version)) {
$version = self::getRequiredVersion($composer->getPackage());
}
// fallback to the hardcoded latest version, if "dev-master" was set
if ($version === 'dev-master') {
return self::getLatestPhantomJsVersion();
}
// 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 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;
}