ClassLoadingInformation.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Core;
 
use Composer\Autoload\ClassLoader;
use TYPO3\ClassAliasLoader\ClassAliasMap;
use ‪TYPO3\CMS\Core\Package\Event\AfterPackageActivationEvent;
use ‪TYPO3\CMS\Core\Package\Event\AfterPackageDeactivationEvent;
use ‪TYPO3\CMS\Core\Package\PackageInterface;
use TYPO3\CMS\Core\Package\PackageManager;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪ClassLoadingInformation
{
    public const ‪AUTOLOAD_INFO_DIR = 'autoload/';
 
    public const ‪AUTOLOAD_INFO_DIR_TESTS = 'autoload-tests/';
 
    public const ‪AUTOLOAD_CLASSMAP_FILENAME = 'autoload_classmap.php';
 
    public const ‪AUTOLOAD_PSR4_FILENAME = 'autoload_psr4.php';
 
    public const ‪AUTOLOAD_CLASSALIASMAP_FILENAME = 'autoload_classaliasmap.php';
 
    protected static ‪$classLoader;
 
    public static function ‪setClassLoader(ClassLoader ‪$classLoader)
    {
        static::$classLoader = ‪$classLoader;
    }
 
    public static function ‪isClassLoadingInformationAvailable()
    {
        return file_exists(self::getClassLoadingInformationDirectory() . self::AUTOLOAD_CLASSMAP_FILENAME);
    }
 
    public static function ‪dumpClassLoadingInformation()
    {
        ‪self::ensureAutoloadInfoDirExists();
        $composerClassLoader = static::getClassLoader();
        $activeExtensionPackages = static::getActiveExtensionPackages();
 
        $generator = GeneralUtility::makeInstance(ClassLoadingInformationGenerator::class, $composerClassLoader, $activeExtensionPackages, ‪Environment::getPublicPath() . '/', self::isTestingContext());
        $classInfoFiles = $generator->buildAutoloadInformationFiles();
        ‪GeneralUtility::writeFile(self::getClassLoadingInformationDirectory() . self::AUTOLOAD_CLASSMAP_FILENAME, $classInfoFiles['classMapFile']);
        ‪GeneralUtility::writeFile(self::getClassLoadingInformationDirectory() . self::AUTOLOAD_PSR4_FILENAME, $classInfoFiles['psr-4File']);
 
        $classAliasMapFile = $generator->buildClassAliasMapFile();
        ‪GeneralUtility::writeFile(self::getClassLoadingInformationDirectory() . self::AUTOLOAD_CLASSALIASMAP_FILENAME, $classAliasMapFile);
    }
 
    public static function ‪updateClassLoadingInformationAfterPackageDeactivation(AfterPackageDeactivationEvent $event): void
    {
        if (‪Environment::isComposerMode()) {
            return;
        }
        static::dumpClassLoadingInformation();
    }
 
    public static function ‪updateClassLoadingInformationAfterPackageActivation(AfterPackageActivationEvent $event): void
    {
        if (‪Environment::isComposerMode()) {
            return;
        }
        static::dumpClassLoadingInformation();
    }
 
    public static function ‪registerClassLoadingInformation()
    {
        $composerClassLoader = static::getClassLoader();
 
        $dynamicClassAliasMapFile = ‪self::getClassLoadingInformationDirectory() . ‪self::AUTOLOAD_CLASSALIASMAP_FILENAME;
        if (file_exists($dynamicClassAliasMapFile)) {
            $classAliasMap = require $dynamicClassAliasMapFile;
            if (is_array($classAliasMap) && !empty($classAliasMap['aliasToClassNameMapping']) && !empty($classAliasMap['classNameToAliasMapping'])) {
                ClassAliasMap::addAliasMap($classAliasMap);
            }
        }
 
        $dynamicClassMapFile = ‪self::getClassLoadingInformationDirectory() . ‪self::AUTOLOAD_CLASSMAP_FILENAME;
        if (file_exists($dynamicClassMapFile)) {
            $classMap = require $dynamicClassMapFile;
            if (!empty($classMap) && is_array($classMap)) {
                $composerClassLoader->addClassMap($classMap);
            }
        }
 
        $dynamicPsr4File = ‪self::getClassLoadingInformationDirectory() . ‪self::AUTOLOAD_PSR4_FILENAME;
        if (file_exists($dynamicPsr4File)) {
            $psr4 = require $dynamicPsr4File;
            if (is_array($psr4)) {
                foreach ($psr4 as $prefix => $paths) {
                    $composerClassLoader->setPsr4($prefix, $paths);
                }
            }
        }
    }
 
    public static function ‪registerTransientClassLoadingInformationForPackage(PackageInterface $package)
    {
        $composerClassLoader = static::getClassLoader();
        $activeExtensionPackages = static::getActiveExtensionPackages();
 
        $generator = GeneralUtility::makeInstance(ClassLoadingInformationGenerator::class, $composerClassLoader, $activeExtensionPackages, ‪Environment::getPublicPath() . '/', self::isTestingContext());
 
        $classInformation = $generator->buildClassLoadingInformationForPackage($package);
        $composerClassLoader->addClassMap($classInformation['classMap']);
        foreach ($classInformation['psr-4'] as $prefix => $paths) {
            $composerClassLoader->setPsr4($prefix, $paths);
        }
        $classAliasMap = $generator->buildClassAliasMapForPackage($package);
        if (is_array($classAliasMap) && !empty($classAliasMap['aliasToClassNameMapping']) && !empty($classAliasMap['classNameToAliasMapping'])) {
            ClassAliasMap::addAliasMap($classAliasMap);
        }
    }
 
    protected static function ‪getClassLoadingInformationDirectory()
    {
        if (self::isTestingContext()) {
            return ‪Environment::getLegacyConfigPath() . '/' . ‪self::AUTOLOAD_INFO_DIR_TESTS;
        }
        return ‪Environment::getLegacyConfigPath() . '/' . ‪self::AUTOLOAD_INFO_DIR;
    }
 
    public static function ‪getClassNameForAlias($alias)
    {
        return ClassAliasMap::getClassNameForAlias($alias);
    }
 
    protected static function ‪ensureAutoloadInfoDirExists()
    {
        $autoloadInfoDir = ‪self::getClassLoadingInformationDirectory();
        if (!file_exists($autoloadInfoDir)) {
            ‪GeneralUtility::mkdir_deep($autoloadInfoDir);
        }
    }
 
    public static function ‪getClassLoader()
    {
        return static::$classLoader;
    }
 
    protected static function ‪isTestingContext()
    {
        return ‪Environment::getContext()->‪isTesting();
    }
 
    protected static function ‪getActiveExtensionPackages()
    {
        $activeExtensionPackages = [];
        $packageManager = GeneralUtility::makeInstance(PackageManager::class);
        foreach ($packageManager->getActivePackages() as $package) {
            if ($package->getPackageMetaData()->isFrameworkType()) {
                // Skip all core packages as the class loading info is prepared for them already
                continue;
            }
            $activeExtensionPackages[] = $package;
        }
        return $activeExtensionPackages;
    }
}