loader.php

<?php
 
namespace Bitrix\Main;
 
use Bitrix\Main\DI\ServiceLocator;
 
class Loader
{
    const SAFE_MODE = false;
 
    const BITRIX_HOLDER = "bitrix";
    const LOCAL_HOLDER = "local";
 
    protected static $safeModeModules = ["main" => true, "fileman" => true];
    protected static $loadedModules = ["main" => true];
    protected static $semiloadedModules = [];
    protected static $modulesHolders = ["main" => self::BITRIX_HOLDER];
    protected static $sharewareModules = [];
 
    protected static $namespaces = [];
 
    const MODULE_NOT_FOUND = 0;
    const MODULE_INSTALLED = 1;
    const MODULE_DEMO = 2;
    const MODULE_DEMO_EXPIRED = 3;
 
    protected static $autoLoadClasses = [];
 
    protected static $requireThrowException = true;
 
    const ALPHA_LOWER = "qwertyuioplkjhgfdsazxcvbnm";
    const ALPHA_UPPER = "QWERTYUIOPLKJHGFDSAZXCVBNM";
 
    public static function includeModule($moduleName)
    {
        if (!is_string($moduleName) || $moduleName == "")
        {
            throw new LoaderException("Empty module name");
        }
        if (preg_match("#[^a-zA-Z0-9._]#", $moduleName))
        {
            throw new LoaderException(sprintf("Module name '%s' is not correct", $moduleName));
        }
 
        $moduleName = strtolower($moduleName);
 
        if (self::SAFE_MODE)
        {
            if (!isset(self::$safeModeModules[$moduleName]))
            {
                return false;
            }
        }
 
        if (isset(self::$loadedModules[$moduleName]))
        {
            return self::$loadedModules[$moduleName];
        }
 
        if (isset(self::$semiloadedModules[$moduleName]))
        {
            trigger_error("Module '".$moduleName."' is in loading progress", E_USER_WARNING);
        }
 
        $arInstalledModules = ModuleManager::getInstalledModules();
        if (!isset($arInstalledModules[$moduleName]))
        {
            return (self::$loadedModules[$moduleName] = false);
        }
 
        $documentRoot = self::getDocumentRoot();
 
        $moduleHolder = self::LOCAL_HOLDER;
        $pathToInclude = $documentRoot."/".$moduleHolder."/modules/".$moduleName;
        if (!file_exists($pathToInclude))
        {
            $moduleHolder = self::BITRIX_HOLDER;
            $pathToInclude = $documentRoot."/".$moduleHolder."/modules/".$moduleName;
            if (!file_exists($pathToInclude))
            {
                return (self::$loadedModules[$moduleName] = false);
            }
        }
 
        //register a PSR-4 base folder for the module
        if (strpos($moduleName, ".") !== false)
        {
            //partner's module
            $baseName = str_replace(".", "\\", ucwords($moduleName, "."));
        }
        else
        {
            //bitrix's module
            $baseName = "Bitrix\\".ucfirst($moduleName);
        }
        self::registerNamespace($baseName, $documentRoot."/".$moduleHolder."/modules/".$moduleName."/lib");
 
        self::$modulesHolders[$moduleName] = $moduleHolder;
 
        if (class_exists('\Dev\Main\Migrator\ModuleUpdater'))
        {
            \Dev\Main\Migrator\ModuleUpdater::checkUpdates($moduleName, $pathToInclude);
        }
 
        $res = true;
        if (file_exists($pathToInclude."/include.php"))
        {
            //recursion control
            self::$semiloadedModules[$moduleName] = true;
 
            $res = self::includeModuleInternal($pathToInclude."/include.php");
 
            unset(self::$semiloadedModules[$moduleName]);
        }
 
        self::$loadedModules[$moduleName] = ($res !== false);
 
        if (!self::$loadedModules[$moduleName])
        {
            //unregister the namespace if "include" fails
            self::unregisterNamespace($baseName);
        }
        else
        {
            ServiceLocator::getInstance()->registerByModuleSettings($moduleName);
        }
 
        return self::$loadedModules[$moduleName];
    }
 
