Asmaster\EquipTwig\Loader\FilesystemLoader

Complexity

Total Complexity

18

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getSource()	0	4	1
A	getCacheKey()	0	4	1
A	isFresh()	0	4	1
A	exists()	0	8	2
A	template()	0	13	3
A	findTemplate()	0	13	3
A	possibleTemplateFiles()	0	11	2
A	normalizeName()	0	6	1
A	realFilePath()	0	9	2

<?php

namespace Asmaster\EquipTwig\Loader;

use Asmaster\EquipTwig\Exception\LoaderException;
use Twig_ExistsLoaderInterface as TwigExistsLoader;
use Twig_LoaderInterface as TwigLoader;

final class FilesystemLoader implements TwigLoader, TwigExistsLoader

The interface Twig_ExistsLoaderInterface has been deprecated with message: since 1.12 (to be removed in 3.0)

{
    /**
     * @var array
     */
    private $path;

    /**
     * @var array
     */
    private $fileExtensions = ['html.twig', 'twig'];

    /**
     * @var array
     */
    private $cache = [];

    /**
     * @param string $path           The template directory path
     * @param array  $fileExtensions The template file extensions
     */
    public function __construct($path, array $fileExtensions = null)
    {
        $this->path = $this->realFilePath($path);

It seems like $this->realFilePath($path) of type string is incompatible with the declared type array of property $path.

        if ($fileExtensions) {
            $this->fileExtensions = $fileExtensions;
        }
    }

    /**
     * @inheritDoc
     */
    public function getSource($name)
    {
        return file_get_contents($this->template($name));
    }

    /**
     * @inheritDoc
     */
    public function getCacheKey($name)
    {
        return $this->template($name);
    }

    /**
     * @inheritDoc
     */
    public function isFresh($name, $time)
    {
        return filemtime($this->template($name)) <= $time;
    }

    /**
     * @inheritDoc
     */
    public function exists($name)
    {
        if (isset($this->cache[$name])) {
            return true;
        }

        return (bool) $this->findTemplate($name);
    }

    /**
     * @throws LoaderException When $name is not found
     *
     * @param string $name
     *
     * @return string
     */
    private function template($name)
    {
        if (isset($this->cache[$name])) {
            return $this->cache[$name];
        }

        $found = $this->findTemplate($name);
        if (!$found) {

The expression $found of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            throw LoaderException::notFound($name, $this->path);
        }

        return $this->cache[$name] = $found;
    }

    /**
     * @param string $name
     *
     * @return string|null
     */
    private function findTemplate($name)
    {
        $files = $this->possibleTemplateFiles($name);

        foreach($files as $file) {
            $filepath = $this->path . DIRECTORY_SEPARATOR . $file;
            if (is_file($filepath)) {
                return $filepath;
            }
        }

        return null;
    }

    /**
     * @param string $name
     *
     * @return array
     */
    private function possibleTemplateFiles($name)
    {
        $name = $this->normalizeName($name);

        $templates = [$name];
        foreach($this->fileExtensions as $extension) {
            $templates[] = "$name.$extension";
        }

        return $templates;
    }

    /**
     * @param string $name
     *
     * @return string
     */
    private function normalizeName($name)
    {
        return preg_replace('#/{2,}#', DIRECTORY_SEPARATOR,
            str_replace('\\', DIRECTORY_SEPARATOR, $name)
        );
    }

    /**
     * @param string $file
     *
     * @return string
     */
    private function realFilePath($file)
    {
        $realpath = realpath($file);
        if (false !== $realpath) {
            return $realpath;
        }

        return $file;
    }
}