League\Plates\Template\ResolveTemplatePath\NameAndFolderResolveTemplatePath

Complexity

Total Complexity

23

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	13	2
A	exists()	0	9	2
A	resolvePath()	0	19	3
A	getPaths()	0	6	1
A	getNamespaces()	0	4	1
A	setPaths()	0	11	3
A	addPath()	0	8	2
A	prependPath()	0	14	3
A	normalizePath()	0	8	2
A	getDefaultDirectory()	0	13	2
A	normalizeNamespace()	0	8	2

<?php

namespace League\Plates\Template\ResolveTemplatePath;

use League\Plates\Exception\TemplateNotFound;
use League\Plates\Template\Name;
use League\Plates\Template\ResolveTemplatePath;
use LogicException;

/** Resolves the path from the logic in the Name class which resolves via folder lookup, and then the default directory */
final class NameAndFolderResolveTemplatePath implements ResolveTemplatePath
{
    /**
     * Identifier of the main namespace.
     *
     * @var string
     */
    const MAIN_NAMESPACE = '__main__';

    /**
     * Collection of template folders.
     */
    protected $paths = [];

    public function __invoke(Name $name): string
    {
        $path = $this->resolvePath($name);
        if (is_file($path)) {
            return $path;
        }

        throw new TemplateNotFound(
            $name->getName(),
            [$path],
            'The template "'.$name->getName().'" could not be found at "'.$path.'".'
        );
    }

    public function exists(Name $name): bool
    {
        $path = $this->resolvePath($name);
        if (is_file($path)) {
            return true;
        }

        return false;
    }

    public function resolvePath(Name $name)
    {
        $namespace = $this->normalizeNamespace($name->getNamespace());
        $shortPath = $name->getPath(false);
        $shortPath = $this->normalizePath($shortPath, $name);

        $fullPath = null;

$fullPath is not used, you could remove the assignment.

        $paths = $this->getPaths($namespace);
        foreach ($paths as $path) {
            $fullPath = $path.'/'.$shortPath;
            if (is_file($fullPath)) {
                return $fullPath;
            }
        }

        $defaultDirectory = $this->getDefaultDirectory($name);

        return "{$defaultDirectory}/{$shortPath}";
    }

    /**
     * Returns the paths to the templates.
     */
    public function getPaths(string $namespace = self::MAIN_NAMESPACE): array
    {
        $namespace = $this->normalizeNamespace($namespace);

        return $this->paths[$namespace] ?? [];
    }

    /**
     * Returns the path namespaces.
     *
     * The main namespace is always defined.
     */
    public function getNamespaces(): array
    {
        return array_keys($this->paths);
    }

    /**
     * @param string|array $paths A path or an array of paths where to look for templates
     */
    public function setPaths($paths, string $namespace = self::MAIN_NAMESPACE): void
    {
        if (!\is_array($paths)) {
            $paths = [$paths];
        }

        $this->paths[$namespace] = [];
        foreach ($paths as $path) {
            $this->addPath($path, $namespace);
        }
    }

    /**
     * @throws \Exception
     */
    public function addPath(string $path, string $namespace = self::MAIN_NAMESPACE)
    {
        if (!is_dir($path)) {
            throw new \Exception(sprintf('The "%s" directory does not exist.', $path));
        }

        $this->paths[$namespace][] = rtrim($path, '/\\');
    }

    public function prependPath(string $path, string $namespace = self::MAIN_NAMESPACE): void
    {
        if (!is_dir($path)) {
            throw new \Exception(sprintf('The "%s" directory does not exist.', $path));
        }

        $path = rtrim($path, '/\\');

        if (!isset($this->paths[$namespace])) {
            $this->paths[$namespace][] = $path;
        } else {
            array_unshift($this->paths[$namespace], $path);
        }
    }

    protected function normalizePath($path, Name $name): string
    {
        if (!is_null($name->getEngine()->getFileExtension())) {
            $path .= '.'.$name->getEngine()->getFileExtension();
        }

        return $path;
    }

    /**
     * Get the default templates directory.
     * @return string
     */
    protected function getDefaultDirectory(Name $name)
    {
        $directory = $name->getEngine()->getDirectory();

        if (is_null($directory)) {
            throw new LogicException(
                'The template name "'.$name->getName().'" is not valid. '.
                'The default directory has not been defined.'
            );
        }

        return $directory;
    }

    protected function normalizeNamespace($namespace = self::MAIN_NAMESPACE): string
    {
        if (empty($namespace)) {
            return self::MAIN_NAMESPACE;
        }

        return $namespace;
    }
}