    public static function requireModule($moduleName)
    {
        $included = self::includeModule($moduleName);
 
        if (!$included && self::$requireThrowException)
        {
            throw new LoaderException("Required module `{$moduleName}` was not found");
        }
 
        return $included;
    }
 
    private static function includeModuleInternal($path)
    {
        global $DB, $MESS;
        return include_once($path);
    }
 
    public static function includeSharewareModule($moduleName)
    {
        if (isset(self::$sharewareModules[$moduleName]))
        {
            return self::$sharewareModules[$moduleName];
        }
 
        $module = str_replace(".", "_", $moduleName);
 
        if (self::includeModule($moduleName))
        {
            if (defined($module."_DEMO") && constant($module."_DEMO") == "Y")
            {
                self::$sharewareModules[$moduleName] = self::MODULE_DEMO;
            }
            else
            {
                self::$sharewareModules[$moduleName] = self::MODULE_INSTALLED;
            }
 
            return self::$sharewareModules[$moduleName];
        }
 
        if (defined($module."_DEMO") && constant($module."_DEMO") == "Y")
        {
            return (self::$sharewareModules[$moduleName] = self::MODULE_DEMO_EXPIRED);
        }
 
        return (self::$sharewareModules[$moduleName] = self::MODULE_NOT_FOUND);
    }
 
    public static function clearModuleCache($moduleName)
    {
        if (!is_string($moduleName) || $moduleName == "")
        {
            throw new LoaderException("Empty module name");
        }
 
        if ($moduleName !== "main")
        {
            unset(self::$loadedModules[$moduleName]);
            unset(self::$modulesHolders[$moduleName]);
        }
 
        unset(self::$sharewareModules[$moduleName]);
    }
 
    public static function getDocumentRoot()
    {
        static $documentRoot = null;
        if ($documentRoot === null)
        {
            $documentRoot = rtrim($_SERVER["DOCUMENT_ROOT"], "/\\");
        }
        return $documentRoot;
    }
 
    public static function registerAutoLoadClasses($moduleName, array $classes)
    {
        if (empty($classes))
        {
            return;
        }
        if (($moduleName !== null) && empty($moduleName))
        {
            throw new LoaderException(sprintf("Module name '%s' is not correct", $moduleName));
        }
 
        foreach ($classes as $class => $file)
        {
            $class = ltrim($class, "\\");
            $class = strtolower($class);
 
            self::$autoLoadClasses[$class] = [
                "module" => $moduleName,
                "file" => $file,
            ];
        }
    }
 
    public static function registerNamespace($namespace, $path)
    {
        $namespace = trim($namespace, "\\")."\\";
        $namespace = strtolower($namespace);
 
        $path = rtrim($path, "/\\");
        $depth = substr_count(rtrim($namespace, "\\"), "\\");
 
        self::$namespaces[$namespace][] = [
            "path" => $path,
            "depth" => $depth,
        ];
    }
 
    public static function unregisterNamespace($namespace)
    {
        $namespace = trim($namespace, "\\")."\\";
        $namespace = strtolower($namespace);
 
        unset(self::$namespaces[$namespace]);
    }
 
    public static function registerHandler(callable $handler)
    {
        \spl_autoload_register($handler);
    }
 
