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();
}
/**
* @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!');
}
protected function initGingerBackend()
{
$extra = $this->composer->getPackage()->getExtra();
if (!isset($extra['bootstrap'])) {
throw new Exception\RuntimeException('No Bootstrap defined. Please add the -bootstrap- definition to the -extra- property of the Ginger WfMS composer.json');
}
$bootstrapClass = $extra['bootstrap'];
if (!class_exists($bootstrapClass)) {
$this->composer->getAutoloadGenerator()->createLoader($this->composer->getPackage()->getAutoload())->register();
}
$bootstrapClass::init();
$this->serviceManager = $bootstrapClass::getServiceManager();
}
public function activate(Composer $composer, IOInterface $io)
{
// if the autoload.php was already generated use this for autoloading
// else register a new autoloader
$file = $composer->getConfig()->get('vendor-dir') . '/autoload.php';
if (is_file($file)) {
include $file;
} else {
// register class loader to load amun classes
$generator = $composer->getAutoloadGenerator();
$classLoader = $generator->createLoader($composer->getPackage()->getAutoload());
$classLoader->register();
}
// register installer
$installer = new ServiceInstaller($io, $composer);
$composer->getInstallationManager()->addInstaller($installer);
}
/**
* 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());
}
/**
* @return bool
* @throws \Exception
*/
public function generateAliasMap()
{
$config = $this->composer->getConfig();
$filesystem = new Filesystem();
$filesystem->ensureDirectoryExists($config->get('vendor-dir'));
$basePath = $this->extractBasePath($config);
$vendorPath = $filesystem->normalizePath(realpath($config->get('vendor-dir')));
$targetDir = $vendorPath . '/composer';
$filesystem->ensureDirectoryExists($targetDir);
$mainPackage = $this->composer->getPackage();
$autoLoadGenerator = $this->composer->getAutoloadGenerator();
$localRepo = $this->composer->getRepositoryManager()->getLocalRepository();
$packageMap = $autoLoadGenerator->buildPackageMap($this->composer->getInstallationManager(), $mainPackage, $localRepo->getCanonicalPackages());
$aliasToClassNameMapping = array();
$classNameToAliasMapping = array();
$classAliasMappingFound = false;
foreach ($packageMap as $item) {
/** @var PackageInterface $package */
list($package, $installPath) = $item;
$aliasLoaderConfig = new \TYPO3\ClassAliasLoader\Config($package, $this->IO);
if ($aliasLoaderConfig->get('class-alias-maps') !== null) {
if (!is_array($aliasLoaderConfig->get('class-alias-maps'))) {
throw new \Exception('Configuration option "class-alias-maps" must be an array');
}
foreach ($aliasLoaderConfig->get('class-alias-maps') as $mapFile) {
$mapFilePath = ($installPath ?: $basePath) . '/' . $filesystem->normalizePath($mapFile);
if (!is_file($mapFilePath)) {
$this->IO->writeError(sprintf('The class alias map file "%s" configured in package "%s" was not found!', $mapFile, $package->getName()));
} else {
$packageAliasMap = (require $mapFilePath);
if (!is_array($packageAliasMap)) {
throw new \Exception('Class alias map files must return an array', 1422625075);
}
if (!empty($packageAliasMap)) {
$classAliasMappingFound = true;
}
foreach ($packageAliasMap as $aliasClassName => $className) {
$lowerCasedAliasClassName = strtolower($aliasClassName);
$aliasToClassNameMapping[$lowerCasedAliasClassName] = $className;
$classNameToAliasMapping[$className][$lowerCasedAliasClassName] = $lowerCasedAliasClassName;
}
}
}
}
}
$mainPackageAliasLoaderConfig = new \TYPO3\ClassAliasLoader\Config($mainPackage);
$alwaysAddAliasLoader = $mainPackageAliasLoaderConfig->get('always-add-alias-loader');
$caseSensitiveClassLoading = $mainPackageAliasLoaderConfig->get('autoload-case-sensitivity');
if (!$alwaysAddAliasLoader && !$classAliasMappingFound && $caseSensitiveClassLoading) {
// No mapping found in any package and no insensitive class loading active. We return early and skip rewriting
// Unless user configured alias loader to be always added
return false;
}
$caseSensitiveClassLoadingString = $caseSensitiveClassLoading ? 'true' : 'false';
$this->IO->write('<info>Generating ' . ($classAliasMappingFound ? ' ' : 'empty ') . 'class alias map file</info>');
$this->generateAliasMapFile($aliasToClassNameMapping, $classNameToAliasMapping, $targetDir);
$suffix = null;
if (!$config->get('autoloader-suffix') && is_readable($vendorPath . '/autoload.php')) {
$content = file_get_contents($vendorPath . '/autoload.php');
if (preg_match('{ComposerAutoloaderInit([^:\\s]+)::}', $content, $match)) {
$suffix = $match[1];
}
}
if (!$suffix) {
$suffix = $config->get('autoloader-suffix') ?: md5(uniqid('', true));
}
$prependAutoloader = $config->get('prepend-autoloader') === false ? 'false' : 'true';
$aliasLoaderInitClassContent = <<<EOF
<?php
// autoload_alias_loader_real.php @generated by typo3/class-alias-loader
class ClassAliasLoaderInit{$suffix} {
private static \$loader;
public static function initializeClassAliasLoader(\$composerClassLoader) {
if (null !== self::\$loader) {
return self::\$loader;
}
self::\$loader = \$composerClassLoader;
\$classAliasMap = require __DIR__ . '/autoload_classaliasmap.php';
\$classAliasLoader = new TYPO3\\ClassAliasLoader\\ClassAliasLoader(\$composerClassLoader);
\$classAliasLoader->setAliasMap(\$classAliasMap);
\$classAliasLoader->setCaseSensitiveClassLoading({$caseSensitiveClassLoadingString});
\$classAliasLoader->register({$prependAutoloader});
TYPO3\\ClassAliasLoader\\ClassAliasMap::setClassAliasLoader(\$classAliasLoader);
return self::\$loader;
}
}
EOF;
file_put_contents($targetDir . '/autoload_alias_loader_real.php', $aliasLoaderInitClassContent);
if (!$caseSensitiveClassLoading) {
$this->IO->write('<info>Re-writing class map to support case insensitive class loading</info>');
if (!$this->optimizeAutoloadFiles) {
$this->IO->write('<warning>Case insensitive class loading only works reliably if you use the optimize class loading feature of composer</warning>');
}
$this->rewriteClassMapWithLowerCaseClassNames($targetDir);
}
$this->IO->write('<info>Inserting class alias loader into main autoload.php file</info>');
$this->modifyMainAutoloadFile($vendorPath . '/autoload.php', $suffix);
return true;
}
/**
* @param Composer $composer
*
* @return void
*/
private static function reDumpAutoloader(Composer $composer)
{
$composer->getAutoloadGenerator()->dump($composer->getConfig(), $composer->getRepositoryManager()->getLocalRepository(), $composer->getPackage(), $composer->getInstallationManager(), 'composer', true);
}
