FileLoader::flushCache() - Code Metrics - Inspection of "view tests" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — 09branch (31301e)

by Anton

created 2017-01-28 21:54 UTC

FileLoader::flushCache() A

↳ Parent: FileLoader

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

namespace Spiral\Views\Loaders;

use Spiral\Core\Component;
use Spiral\Debug\Traits\BenchmarkTrait;
use Spiral\Files\FilesInterface;
use Spiral\Views\Exceptions\LoaderException;
use Spiral\Views\LoaderInterface;
use Spiral\Views\SourceContextInterface;
use Spiral\Views\ViewsInterface;
use Spiral\Views\ViewSource;

/**
 * Default views loader is very similar to twig loader (compatible), however it uses different view
 * namespace syntax, can change it's default namespace and force specified file extension. Plus it
 * works over FilesInterface.
 */
class FileLoader extends Component implements LoaderInterface
{
    use BenchmarkTrait;

    /**
     * View cache. Can be improved using MemoryInterface.
     *
     * @var array
     */
    private $sourceCache = [];

    /**
     * Such extensions will automatically be added to every file but only if no other extension
     * specified in view name. As result you are able to render "home" view, instead of "home.twig".
     *
     * @var string|null
     */
    protected $extension = null;

    /**
     * Available view namespaces associated with their directories.
     *
     * @var array
     */
    protected $namespaces = [];

    /**
     * @var FilesInterface
     */
    protected $files = null;

    /**
     * @param array          $namespaces
     * @param FilesInterface $files
     */
    public function __construct(array $namespaces, FilesInterface $files)
    {
        $this->namespaces = $namespaces;
        $this->files = $files;
    }

    /**
     * {@inheritdoc}
     */
    public function getNamespaces(): array
    {
        return $this->namespaces;
    }

    /**
     * {@inheritdoc}
     */
    public function withExtension(string $extension = null): LoaderInterface
    {
        $loader = clone $this;
        $loader->extension = $extension;

        return $loader->flushCache();
    }

    /**
     * {@inheritdoc}
     */
    public function getSource(string $path): ViewSource
    {
        if (isset($this->sourceCache[$path])) {
            //Already resolved and cached
            return $this->sourceCache[$path];
        }

        //Making sure requested name is valid
        $this->validatePath($path);

        list($namespace, $filename) = $this->parsePath($path);

        if (!isset($this->namespaces[$namespace])) {
            throw new LoaderException("Undefined view namespace '{$namespace}'");
        }

        foreach ($this->namespaces[$namespace] as $directory) {
            //Seeking for view filename
            if ($this->files->exists($directory . $filename)) {

                //Found view context
                $this->sourceCache[$path] = new ViewSource(
                    $directory . $filename,
                    $this->fetchName($filename),
                    $namespace
                );

                return $this->sourceCache[$path];
            }
        }

        throw new LoaderException("Unable to locate view '{$filename}' in namespace '{$namespace}'");
    }

    /**
     * {@inheritdoc}
     */
    public function exists(string $path): bool
    {
        if (isset($this->sourceCache[$path])) {
            //Already resolved and cached
            return true;
        }

        try {
            return !empty($this->getSource($path));
        } catch (LoaderException $e) {
            return false;
        }
    }

    /**
     * Fetch namespace and filename from view name or force default values.
     *
     * @param string $path
     *
     * @return array
     * @throws LoaderException
     */
    protected function parsePath(string $path): array
    {
        //Cutting extra symbols (see Twig)
        $filename = preg_replace(
            '#/{2,}#',
            '/',
            str_replace('\\', '/', (string)$path)
        );

        if (strpos($filename, '.') === false && !empty($this->extension)) {
            //Forcing default extension
            $filename .= '.' . $this->extension;
        }

        if (strpos($filename, ViewsInterface::NS_SEPARATOR) !== false) {
            return explode(ViewsInterface::NS_SEPARATOR, $filename);
        }

        //Twig like namespaces
        if (isset($filename[0]) && $filename[0] == '@') {
            if (($separator = strpos($filename, '/')) === false) {
                throw new LoaderException(sprintf(
                    'Malformed namespaced template name "%s" (expecting "@namespace/template_name").',
                    $path
                ));
            }

            $namespace = substr($filename, 1, $separator - 1);
            $filename = substr($filename, $separator + 1);

            return [$namespace, $filename];
        }

        //Let's force default namespace
        return [ViewsInterface::DEFAULT_NAMESPACE, $filename];
    }