    public static function autoLoad($className)
    {
        // fix web env
        $className = ltrim($className, "\\");
 
        $classLower = strtolower($className);
 
        static $documentRoot = null;
        if ($documentRoot === null)
        {
            $documentRoot = self::getDocumentRoot();
        }
 
        //optimization via direct paths
        if (isset(self::$autoLoadClasses[$classLower]))
        {
            $pathInfo = self::$autoLoadClasses[$classLower];
            if ($pathInfo["module"] != "")
            {
                $module = $pathInfo["module"];
                $holder = (self::$modulesHolders[$module] ?? self::BITRIX_HOLDER);
 
                $filePath = (defined('REPOSITORY_ROOT') && $holder === self::BITRIX_HOLDER)
                    ? REPOSITORY_ROOT
                    : "{$documentRoot}/{$holder}/modules";
 
                $filePath .= '/'.$module."/".$pathInfo["file"];
 
                require_once($filePath);
            }
            else
            {
                require_once($documentRoot.$pathInfo["file"]);
            }
            return;
        }
 
        if (preg_match("#[^\\\\/a-zA-Z0-9_]#", $className))
        {
            return;
        }
 
        $tryFiles = [[
            "real" => $className,
            "lower" => $classLower,
        ]];
 
        if (substr($classLower, -5) == "table")
        {
            // old *Table stored in reserved files
            $tryFiles[] = [
                "real" => substr($className, 0, -5),
                "lower" => substr($classLower, 0, -5),
            ];
        }
 
        foreach ($tryFiles as $classInfo)
        {
            $classParts = explode("\\", $classInfo["lower"]);
 
            //remove class name
            array_pop($classParts);
 
            while (!empty($classParts))
            {
                //go from the end
                $namespace = implode("\\", $classParts)."\\";
 
                if (isset(self::$namespaces[$namespace]))
                {
                    //found
                    foreach (self::$namespaces[$namespace] as $namespaceLocation)
                    {
                        $depth = $namespaceLocation["depth"];
                        $path = $namespaceLocation["path"];
 
                        $fileParts = explode("\\", $classInfo["real"]);
 
                        for ($i=0; $i <= $depth; $i++)
                        {
                            array_shift($fileParts);
                        }
 
                        $classPath = implode("/", $fileParts);
 
                        $classPathLower = strtolower($classPath);
 
                        // final path lower case
                        $filePath = $path.'/'.$classPathLower.".php";
 
                        if (file_exists($filePath))
                        {
                            require_once($filePath);
                            break 3;
                        }
 
                        // final path original case
                        $filePath = $path.'/'.$classPath.".php";
 
                        if (file_exists($filePath))
                        {
                            require_once($filePath);
                            break 3;
                        }
                    }
                }
 
                //try the shorter namespace
                array_pop($classParts);
            }
        }
    }
 
    public static function requireClass($className)
    {
        $file = ltrim($className, "\\");    // fix web env
        $file = strtolower($file);
 
        if (preg_match("#[^\\\\/a-zA-Z0-9_]#", $file))
            return;
 
        $tryFiles = [$file];
 
        if (substr($file, -5) == "table")
        {
            // old *Table stored in reserved files
            $tryFiles[] = substr($file, 0, -5);
        }
 
        foreach ($tryFiles as $file)
        {
            $file = str_replace('\\', '/', $file);
            $arFile = explode("/", $file);
 
            if ($arFile[0] === "bitrix")
            {
                array_shift($arFile);
 
                if (empty($arFile))
                {
                    break;
                }
 
                $module = array_shift($arFile);
                if ($module == null || empty($arFile))
                {
                    break;
                }
            }
            else
            {
                $module1 = array_shift($arFile);
                $module2 = array_shift($arFile);
 
                if ($module1 == null || $module2 == null || empty($arFile))
                {
                    break;
                }
 
                $module = $module1.".".$module2;
            }
 
            if (!self::includeModule($module))
            {
                throw new LoaderException(sprintf(
                    "There is no `%s` class, module `%s` is unavailable", $className, $module
                ));
            }
        }
 
        self::autoLoad($className);
    }
 
    public static function getLocal($path, $root = null)
    {
        if ($root === null)
        {
            $root = self::getDocumentRoot();
        }
 
        if (file_exists($root."/local/".$path))
        {
            return $root."/local/".$path;
        }
        elseif (file_exists($root."/bitrix/".$path))
        {
            return $root."/bitrix/".$path;
        }
        else
        {
            return false;
        }
    }
 
    public static function getPersonal($path)
    {
        $root = self::getDocumentRoot();
        $personal = ($_SERVER["BX_PERSONAL_ROOT"] ?? "");
 
        if ($personal <> '' && file_exists($root.$personal."/".$path))
        {
            return $root.$personal."/".$path;
        }
 
        return self::getLocal($path, $root);
    }
 
    public static function setRequireThrowException($requireThrowException)
    {
        self::$requireThrowException = (bool) $requireThrowException;
    }
}
 
class LoaderException extends \Exception
{
    public function __construct($message = "", $code = 0, \Exception $previous = null)
    {
        parent::__construct($message, $code, $previous);
    }
}