ClassAliasLoader.php

Go to the documentation of this file.

<?php
namespace TYPO3\ClassAliasLoader;

/*
 * This file is part of the class alias loader package.
 *
 * (c) Helmut Hummel <info@helhum.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

use Composer\Autoload\ClassLoader as ComposerClassLoader;

class ClassAliasLoader
{
    protected $composerClassLoader;

    protected $aliasMap = array(
        'aliasToClassNameMapping' => array(),
        'classNameToAliasMapping' => array()
    );

    protected $caseSensitiveClassLoading = true;

    public function __construct(ComposerClassLoader $composerClassLoader)
    {
        $this->composerClassLoader = $composerClassLoader;
    }

    public function setAliasMap(array $aliasMap)
    {
        $this->aliasMap = $aliasMap;
    }

    public function setCaseSensitiveClassLoading($caseSensitiveClassLoading)
    {
        $this->caseSensitiveClassLoading = $caseSensitiveClassLoading;
    }

    public function addAliasMap(array $aliasMap)
    {
        foreach ($aliasMap['aliasToClassNameMapping'] as $alias => $originalClassName) {
            $lowerCaseAlias = strtolower($alias);
            $this->aliasMap['aliasToClassNameMapping'][$lowerCaseAlias] = $originalClassName;
            $this->aliasMap['classNameToAliasMapping'][$originalClassName][$lowerCaseAlias] = $lowerCaseAlias;
        }
    }

    public function getClassNameForAlias($aliasOrClassName)
    {
        $lookUpClassName = strtolower($aliasOrClassName);

        return isset($this->aliasMap['aliasToClassNameMapping'][$lookUpClassName]) ? $this->aliasMap['aliasToClassNameMapping'][$lookUpClassName] : $aliasOrClassName;
    }

    public function register($prepend = false)
    {
        $this->composerClassLoader->unregister();
        spl_autoload_register(array($this, 'loadClassWithAlias'), true, $prepend);
    }

    public function unregister()
    {
        spl_autoload_unregister(array($this, 'loadClassWithAlias'));
    }

    public function loadClassWithAlias($className)
    {
        $originalClassName = $this->getOriginalClassName($className);
        return $originalClassName ? $this->loadOriginalClassAndSetAliases($originalClassName) : $this->loadClass($className);
    }

    public function loadClass($className) {
        $classFound = $this->composerClassLoader->loadClass($className);
        if (!$classFound && !$this->caseSensitiveClassLoading) {
            $classFound = $this->composerClassLoader->loadClass(strtolower($className));
        }
        return $classFound;
    }

    protected function getOriginalClassName($aliasOrClassName)
    {
        // Is an original class which has an alias
        if (array_key_exists($aliasOrClassName, $this->aliasMap['classNameToAliasMapping'])) {
            return $aliasOrClassName;
        }

        // Is an alias (we're graceful regarding casing for alias definitions)
        $lowerCasedClassName = strtolower($aliasOrClassName);
        if (array_key_exists($lowerCasedClassName, $this->aliasMap['aliasToClassNameMapping'])) {
            return $this->aliasMap['aliasToClassNameMapping'][$lowerCasedClassName];
        }
        // No alias registered for this class name, return and remember that info
        return $this->aliasMap['classNameToAliasMapping'][$aliasOrClassName] = NULL;
    }

    protected function loadOriginalClassAndSetAliases($originalClassName)
    {
        if ($this->classOrInterfaceExists($originalClassName) || $this->loadClass($originalClassName)) {
            foreach ($this->aliasMap['classNameToAliasMapping'][$originalClassName] as $aliasClassName) {
                if (!$this->classOrInterfaceExists($aliasClassName)) {
                    class_alias($originalClassName, $aliasClassName);
                }
            }

            return true;
        }

        return null;
    }

    protected function classOrInterfaceExists($className)
    {
        return class_exists($className, false) || interface_exists($className, false);
    }

    public function __call($method, $arguments)
    {
        if (!is_callable(array($this->composerClassLoader, $method))) {
            throw new \InvalidArgumentException(sprintf('Method "%s" does not exist!', $method), 1422631610);
        }

        return call_user_func_array(array($this->composerClassLoader, $method), $arguments);
    }

}