Biurad\DependencyInjection\Loader

Complexity

Total Complexity

24

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
C	loadFile()	0	44	13
A	__construct()	0	4	1
A	load()	0	9	2
A	getClassName()	0	3	1
A	generate()	0	11	2
A	isExpired()	0	12	5

<?php

declare(strict_types=1);

/*
 * This file is part of Biurad opensource projects.
 *
 * PHP version 7.2 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Biurad\DependencyInjection;

use Nette;
use Nette\DI\DependencyChecker;

/**
 * DI container loader.
 *
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
class Loader
{
    /** @var bool */
    private $autoRebuild = false;

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

    public function __construct(string $tempDirectory, bool $autoRebuild = false)
    {
        $this->tempDirectory = $tempDirectory;
        $this->autoRebuild   = $autoRebuild;
    }

    /**
     * @param callable $generator function (Nette\DI\Compiler $compiler): string|null
     * @param mixed    $key
     */
    public function load(callable $generator, $key = null): string
    {
        $class = $this->getClassName($key);

        if (!\class_exists($class, false)) {
            $this->loadFile($class, $generator);
        }

        return $class;
    }

    /**
     * @param mixed $key
     */
    public function getClassName($key): string
    {
        return 'Container_' . \substr(\md5(\serialize($key)), 0, 10);
    }

    /**
     * @param string   $class
     * @param callable $generator
     *
     * @return array of (code, file[])
     */
    protected function generate(string $class, callable $generator): array
    {
        $compiler = new Compiler(new Builder());
        $compiler->setClassName($class);

        $code = $generator(...[&$compiler]) ?: $compiler->compile();

        return [
            "<?php\n$code",
            \serialize($compiler->exportDependencies()),
            (new XmlAdapter())->dump($compiler->getConfig()),

The function Nette\DI\Compiler::getConfig() has been deprecated.

        ];
    }

    private function loadFile(string $class, callable $generator): void
    {
        $file = "$this->tempDirectory/$class.php";

        if (!$this->isExpired($file) && (@include $file) !== false) { // @ file may not exist
            return;
        }

        Nette\Utils\FileSystem::createDir($this->tempDirectory);

        $handle = @\fopen("$file.lock", 'c+'); // @ is escalated to exception

        if (!$handle) {

$handle is of type false|resource, thus it always evaluated to false.

            throw new Nette\IOException("Unable to create file '$file.lock'. " . Nette\Utils\Helpers::getLastError());
        }

        if (!@\flock($handle, \LOCK_EX)) { // @ is escalated to exception
            throw new Nette\IOException("Unable to acquire exclusive lock on '$file.lock'. " . Nette\Utils\Helpers::getLastError());
        }

        if (!\is_file($file) || $this->isExpired($file, $updatedMeta)) {

The variable $updatedMeta seems to be never defined.

            if (isset($updatedMeta)) {

The variable $updatedMeta seems to never exist and therefore isset should always be false.

                $toWrite["$file.meta"] = $updatedMeta;

$toWrite was never initialized. Although not strictly required by PHP, it is generally a good practice to add $toWrite = array(); before regardless.

            } else {
                [$toWrite[$file], $toWrite["$file.meta"], $toWrite["$file.xml"]] = $this->generate($class, $generator);
            }

            foreach ($toWrite as $name => $content) {
                if (\file_put_contents("$name.tmp", $content) !== \strlen($content) || !\rename("$name.tmp", $name)) {
                    @\unlink("$name.tmp"); // @ - file may not exist

It seems like you do not handle an error condition for unlink(). This can introduce security issues, and is generally not recommended.

                    throw new Nette\IOException("Unable to create file '$name'.");
                }

                if (\function_exists('opcache_invalidate')) {
                    @\opcache_invalidate($name, true); // @ can be restricted

It seems like you do not handle an error condition for opcache_invalidate(). This can introduce security issues, and is generally not recommended.

                }
            }
        }

        if ((@include $file) === false) { // @ - error escalated to exception
            throw new Nette\IOException("Unable to include '$file'.");
        }
        \flock($handle, \LOCK_UN);
    }

    private function isExpired(string $file, string &$updatedMeta = null): bool
    {
        if ($this->autoRebuild) {
            $meta = @\unserialize((string) \file_get_contents("$file.meta")); // @ - file may not exist
            $orig = $meta[2] ?? null;

            return empty($meta[0])
                || DependencyChecker::isExpired(...$meta)

The call to Nette\DI\DependencyChecker::isExpired() has too few arguments starting with files.

                || ($orig !== $meta[2] && $updatedMeta = \serialize($meta));
        }

        return false;
    }
}