Jasny\Controller\View\Twig

Complexity

Total Complexity

20

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

93.48%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
	getRequest()	0	1	?
	getResponse()	0	1	?
A	setViewVariable()	0	8	2
A	setViewFunction()	0	12	3
A	setViewExtension()	0	6	1
A	view()	0	13	2
A	getTwig()	0	21	4
A	getTwigLoader()	0	4	1
A	getTwigEnvironment()	0	4	1
A	createTwigFunction()	0	6	3
A	createTwigFilter()	0	6	3

<?php

namespace Jasny\Controller\View;

use Jasny\Flash;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * View using Twig
 */
trait Twig
{
    /**
     * Twig environment
     * @var \Twig_Environment
     */
    protected $twig = null;

    /**
     * Get server request
     * @return ServerRequestInterface
     */
    abstract public function getRequest();

    /**
     * Get server response
     * @return ResponseInterface
     */
    abstract public function getResponse();

    /**
     * Add a global variable to the view.
     * 
     * @param string $name   Variable name
     * @param mixed  $value
     * @return $this
     */
    public function setViewVariable($name, $value)
    {
        if (!$name) throw new \InvalidArgumentException("Name should not be empty");        

It is generally a best practice to always use braces with control structures.

        $this->getTwig()->addGlobal($name, $value);

        return $this;
    }
    
    /**
     * Expose a function to the view.
     * 
     * @param string $name       Variable name
     * @param mixed  $function
     * @param string $as        'function' or 'filter'
     * @return $this
     */
    public function setViewFunction($name, $function = null, $as = 'function')
    {
        if ($as === 'function') {
            $this->getTwig()->addFunction($this->createTwigFunction($name, $function));
        } elseif ($as === 'filter') {
            $this->getTwig()->addFilter($this->createTwigFilter($name, $function));
        } else {
            throw new \InvalidArgumentException("You should create either function or filter, not '$as'");
        }
        
        return $this;
    }

    /**
     * Add extension to view
     *
     * @param object $extension
     * @return $this
     */
    public function setViewExtension($extension)
    {
        $this->getTwig()->addExtension($extension);

        return $this;
    }

    /**
     * View rendered template
     *
     * @param string $name   Template name
     * @param array $context Template context
     * @return ResponseInterface
     */
    public function view($name, array $context = [])
    {
        if (!pathinfo($name, PATHINFO_EXTENSION)) $name .= '.html.twig';

It is generally a best practice to always use braces with control structures.

        $twig = $this->getTwig();
        $tmpl = $twig->loadTemplate($name);

        $response = $this->getResponse();
        $response = $response->withHeader('Content-Type', 'text/html; charset=' . $twig->getCharset());
        $response->getBody()->write($tmpl->render($context));            

        return $response;
    }

    /**
     * Get twig environment
     *
     * @return \Twig_Environment
     */
    public function getTwig()
    {
        if ($this->twig) return $this->twig;

It is generally a best practice to always use braces with control structures.

        $loader = $this->getTwigLoader();
        $this->twig = $this->getTwigEnvironment($loader);

        $extensions = ['DateExtension', 'PcreExtension', 'TextExtension', 'ArrayExtension'];
        foreach ($extensions as $name) {
            $class = "Jasny\Twig\\$name";

            if (class_exists($class)) $this->setViewExtension(new $class());

It is generally a best practice to always use braces with control structures.

        }
        
        $uri = $this->getRequest()->getUri()->getPath();
        
        $this->setViewVariable('current_url', $uri);
        $this->setViewVariable('flash', new Flash());

        return $this->twig;
    }

    /**
     * Get twig loasder for current working directory
     *
     * @return \Twig_Loader_Filesystem
     */
    public function getTwigLoader()
    {
        return new \Twig_Loader_Filesystem(getcwd());
    }

    /**
     * Get twig environment instance
     *
     * @param \Twig_Loader_Filesystem $loader
     * @return \Twig_Environment
     */
    public function getTwigEnvironment(\Twig_Loader_Filesystem $loader)
    {
        return new \Twig_Environment($loader);
    }

    /**
     * Create twig function
     *
     * @param string $name          Name of function in view
     * @param callable|null $function 
     * @return \Twig_SimpleFunction
     */
    public function createTwigFunction($name, $function)
    {
        if (!$name) throw new \InvalidArgumentException("Function name should not be empty");

It is generally a best practice to always use braces with control structures.

        return new \Twig_SimpleFunction($name, $function ?: $name);
    }

    /**
     * Create twig filter
     *
     * @param string $name          Name of filter in view
     * @param callable|null $function 
     * @return \Twig_SimpleFilter
     */
    public function createTwigFilter($name, $function)
    {
        if (!$name) throw new \InvalidArgumentException("Filter name should not be empty");

It is generally a best practice to always use braces with control structures.

        return new \Twig_SimpleFilter($name, $function ?: $name);
    }
}