    /**
     * Make sure view filename is OK. Same as in twig.
     *
     * @param string $name
     *
     * @throws LoaderException
     */
    protected function validatePath(string $name)
    {
        if (false !== strpos($name, "\0")) {
            throw new LoaderException('A template name cannot contain NUL bytes');
        }

        $name = ltrim($name, '/');
        $parts = explode('/', $name);
        $level = 0;
        foreach ($parts as $part) {
            if ('..' === $part) {
                --$level;
            } elseif ('.' !== $part) {
                ++$level;
            }

            if ($level < 0) {
                throw new LoaderException(sprintf(
                    'Looks like you try to load a template outside configured directories (%s)',
                    $name
                ));
            }
        }
    }

    /**
     * Flushing loading cache.
     *
     * @return self
     */
    protected function flushCache(): FileLoader
    {
        $this->sourceCache = [];

        return $this;
    }

    /**
     * Resolve view name based on filename (depends on current extension settings).
     *
     * @param string $filename
     *
     * @return string
     */
    private function fetchName(string $filename): string
    {
        if (empty($this->extension)) {
            return $filename;
        }

        return substr($filename, 0, -1 * (1 + strlen($this->extension)));
    }
}

1			<?php
2			/**
3			* Spiral Framework.
4			*
5			* @license MIT
6			* @author Anton Titov (Wolfy-J)
7			*/
8
9			namespace Spiral\Views\Loaders;
10
11			use Spiral\Core\Component;
12			use Spiral\Debug\Traits\BenchmarkTrait;
13			use Spiral\Files\FilesInterface;
14			use Spiral\Views\Exceptions\LoaderException;
15			use Spiral\Views\LoaderInterface;
16			use Spiral\Views\SourceContextInterface;
17			use Spiral\Views\ViewsInterface;
18			use Spiral\Views\ViewSource;
19
20			/**
21			* Default views loader is very similar to twig loader (compatible), however it uses different view
22			* namespace syntax, can change it's default namespace and force specified file extension. Plus it
23			* works over FilesInterface.
24			*/
25			class FileLoader extends Component implements LoaderInterface
26			{
27			use BenchmarkTrait;
28
29			/**
30			* View cache. Can be improved using MemoryInterface.
31			*
32			* @var array
33			*/
34			private $sourceCache = [];
35
36			/**
37			* Such extensions will automatically be added to every file but only if no other extension
38			* specified in view name. As result you are able to render "home" view, instead of "home.twig".
39			*
40			* @var string\|null
41			*/
42			protected $extension = null;
43
44			/**
45			* Available view namespaces associated with their directories.
46			*
47			* @var array
48			*/
49			protected $namespaces = [];
50
51			/**
52			* @var FilesInterface
53			*/
54			protected $files = null;
55
56			/**
57			* @param array $namespaces
58			* @param FilesInterface $files
59			*/
60			public function __construct(array $namespaces, FilesInterface $files)
61			{
62			$this->namespaces = $namespaces;
63			$this->files = $files;
64			}
65
66			/**
67			* {@inheritdoc}
68			*/
69			public function getNamespaces(): array
70			{
71			return $this->namespaces;
72			}
73
74			/**
75			* {@inheritdoc}
76			*/
77			public function withExtension(string $extension = null): LoaderInterface
78			{
79			$loader = clone $this;
80			$loader->extension = $extension;
81
82			return $loader->flushCache();
83			}
84
85			/**
86			* {@inheritdoc}
87			*/
88			public function getSource(string $path): ViewSource
89			{
90			if (isset($this->sourceCache[$path])) {
91			//Already resolved and cached
92			return $this->sourceCache[$path];
93			}
94
95			//Making sure requested name is valid
96			$this->validatePath($path);
97
98			list($namespace, $filename) = $this->parsePath($path);
99
100			if (!isset($this->namespaces[$namespace])) {
101			throw new LoaderException("Undefined view namespace '{$namespace}'");
102			}
103
104			foreach ($this->namespaces[$namespace] as $directory) {
105			//Seeking for view filename
106			if ($this->files->exists($directory . $filename)) {
107
108			//Found view context
109			$this->sourceCache[$path] = new ViewSource(
110			$directory . $filename,
111			$this->fetchName($filename),
112			$namespace
113			);
114
115			return $this->sourceCache[$path];
116			}
117			}
118
119			throw new LoaderException("Unable to locate view '{$filename}' in namespace '{$namespace}'");
120			}
121
122			/**
123			* {@inheritdoc}
124			*/
125			public function exists(string $path): bool
126			{
127			if (isset($this->sourceCache[$path])) {
128			//Already resolved and cached
129			return true;
130			}
131
132			try {
133			return !empty($this->getSource($path));
134			} catch (LoaderException $e) {
135			return false;
136			}
137			}
138
139			/**
140			* Fetch namespace and filename from view name or force default values.
141			*
142			* @param string $path
143			*
144			* @return array
145			* @throws LoaderException
146			*/
147			protected function parsePath(string $path): array
148			{
149			//Cutting extra symbols (see Twig)
150			$filename = preg_replace(
151			'#/{2,}#',
152			'/',
153			str_replace('\\', '/', (string)$path)
154			);
155
156			if (strpos($filename, '.') === false && !empty($this->extension)) {
157			//Forcing default extension
158			$filename .= '.' . $this->extension;
159			}
160
161			if (strpos($filename, ViewsInterface::NS_SEPARATOR) !== false) {
162			return explode(ViewsInterface::NS_SEPARATOR, $filename);
163			}
164
165			//Twig like namespaces
166			if (isset($filename[0]) && $filename[0] == '@') {
167			if (($separator = strpos($filename, '/')) === false) {
168			throw new LoaderException(sprintf(
169			'Malformed namespaced template name "%s" (expecting "@namespace/template_name").',
170			$path
171			));
172			}
173
174			$namespace = substr($filename, 1, $separator - 1);
175			$filename = substr($filename, $separator + 1);
176
177			return [$namespace, $filename];
178			}
179
180			//Let's force default namespace
181			return [ViewsInterface::DEFAULT_NAMESPACE, $filename];
182			}
183
184			/**
185			* Make sure view filename is OK. Same as in twig.
186			*
187			* @param string $name
188			*
189			* @throws LoaderException
190			*/
191			protected function validatePath(string $name)
192			{
193			if (false !== strpos($name, "\0")) {
194			throw new LoaderException('A template name cannot contain NUL bytes');
195			}
196
197			$name = ltrim($name, '/');
198			$parts = explode('/', $name);
199			$level = 0;
200			foreach ($parts as $part) {
201			if ('..' === $part) {
202			--$level;
203			} elseif ('.' !== $part) {
204			++$level;
205			}
206
207			if ($level < 0) {
208			throw new LoaderException(sprintf(
209			'Looks like you try to load a template outside configured directories (%s)',
210			$name
211			));
212			}
213			}
214			}
215
216			/**
217			* Flushing loading cache.
218			*
219			* @return self
220			*/
221			protected function flushCache(): FileLoader
222			{
223			$this->sourceCache = [];
224
225			return $this;
226			}
227
228			/**
229			* Resolve view name based on filename (depends on current extension settings).
230			*
231			* @param string $filename
232			*
233			* @return string
234			*/
235			private function fetchName(string $filename): string
236			{
237			if (empty($this->extension)) {
238			return $filename;
239			}
240
241			return substr($filename, 0, -1 * (1 + strlen($this->extension)));
242			}
243			}

spiral / framework

Branch — 09branch (31301e)

FileLoader::flushCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like