WP Theme Bootstrap

<?PHP
    NAMESPACE tri4m\Wp;
    USE tri4m\Wp\Theme\Application;
    USE tri4m\Wp\Theme\Hook;
    USE tri4m\Wp\Theme\Trace;
    USE tri4m\Wp\Theme\Wp;
    USE ILLI\Core\Std\Def;
    USE ILLI\Core\Std\Def\__const_Type;
    USE ILLI\Core\Std\Exception;
    USE ILLI\Core\Std\Invoke;
    USE ILLI\Core\Std\Throwable;
    USE ILLI\Core\Util\Inflector;
    USE ILLI\Core\Util\String;

    CLASS Theme
    {
        protected static $__running     = FALSE;
        protected static $__config      = [];
        protected static $__themePath       = NULL;
        protected static $__themeUri        = NULL;
        protected static $__wpIncludePath   = NULL;
        protected static $__wpIncludeUri    = NULL;
        protected static $__slug        = NULL;
        protected static $__name        = NULL;
        protected static $__fullName        = NULL;
        protected static $__version     = NULL;
        protected static $__versionID       = NULL;
        protected static $__debug       = NULL;
        protected static $__Hook        = NULL;
        protected static $__pathScheme      =
        [
            // theme base path
            'root'      => '{:root}',
            'core'      => '{:root}/core',
            'coreInc'   => '{:root}/core/inc/{:class}/{:method}/{:file}.php',

            // core lib contains 3rd party stuff
            'coreLib'   => '{:root}/core/lib',
            'coreJs'    => '{:root}/core/lib/js',
            'coreCss'   => '{:root}/core/lib/css',
            'coreImg'   => '{:root}/core/lib/img',
            'coreIetf'  => '{:root}/core/lib/ietf',
            'corePie'   => '{:root}/core/lib/pie',
            'api'       => '{:root}/core/api',
            'apiScheme' => '{:root}/core/api/{:class}/{:method}/{:slug}/{:file}.xml',

            // std contains fallbacks for user replacable files
            'std'       => '{:root}/core/std',
            'stdLib'    => '{:root}/core/std/lib',
            'stdImg'    => '{:root}/core/std/lib/img',

            // wordpress includes
            'wp'        => '{:wp}',
            'wpJs'      => '{:wp}/js',
            'wpCss'     => '{:wp}/css'
        ];

        public function __construct(array $__config)
        {
            Throwable::run();

            if(TRUE === static::$__running)
            {
                if(TRUE === Theme::isDebug())
                    Trace::add(__METHOD__.': bypass');
                return;
            }

            $__config +=
            [
                'debug'     => FALSE,
                'versionID' => 0,
                'version'   => '0',
            ];

            static::$__running  = TRUE;
            static::$__config   = &$__config;
            static::$__Hook     = new Hook;


            try
            {
                $_ =
                [
                    Def::v(__const_Type::SPL_BOOLEAN),
                    Def::v(__const_Type::SPL_STRING),
                    Def::v(__const_Type::SPL_DIRECTORY),
                    Def::v(__const_Type::SPL_INTEGER),
                ];

                foreach(['slug', 'name', 'fullName', 'version', 'versionID', 'themePath', 'themeUri', 'wpIncludePath', 'wpIncludeUri', 'debug'] as $config)
                {
                    if(!isset($__config[$config]))
                        throw new Exception(String::insert('Missing configuration {:config}.', compact('config')));

                    switch($config):
                        case 'themePath':
                        case 'wpIncludePath':
                            $__config[$config] = '/'.trim(rtrim($__config[$config], '/'), '/');
                            break;
                        case 'themeUri':
                        case 'wpIncludeUri':
                            $__config[$config] = trim(rtrim($__config[$config], '/'), '/');
                            break;
                    endswitch;

                    if(TRUE === Theme::isDebug())
                        Trace::add(__METHOD__.': '.$config.': '.$__config[$config]);

                    try
                    {
                        switch($config):
                            case 'debug':
                                $_[0]->set($__config[$config]);
                                break;
                            case 'slug':
                            case 'name':
                            case 'fullName':
                            case 'version':
                            case 'themeUri':
                            case 'wpIncludeUri':
                                $_[1]->set($__config[$config]);
                                break;
                            case 'themePath':
                            case 'wpIncludePath':
                                $_[2]->set($__config[$config]);
                                break;
                            case 'versionID':
                                $_[3]->set($__config[$config]);
                                break;
                        endswitch;
                    }
                    catch(Exception $E)
                    {
                        throw new Exception('Illegal type for {:config} detected.', compact('config'), $E);
                    }

                    static::${'__'.$config} = $__config[$config];

                    unset($__config[$config]);
                }

                unset($_);
            }
            catch(\Exception $E)
            {
                throw new Exception('Theme Config Error', $E);
            }

            /*
                - current event: Application::boot()
                - after_setup_theme:
                    - Application::run()
                    - dequeue Actions
                    - dequeue Filters
                    - dequeue Callables
                    - register shutdown showTrace()
            */
            try
            {
                try
                {
                    Application::boot();
                }
                catch(\Exception $E)
                {
                    throw new Exception('Boot Exec Error', $E);
                }

                try
                {
                    Wp::addAction(Hook::ACTION_AFTER_SETUP_THEME, function()
                    {
                        try
                        {
                            Application::run();
                        }
                        catch(\Exception $E)
                        {
                            Theme::e('Run Exec Error', $E);
                        }

                        try
                        {
                            Hook::dequeueFilters();
                            Hook::dequeueActions();
                            Hook::dequeueCallables();
                        }
                        catch(\Exception $E)
                        {
                            Theme::e('Hook Dequeue Error', $E);
                        }

                        try
                        {
                            Wp::addAction(Hook::ACTION_SHUTDOWN, function()
                            {
                                if(FALSE === static::$__debug)
                                    return;

                                print static::showTrace();
                            });
                        }
                        catch(\Exception $E)
                        {
                            Theme::e('Registration Hook::ACTION_SHUTDOWN Error', $E);
                        }

                    });
                }
                catch(\Exception $E)
                {
                    throw new Exception('Registration Hook::ACTION_AFTER_SETUP_THEME Error', $E);
                }

            }
            catch(\Exception $E)
            {
                throw new Exception('Theme Application Error', $E);
            }

            Throwable::stop();
        }

        static function __callStatic($__name, $__args)
        {
            $r = explode('_', $n = Inflector::underscore($__name));

            switch($prefix = $r[0]):
                case 'path':
                case 'uri':
                    array_shift($r);

                    return isset(static::$__pathScheme[$r = lcfirst(Inflector::camelize(implode('_', $r)))])
                        ? String::insert(static::$__pathScheme[$r], [
                            'root'  => static::${'__theme'.('uri' === $prefix ? 'Uri' : 'Path')},
                            'wp'    => static::${'__wpInclude'.('uri' === $prefix ? 'Uri' : 'Path')}])
                            .(([] !== $__args) ? '/'.trim(rtrim(implode('/', $__args), '/'), '/') : '')
                        : NULL;
            endswitch;
        }

        static function slug($__value = NULL)
        {
            return NULL === $__value
                ? static::$__slug
                : static::$__slug.'_'.$__value;
        }

        static function name()
        {
            return static::$__name;
        }

        static function fullname()
        {
            return static::$__fullname;
        }

        static function version()
        {
            return static::$__version;
        }

        static function versionID()
        {
            return static::$__versionID;
        }

        static function isDebug()
        {
            return static::$__debug;
        }

        static function config($__key = NULL, $__value = NULL)
        {
            if(TRUE === is_scalar($__key)
            && NULL !== $key)
                static::$__config[$__key] = $__value;

            return static::$__config;
        }

        static function showTrace()
        {
            return '<pre class="log">'.(new Trace).'</pre>';
        }

        /**
         * handle exceptions thrown in closures.
         * create throwable instance and forward track to wp_die()
         */
        static function e()
        {
            $T = Invoke::emitClass('ILLI\Core\Std\Exception', func_get_args());

            $m = '<pre class="error">'.$T->toTrack()->asText().'</pre>';
            $t = '<pre class="log">'.(new Trace).'</pre>';

            Throwable::stop();
            Wp::wpDie($m.$t);
        }
    }