/** * 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()); }