BEAR\Package\AppInjector

Complexity

Total Complexity

16

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	23	6
A	getInstance()	0	4	1
A	getOverrideInstance()	0	7	1
A	clear()	0	8	3
A	getCachedInstance()	0	15	3
A	getModule()	0	14	2

<?php
/**
 * This file is part of the BEAR.Package package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace BEAR\Package;

use BEAR\AppMeta\AbstractAppMeta;
use BEAR\AppMeta\Meta;
use Doctrine\Common\Cache\FilesystemCache;
use josegonzalez\Dotenv\Loader;
use Ray\Compiler\ScriptInjector;
use Ray\Di\AbstractModule;
use Ray\Di\Bind;
use Ray\Di\Injector;
use Ray\Di\InjectorInterface;
use Ray\Di\Name;

final class AppInjector implements InjectorInterface
{
    /**
     * @var AbstractAppMeta
     */
    private $appMeta;

    /**
     * @var string
     */
    private $context;

    /**
     * @var string
     */
    private $scriptDir;

    /**
     * @var string
     */
    private $appDir;

    /**
     * @var ScriptInjector
     */
    private $injector;

    /**
     * @var string
     */
    private $cacheSpace;

    /**
     * @var AbstractModule|null
     */
    private $module;

    /**
     * @param string               $name       application name      'MyVendor\MyProject'
     * @param string               $context    application context   'prod-app'
     * @param AbstractAppMeta|null $appMeta    application meta
     * @param string               $cacheSpace cache namespace
     * @param string               $envFile    .env file path        '/path/to/project/.env'
     */
    public function __construct(string $name, string $context, AbstractAppMeta $appMeta = null, string $cacheSpace = '', string $envFile = '')
    {
        $this->context = $context;
        $this->appMeta = $appMeta instanceof AbstractAppMeta ? $appMeta : new Meta($name, $context);
        $this->cacheSpace = $cacheSpace;
        $scriptDir = $this->appMeta->tmpDir . '/di';
        ! \file_exists($scriptDir) && \mkdir($scriptDir);
        $this->scriptDir = $scriptDir;
        $appDir = $this->appMeta->tmpDir . '/app';
        ! \file_exists($appDir) && \mkdir($appDir);
        touch($appDir . '/.do_not_clear');
        $this->appDir = $appDir;
        $this->injector = new ScriptInjector($this->scriptDir, function () use ($envFile) {
            if (file_exists($envFile)) {
                (new Loader($envFile))->parse()->toEnv(true);
            }

            return $this->getModule();
        });
        if (! $cacheSpace) {
            $this->clear();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getInstance($interface, $name = Name::ANY)
    {
        return $this->injector->getInstance($interface, $name);
    }

    public function getOverrideInstance(AbstractModule $module, $interface, $name = Name::ANY)
    {
        $appModule = clone $this->getModule();
        $appModule->override($module);

$module is of type object<Ray\Di\AbstractModule>, but the function expects a object<self>.

        return (new Injector($appModule, $this->scriptDir))->getInstance($interface, $name);
    }

    public function clear()
    {
        if ((new Unlink)->once($this->appMeta->tmpDir)) {
            return;
        }
        ! is_dir($this->appMeta->tmpDir . '/di') && \mkdir($this->appMeta->tmpDir . '/di');
        file_put_contents($this->scriptDir . ScriptInjector::MODULE, serialize($this->getModule()));
    }

    public function getCachedInstance($interface, $name = Name::ANY)
    {
        $lockFile = $this->appMeta->appDir . '/composer.lock';
        $this->cacheSpace .= file_exists($lockFile) ? (string) filemtime($lockFile) : '';
        $cache = new FilesystemCache($this->appDir);
        $id = $interface . $name . $this->context . $this->cacheSpace;
        $instance = $cache->fetch($id);
        if ($instance) {
            return $instance;
        }
        $instance = $this->injector->getInstance($interface, $name);
        $cache->save($id, $instance);

        return $instance;
    }

    private function getModule() : AbstractModule
    {
        if ($this->module instanceof AbstractModule) {
            return $this->module;
        }
        $module = (new Module)($this->appMeta, $this->context);
        /* @var AbstractModule $module */
        $container = $module->getContainer();
        (new Bind($container, InjectorInterface::class))->toInstance($this->injector);
        (new Bind($container, ''))->annotatedWith('cache_namespace')->toInstance($this->cacheSpace);
        $this->module = $module;

        return $module;
    }
}