Ingenerator\KohanaView\TemplateManager\CFSTemplateManager

Complexity

Total Complexity

14

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	4
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getPath()	0	13	2
A	isCompileRequired()	0	8	3
A	requireSourceFileContent()	0	8	2
A	writeFile()	0	5	1
A	ensureWriteableDirectory()	0	12	4

<?php
/**
 * @author     Andrew Coulton <andrew@ingenerator.com>
 * @copyright  2015 inGenerator Ltd
 * @license    http://kohanaframework.org/license
 */

namespace Ingenerator\KohanaView\TemplateManager;

use Ingenerator\KohanaView\Exception\TemplateCacheException;
use Ingenerator\KohanaView\Exception\TemplateNotFoundException;
use Ingenerator\KohanaView\TemplateCompiler;
use Ingenerator\KohanaView\TemplateManager;

/**
 * Manages compilation of templates from view files located within the cascading file system. This allows extension
 * modules or applications to provide their own templates that are used in place of defaults provided by other modules.
 *
 * Templates will be dynamically compiled and cached to disk:
 *  * If the recompile_always option is TRUE, then once for every execution
 *  * If the recompile_always option is FALSE, then only if the compiled template does not yet exist
 *
 * @package Ingenerator\KohanaView\TemplateManager
 */
class CFSTemplateManager implements TemplateManager
{
    /**
     * @var string
     */
    protected $cache_dir;

    /**
     * @var CFSWrapper
     */
    protected $cascading_files;

    /**
     * @var array
     */
    protected $compiled_paths = [];

    /**
     * @var TemplateCompiler
     */
    protected $compiler;

    /**
     * @var boolean
     */
    protected $recompile_always;

    /**
     * @var string
     */
    protected $template_dir;

    /**
     * Valid options:
     * * cache_dir        => the path where compiled templates will be cached
     * * recompile_always => whether to recompile each template on every execution,
     * * template_dir     => directory (in the cascading filesystem) to search for templates
     *
     * @param TemplateCompiler $compiler
     * @param array            $options
     * @param null|CFSWrapper  $cascading_files
     */
    public function __construct(TemplateCompiler $compiler, array $options, CFSWrapper $cascading_files = NULL)
    {
        $this->cascading_files  = $cascading_files ?: new CFSWrapper;
        $this->compiler         = $compiler;
        $this->cache_dir        = rtrim($options['cache_dir'], '/');
        $this->recompile_always = \Arr::get($options, 'recompile_always', FALSE);
        $this->template_dir     = rtrim(\Arr::get($options, 'template_dir', 'views'), '/');
    }

    /**
     * {@inheritdoc}
     */
    public function getPath($template_name)
    {
        $compiled_path = $this->cache_dir.'/'.$template_name.'.php';

        if ($this->isCompileRequired($compiled_path)) {
            $source   = $this->requireSourceFileContent($template_name);
            $compiled = $this->compiler->compile($source);
            $this->writeFile($compiled_path, $compiled);
            $this->compiled_paths[$compiled_path] = TRUE;
        }

        return $compiled_path;
    }

    /**
     * @param string $compiled_path
     *
     * @return bool
     */
    protected function isCompileRequired($compiled_path)
    {
        if ($this->recompile_always AND ! isset($this->compiled_paths[$compiled_path])) {
            return TRUE;
        }

        return ! file_exists($compiled_path);
    }

    /**
     * @param string $template_name
     *
     * @return string
     */
    protected function requireSourceFileContent($template_name)
    {
        if ( ! $source_file = $this->cascading_files->find_file($this->template_dir, $template_name)) {
            throw TemplateNotFoundException::forSourcePath($this->template_dir.'/'.$template_name);
        }

        return file_get_contents($source_file);
    }

    /**
     * @param string $compiled_path
     * @param string $compiled
     */
    protected function writeFile($compiled_path, $compiled)
    {
        $this->ensureWriteableDirectory(dirname($compiled_path));
        file_put_contents($compiled_path, $compiled);
    }

    /**
     * @param string $path
     */
    protected function ensureWriteableDirectory($path)
    {
        if (is_dir($path)) {
            if ( ! is_writeable($path)) {
                throw TemplateCacheException::pathNotWriteable($path);
            }
        } else {
            if ( ! mkdir($path, 0777, TRUE)) {
                throw TemplateCacheException::cannotCreateDirectory($path);
            }
        }
    }

}