phalconplus Documentation v1.2.0
Class
Class PhalconPlus Enum

# Sys

        namespace PhalconPlus\Enum;
    use PhalconPlus\Enum\AbstractEnum;
    use PhalconPlus\Base\Exception as BaseException;
    use PhalconPlus\App\App as SuperApp;

    final class Sys extends AbstractEnum
    {
        // 定义类常量
        const COMMON_NAME = "common";
        const CONF_NAME   = "config";
        const LOAD_NAME   = "load";
        const PUB_NAME    = "public";
        const APP_NAME    = "app";

        const DS = DIRECTORY_SEPARATOR;
        const EXT = ".php";
        const ENV_NAME = "phalconplus.env";

        private static rootDir = "";  // without trailing /
        private static primaryModuleDir = ""; // without trailing /
        private static requiredFiles = [];
        private static app = null;

        public static function init(string! moduleDir) -> void
        {
            if !empty(self::primaryModuleDir) {
                return ;
            }
            let moduleDir = rtrim(moduleDir, Sys::DS);
            if !is_dir(moduleDir) {
                throw new BaseException("Module directory not exists or not a dir, file positon: " . moduleDir);
            }
            let self::primaryModuleDir = moduleDir;
            let self::rootDir = dirname(moduleDir);
            // Alias this class for convenience
            // PhalconPlus\Enum\Sys == Ph\Sys
            Sys::classAlias("PhalconPlus\\Enum\Sys", "Ph\\Sys");
        }

        public static function initApp( app) -> void
        {
            if is_null(self::app) {
                let self::app = app;
            }
        }

        public static function app() ->
        {
            return self::app;
        }

        // -> {APP_MODULE_DIR}
        public static function getPrimaryModuleDir() -> string
        {
            return self::primaryModuleDir;
        }

        // -> {APP_ROOT_DIR}
        public static function getRootDir() -> string
        {
            return self::rootDir;
        }

        // -> {APP_ROOT_DIR}/common
        public static function getCommonDir() -> string
        {
            return implode(Sys::DS, [
                self::rootDir,
                Sys::COMMON_NAME
            ]);
        }

        // -> {APP_ROOT_DIR}/common/config
        public static function getGlobalConfigDir() -> string
        {
            return implode(Sys::DS, [
                self::rootDir,
                Sys::COMMON_NAME,
                Sys::CONF_NAME
            ]);
        }

        // -> {APP_ROOT_DIR}/common/config/config.php
        public static function getGlobalConfigPath() -> string
        {
            return implode(Sys::DS, [
                self::rootDir,
                Sys::COMMON_NAME,
                Sys::CONF_NAME,
                Sys::CONF_NAME . Sys::EXT
            ]);
        }

        // -> {APP_ROOT_DIR}/common/load
        public static function getGlobalLoadDir() -> string
        {
            return implode(Sys::DS, [
                self::rootDir,
                Sys::COMMON_NAME,
                Sys::LOAD_NAME
            ]);
        }

        // -> {APP_ROOT_DIR}/{moduleName}
        public static function getModuleDirByName(string moduleName) -> string
        {
            return implode(Sys::DS, [
                self::rootDir,
                moduleName
            ]);
        }

        // foo/bar/baz -> baz
        public static function getModuleNameByDir(string moduleDir) -> string
        {
            return pathinfo(moduleDir, PATHINFO_FILENAME);
        }

        // {moduleDir}/app/{modeName}.php
        public static function getModuleClassPath(string moduleDir, string modeName)
        {
            return implode(Sys::DS, [
                moduleDir,
                Sys::APP_NAME,
                modeName . Sys::EXT
            ]);
        }

        // -> {moduleDir}/app/config/{APP_RUN_ENV | config}.php
        public static function getModuleConfigPath(string moduleDir)
        {
            var confPath = "";
            let confPath = implode(Sys::DS, [
                moduleDir,
                Sys::APP_NAME,
                Sys::CONF_NAME,
                APP_RUN_ENV . Sys::EXT
            ]);
            if !is_file(confPath) {
                let confPath = implode(Sys::DS, [
                    moduleDir,
                    Sys::APP_NAME,
                    Sys::CONF_NAME,
                    Sys::CONF_NAME . Sys::EXT
                ]);
            }
            if !is_file(confPath) {
                throw new BaseException("Module Config file not exists: " . confPath . " & " . APP_RUN_ENV . self::EXT);
            }
            return confPath;
        }

        // -> {APP_ROOT_DIR}/vendor/autoload.php
        public static function getComposerAutoloadPath()
        {
            return implode(Sys::DS, [
                self::rootDir,
                "vendor",
                "autoload.php"
            ]);
        }

        public static function classAlias(string className, string classAlias) -> bool
        {
            %{
                zend_class_entry *ce;
                ce = zephir_fetch_class(&className TSRMLS_CC);
                zend_register_class_alias_ex(Z_STRVAL(classAlias), Z_STRLEN(classAlias), ce);
            }%

            return true;
        }

        public static function load(string filePath, array context = [])
        {
            if unlikely !is_file(filePath) {
                throw new BaseException("The file you try to load is not exists. file position: " . filePath);
            }
            var result;
            if fetch result, self::requiredFiles[filePath] {
                return result;
            }
            var rootPath = "rootPath",
                di       = "di",
                loader   = "loader",
                config   = "config",
                superapp = "superapp";
            // Create a Symbol Table for require directive
            create_symbol_table();
            // ALL variables assigned with "let {zephir-var} = zephir-val"
            // are ONLY visible in required file
            let {rootPath} = Sys::getRootDir();
            if typeof self::app == "object" {
                let {config} = self::app->config();
                if self::app->isBooted() {
                    let {superapp} = self::app;
                    let {di} = self::app->di();
                    let {loader} = self::app->di()->get("loader");
                }
            }
            var name, value;
            for name, value in context {
                let {name} = value;
            }
            /* PHP 7.1 and later version, forbid dynamic calls to scope introspection functions
            extract(["rootPath": APP_ROOT_DIR,
                     "loader": new \Phalcon\Loader(),
                     "config": this->config,
                     "application": this->application,
                     "bootstrap": this,
                     "di": this->di
            ]);
            */
            let result = require filePath;
            let self::requiredFiles[filePath] = result;
            return result;
        }

    }