BEAR\Package\Compiler

Complexity

Total Complexity

17

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	13

Test Coverage

Coverage

60.81%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	22	1
B	compile()	0	32	6
A	dumpAutoload()	0	4	1
A	registerLoader()	0	25	5
A	hookNullObjectClass()	0	7	2
A	unregisterComposerLoader()	0	7	2

<?php

declare(strict_types=1);

namespace BEAR\Package;

use ArrayObject;
use BEAR\AppMeta\Meta;
use BEAR\Package\Compiler\CompileAutoload;
use BEAR\Package\Compiler\CompileClassMetaInfo;
use BEAR\Package\Compiler\CompileDependencies;
use BEAR\Package\Compiler\CompileDiScripts;
use BEAR\Package\Compiler\CompileObjectGraph;
use BEAR\Package\Compiler\CompilePreload;
use BEAR\Package\Compiler\FakeRun;
use BEAR\Package\Compiler\FilePutContents;
use BEAR\Package\Compiler\NewInstance;
use BEAR\Package\Exception\InvalidContextException;
use BEAR\Package\Provide\Error\NullPage;
use Composer\Autoload\ClassLoader;
use Ray\Di\InjectorInterface;
use RuntimeException;

use function assert;
use function count;
use function file_exists;
use function is_float;
use function is_int;
use function memory_get_peak_usage;
use function microtime;
use function number_format;
use function ob_clean;
use function printf;
use function realpath;
use function spl_autoload_functions;
use function spl_autoload_register;
use function spl_autoload_unregister;
use function strpos;

use const PHP_EOL;

final class Compiler
{
    /** @var ArrayObject<int, string> */
    private $classes;

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

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

    /** @var Meta */
    private $appMeta;

    /** @var CompileDiScripts */
    private $compilerDiScripts;

    /** @var NewInstance */
    private $newInstance;

    /** @var CompileAutoload */
    private $dumpAutoload;

    /** @var CompilePreload */
    private $compilePreload;

    /** @var CompileObjectGraph */
    private $compilerObjectGraph;

    /** @var CompileDependencies */
    private $compileDependencies;

    /**
     * @param string $appName application name "MyVendor|MyProject"
     * @param string $context application context "prod-app"
     * @param string $appDir  application path
     */
    public function __construct(string $appName, string $context, string $appDir)
    {
        $classes = new ArrayObject();
        $this->classes = $classes;
        $this->registerLoader($appDir);
        $this->hookNullObjectClass($appDir);
        $this->context = $context;
        $this->appMeta = new Meta($appName, $context, $appDir);
        /** @psalm-suppress MixedAssignment (?) */
        $this->injector = Injector::getInstance($appName, $context, $appDir);
        $this->compilerDiScripts = new CompileDiScripts(new CompileClassMetaInfo(), $this->injector);
        $this->newInstance = new NewInstance($this->injector);
        /** @var ArrayObject<int, string> $overWritten */
        $overWritten = new ArrayObject();
        /** @var ArrayObject<int, string> $classes */
        $filePutContents = new FilePutContents($overWritten);
        $fakeRun = new FakeRun($this->injector, $context, $this->appMeta);
        $this->dumpAutoload = new CompileAutoload($fakeRun, $this->injector, $filePutContents, $this->appMeta, $overWritten, $this->classes, $appDir, $context);
        $this->compilePreload = new CompilePreload($fakeRun, $this->newInstance, $this->dumpAutoload, $filePutContents, $classes, $context);
        $this->compilerObjectGraph = new CompileObjectGraph($filePutContents, $appDir);
        $this->compileDependencies = new CompileDependencies($this->newInstance);
    }

    /**
     * Compile application
     *
     * @return 0|1 exit code

The doc-type 0|1 could not be parsed: Unknown type name "0" at position 0. (view supported doc-types)

     */
    public function compile(): int
    {
        try {
            $preload = ($this->compilePreload)($this->appMeta, $this->context);
            $module = (new Module())($this->appMeta, $this->context);
            ($this->compileDependencies)($module);
        } catch (InvalidContextException $e) {
            printf("Invalid context %s\n", $e->getMessage());
            ob_clean();

            return 1;
        }

        echo PHP_EOL;
        ($this->compilerDiScripts)($this->appMeta);
        $failed = $this->newInstance->getFailed();
        $dot = $failed ? '' : ($this->compilerObjectGraph)($module);
        $start = $_SERVER['REQUEST_TIME_FLOAT'];
        assert(is_float($start));
        $time = number_format(microtime(true) - $start, 2);
        $memory = number_format(memory_get_peak_usage() / (1024 * 1024), 3);
        echo PHP_EOL;
        printf("Compilation (1/2) took %f seconds and used %fMB of memory\n", $time, $memory);
        printf("Success: %d Failed: %d\n", $this->newInstance->getCompiled(), count($this->newInstance->getFailed()));
        printf("preload.php: %s\n", $this->dumpAutoload->getFileInfo($preload));
        printf("module.dot: %s\n", $dot ? $this->dumpAutoload->getFileInfo($dot) : 'n/a');
        foreach ($this->newInstance->getFailed() as $depedencyIndex => $error) {
            printf("UNBOUND: %s for %s \n", $error, $depedencyIndex);
        }

        return $failed ? 1 : 0;
    }

    public function dumpAutoload(): int
    {
        return ($this->dumpAutoload)();
    }

    private function registerLoader(string $appDir): void
    {
        $this->unregisterComposerLoader();
        $loaderFile = $appDir . '/vendor/autoload.php';
        if (! file_exists($loaderFile)) {
            throw new RuntimeException('no loader');
        }

        $loader = require $loaderFile;
        assert($loader instanceof ClassLoader);
        spl_autoload_register(
            /** @var class-string $class */

The doc-type class-string could not be parsed: Unknown type name "class-string" at position 0. (view supported doc-types)

            function (string $class) use ($loader): void {
                $loader->loadClass($class);
                if (
                    $class !== NullPage::class
                    && ! is_int(strpos($class, 'BEAR\Package\Compiler'))
                    && ! is_int(strpos($class, NullPage::class))
                ) {
                    /** @psalm-suppress NullArgument */
                    $this->classes[] = $class;
                }
            }
        );
    }

    private function hookNullObjectClass(string $appDir): void
    {
        $compileScript = realpath($appDir) . '/.compile.php';
        if (file_exists($compileScript)) {
            require $compileScript;
        }
    }

    private function unregisterComposerLoader(): void
    {
        $autoload = spl_autoload_functions();
        if (isset($autoload[0])) {
            spl_autoload_unregister($autoload[0]);
        }
    }
}