/**
* Plugin callback for this script event, which calls the previously implemented static method
*
* @param \Composer\Script\Event $event
* @return bool
*/
public function onPostAutoloadDump(\Composer\Script\Event $event)
{
$flags = $event->getFlags();
$config = $event->getComposer()->getConfig();
$optimizeAutoloadFiles = !empty($flags['optimize']) || $config->get('optimize-autoloader') || $config->get('classmap-authoritative');
$aliasMapGenerator = new ClassAliasMapGenerator($event->getComposer(), $event->getIO(), $optimizeAutoloadFiles);
return $aliasMapGenerator->generateAliasMap();
}
/**
* Handle an event callback for an install, update or dump command by
* checking for "merge-plugin" in the "extra" data and merging package
* contents if found.
*
* @param Event $event
*/
public function onInstallUpdateOrDump(Event $event)
{
$this->state->loadSettings();
$this->state->setDevMode($event->isDevMode());
$this->mergeFiles($this->state->getIncludes(), false);
$this->mergeFiles($this->state->getRequires(), true);
if ($event->getName() === ScriptEvents::PRE_AUTOLOAD_DUMP) {
$this->state->setDumpAutoloader(true);
$flags = $event->getFlags();
if (isset($flags['optimize'])) {
$this->state->setOptimizeAutoloader($flags['optimize']);
}
}
}
/**
* Handle an event callback for an install, update or dump command by
* checking for "merge-patterns" in the "extra" data and merging package
* contents if found.
*
* @param Event $event
*/
public function onInstallUpdateOrDump(Event $event)
{
$config = $this->readConfig($this->getRootPackage());
if (isset($config['recurse'])) {
$this->recurse = (bool) $config['recurse'];
}
if ($config['include']) {
$this->loader = new ArrayLoader();
$this->duplicateLinks = array('require' => array(), 'require-dev' => array());
$this->devMode = $event->isDevMode();
$this->mergePackages($config);
}
if ($event->getName() === ScriptEvents::PRE_AUTOLOAD_DUMP) {
$this->dumpAutoloader = true;
$flags = $event->getFlags();
if (isset($flags['optimize'])) {
$this->optimizeAutoloader = $flags['optimize'];
}
}
}
/**
* Instantiate an AbstractTask object.
*
* @since 0.1.0
*
* @param ConfigInterface $config Configuration settings.
* @param Event $event The Composer Event that is being handled.
*
* @throws FailedToProcessConfigException If the configuration could not be processed.
*/
public function __construct(ConfigInterface $config, Event $event)
{
$this->processConfig($config);
$this->event = $event;
$this->name = $event->getName();
$this->arguments = $event->getArguments();
$this->flags = $event->getFlags();
$this->composer = $event->getComposer();
$this->io = $event->getIO();
}
/**
* @param \Composer\Script\Event $event
* @return bool
* @throws \Exception
*/
public static function generateAliasMap(\Composer\Script\Event $event)
{
$composer = $event->getComposer();
$config = $composer->getConfig();
$filesystem = new Filesystem();
$filesystem->ensureDirectoryExists($config->get('vendor-dir'));
$basePath = self::extractBasePath($config);
$vendorPath = $filesystem->normalizePath(realpath($config->get('vendor-dir')));
$targetDir = $vendorPath . '/composer';
$filesystem->ensureDirectoryExists($targetDir);
$mainPackage = $composer->getPackage();
$autoLoadGenerator = $composer->getAutoloadGenerator();
$localRepo = $composer->getRepositoryManager()->getLocalRepository();
$packageMap = $autoLoadGenerator->buildPackageMap($composer->getInstallationManager(), $mainPackage, $localRepo->getCanonicalPackages());
$aliasToClassNameMapping = array();
$classNameToAliasMapping = array();
$classAliasMappingFound = false;
foreach ($packageMap as $item) {
list($package, $installPath) = $item;
$aliasLoaderConfig = self::getAliasLoaderConfigFromPackage($package);
if (!empty($aliasLoaderConfig['class-alias-maps'])) {
if (!is_array($aliasLoaderConfig['class-alias-maps'])) {
throw new \Exception('"class-alias-maps" must be an array');
}
foreach ($aliasLoaderConfig['class-alias-maps'] as $mapFile) {
$mapFilePath = ($installPath ?: $basePath) . '/' . $filesystem->normalizePath($mapFile);
if (is_file($mapFilePath)) {
$packageAliasMap = (require $mapFilePath);
if (!is_array($packageAliasMap)) {
throw new \Exception('"class alias maps" 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 = self::getAliasLoaderConfigFromPackage($mainPackage);
$alwaysAddAliasLoader = $mainPackageAliasLoaderConfig['always-add-alias-loader'];
$caseSensitiveClassLoading = $mainPackageAliasLoaderConfig['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';
$event->getIO()->write('<info>Generating ' . ($classAliasMappingFound ? ' ' : 'empty ') . 'class alias map file</info>');
self::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 helhum/class-alias-loader
class ClassAliasLoaderInit{$suffix} {
private static \$loader;
public static function getAliasLoader(\$composerClassLoader) {
if (null !== self::\$loader) {
return self::\$loader;
}
\$classAliasLoader = new Helhum\\ClassAliasLoader\\ClassAliasLoader(\$composerClassLoader);
self::\$loader = \$classAliasLoader;
Helhum\\ClassAliasLoader\\ClassAliasMap::setClassAliasLoader(\$classAliasLoader);
\$classAliasMap = require __DIR__ . '/autoload_classaliasmap.php';
\$classAliasLoader->setAliasMap(\$classAliasMap);
\$classAliasLoader->setCaseSensitiveClassLoading({$caseSensitiveClassLoadingString});
\$classAliasLoader->register({$prependAutoloader});
return \$composerClassLoader;
}
}
EOF;
file_put_contents($targetDir . '/autoload_alias_loader_real.php', $aliasLoaderInitClassContent);
if (!$caseSensitiveClassLoading) {
$event->getIO()->write('<info>Re-writing class map to support case insensitive class loading</info>');
$flags = $event->getFlags();
$optimize = !empty($flags['optimize']) || $config->get('optimize-autoloader') || $config->get('classmap-authoritative');
if (!$optimize) {
$event->getIO()->write('<warning>Case insensitive class loading only works reliably if you use the optimize class loading feature of composer</warning>');
}
self::rewriteClassMapWithLowerCaseClassNames($targetDir);
}
$event->getIO()->write('<info>Inserting class alias loader into main autoload.php file</info>');
static::modifyMainAutoloadFile($vendorPath . '/autoload.php', $suffix);
return true;
}
/**
* Delegate autoload dump to all the monorepo subdirectories.
*/
public function generateMonorepoAutoloads(Event $event)
{
$flags = $event->getFlags();
$optimize = isset($flags['optimize']) ? $flags['optimize'] : false;
$this->build->build(getcwd(), $optimize, !$event->isDevMode());
}
