mindplay\kisstpl\ViewService

Complexity

Total Complexity

21

Size/Duplication

Total Lines	239
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	capture()	0	8	1
A	begin()	0	15	2
A	end()	0	18	3
A	renderClosure()	0	4	1
A	onMissingView()	0	12	2
C	render()	0	40	7
A	renderFile()	0	14	4

<?php

namespace mindplay\kisstpl;

use Closure;
use RuntimeException;

/**
 * This service provides a view/template rendering service and a simple output capture facility.
 */
class ViewService implements Renderer
{
    /**
     * @var ViewFinder
     */
    public $finder;

    /**
     * @var string the default type of view
     *
     * @see render()
     */
    public $default_type = 'view';

    /**
     * @var string[] a stack of variable references being captured to
     *
     * @see begin()
     * @see end()
     */
    protected $capture_stack = array();

    /**
     * @var int a unique index to track use of the capture stack
     *
     * @see begin()
     * @see end()
     */
    private $capture_index = 0;

    /**
     * @var string[][] map where view-model class name => map where view type => view path
     */
    private $path_cache = array();

    /**
     * @var Closure[] map where view path => view Closure
     */
    private $closure_cache = array();

    /**
     * @param ViewFinder $finder
     */
    public function __construct(ViewFinder $finder)
    {
        $this->finder = $finder;
    }

    /**
     * Locate and render a PHP template for the given view, directly to output - as
     * opposed to {@see capture()} which will use output buffering to capture the
     * content and return it as a string.
     *
     * The view will be made available to the template as <code>$view</code> and the
     * calling context (<code>$this</code>) will be this ViewService.
     *
     * @param object      $view the view-model to render
     * @param string|null $type the type of view to render (optional)
     *
     * @return void
     *
     * @throws RuntimeException
     *
     * @see capture()
     */
    public function render($view, $type = null)
    {
        $__type = $type === null
            ? $this->default_type
            : $type;

        unset($type);

        $__class = get_class($view);

        if (! isset($this->path_cache[$__class][$__type])) {
            $this->path_cache[$__class][$__type] = $this->finder->findTemplate($view, $__type);
        }

        $__path = $this->path_cache[$__class][$__type];

        if ($__path === null) {
            $this->onMissingView($view, $__type);

            return;
        }

        $__depth = count($this->capture_stack);

        $ob_level = ob_get_level();

        $this->renderFile($__path, $view);

        if (ob_get_level() !== $ob_level) {
            $error = count($this->capture_stack) !== $__depth
                ? "begin() without matching end()"
                : "output buffer-level mismatch: was " . ob_get_level() . ", expected {$ob_level}";

            while (ob_get_level() > $ob_level) {
                ob_end_clean(); // clean up any hanging output buffers prior to throwing
            }

            throw new RuntimeException("{$error} in file: {$__path}");
        }
    }

    /**
     * Render and capture the output from a PHP template for the given view - as
     * opposed to {@see render()} which will render directly to output.
     *
     * Use capture only when necessary, such as when capturing content from a
     * rendered template to populate the body of an e-mail.
     *
     * @param object      $view the view-model to render
     * @param string|null $type the type of view to render (optional)
     *
     * @return string rendered content
     *
     * @see render()
     */
    public function capture($view, $type = null)
    {
        ob_start();

        $this->render($view, $type);

        return ob_get_clean();
    }

    /**
     * @param string &$var target variable reference for captured content
     *
     * @return void
     *
     * @see end()
     */
    public function begin(&$var)
    {
        $index = $this->capture_index++;

        $var = __CLASS__ . "::\$capture_stack[{$index}]";

        if (in_array($var, $this->capture_stack, true)) {
            throw new RuntimeException("begin() with same reference as prior begin()");
        }

        $this->capture_stack[] = &$var;

        // begin buffering content to capture:
        ob_start();
    }

    /**
     * @param string &$var target variable reference for captured content
     *
     * @return void
     *
     * @throws RuntimeException
     *
     * @see begin()
     */
    public function end(&$var)
    {
        if (count($this->capture_stack) === 0) {
            throw new RuntimeException("end() without begin()");
        }

        $index = count($this->capture_stack) - 1;

        if ($this->capture_stack[$index] !== $var) {
            throw new RuntimeException("end() with mismatched begin()");
        }

        // capture the buffered content:
        $this->capture_stack[$index] = ob_get_clean();

        // remove target variable reference from stack:
        array_pop($this->capture_stack);
    }

    /**
     * Internally render a template file (or delegate to a cached closure)
     *
     * @param string $_path_ absolute path to PHP template
     * @param object $view the view-model to render
     *
     * @return void
     */
    protected function renderFile($_path_, $view)
    {
        if (!isset($this->closure_cache[$_path_])) {
            $_closure_ = require $_path_;

            if (is_callable($_closure_)) {
                $this->closure_cache[$_path_] = $_closure_;
            }
        }

        if (isset($this->closure_cache[$_path_])) {
            $this->renderClosure($this->closure_cache[$_path_], $view);

$this->closure_cache[$_path_] is of type callable, but the function expects a object<Closure>.

        }
    }

    /**
     * Internally render a template closure
     *
     * @param Closure $closure template closure
     * @param object  $view    the view-model to render
     *
     * @return void
     */
    protected function renderClosure($closure, $view)
    {
        call_user_func($closure, $view, $this);
    }

    /**
     * Called internally, if a view could not be resolved
     *
     * @param object      $view the view-model attempted to render
     * @param string|null $type the type of view attempted to render (optional)
     *
     * @return void
     *
     * @see render()
     */
    protected function onMissingView($view, $type)
    {
        $class = get_class($view);

        $paths = $this->finder->listSearchPaths($view, $type);

        $message = count($paths) > 0
            ? "searched paths:\n  * " . implode("\n  * ", $paths)
            : "no applicable path(s) found";

        throw new RuntimeException("no view of type \"{$type}\" found for model: {$class} - {$message}");
    }
}