Spiral\Stempler\Behaviours\IncludeBlock

Complexity

Total Complexity

8

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
B	createNode()	0	42	4
A	contextNode()	0	9	2
A	createPlaceholder()	0	7	1

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

namespace Spiral\Stempler\Behaviours;

use Spiral\Stempler\BehaviourInterface;
use Spiral\Stempler\HtmlTokenizer;
use Spiral\Stempler\Node;
use Spiral\Stempler\Supervisor;

/**
 * Replaces specified block (including tag) with external node, automatically uses inner tag
 * content as "context" block and all other tag attributes as additional node child.
 */
class IncludeBlock implements BehaviourInterface
{
    /**
     * Name of block used to represent import context.
     */
    const CONTEXT_BLOCK = 'context';

    /**
     * Path to be included (see Supervisor createNode).
     *
     * @var string
     */
    protected $path = '';

    /**
     * Import context includes everything between opening and closing tag.
     *
     * @var array
     */
    protected $context = [];

    /**
     * Context token.
     *
     * @var array
     */
    protected $token = [];

    /**
     * @var Supervisor
     */
    protected $supervisor = null;

    /**
     * @param Supervisor $supervisor
     * @param string     $path
     * @param array      $context
     * @param array      $token
     */
    public function __construct(
        Supervisor $supervisor,
        string $path,
        array $context,
        array $token = []
    ) {
        $this->supervisor = $supervisor;
        $this->path = $path;

        $this->context = $context;
        $this->token = $token;
    }

    /**
     * Create node to be injected into template at place of tag caused import.
     *
     * @return Node
     */
    public function createNode(): Node
    {
        //Content of node to be imported
        $node = $this->supervisor->createNode($this->path, $this->token);

        //Let's register user defined blocks (context and attributes) as placeholders
        $node->mountBlock(
            self::CONTEXT_BLOCK,
            [],
            [$this->createPlaceholder(self::CONTEXT_BLOCK, $contextID)],
            true
        );

        foreach ($this->token[HtmlTokenizer::TOKEN_ATTRIBUTES] as $attribute => $value) {
            //Attributes counted as blocks to replace elements in included node
            $node->mountBlock($attribute, [], [$value], true);
        }

        //We now have to compile node content to pass it's body to parent node
        $content = $node->compile($dynamic);

        //Outer blocks (usually user attributes) can be exported to template using non default
        //rendering technique, for example every "extra" attribute can be passed to specific
        //template location. Stempler to decide.
        foreach ($this->supervisor->getSyntax()->blockExporters() as $exporter) {
            $content = $exporter->mountBlocks($content, $dynamic);

It seems like $dynamic can also be of type null; however, Spiral\Stempler\ExporterInterface::mountBlocks() does only seem to accept array, maybe add an additional type check?

        }

        //Let's parse complied content without any imports (to prevent collision)
        $supervisor = clone $this->supervisor;
        $supervisor->flushImporters();

        //Outer content must be protected using unique names
        $rebuilt = new Node($supervisor, $supervisor->uniquePlaceholder(), $content);

        if (!empty($contextBlock = $rebuilt->findNode($contextID))) {
            //Now we can mount our content block
            $contextBlock->mountNode($this->contextNode());
        }

        return $rebuilt;
    }

    /**
     * Pack node context (everything between open and close tag).
     *
     * @return Node
     */
    protected function contextNode(): Node
    {
        $context = '';
        foreach ($this->context as $token) {
            $context .= $token[HtmlTokenizer::TOKEN_CONTENT];
        }

        return new Node($this->supervisor, $this->supervisor->uniquePlaceholder(), $context);
    }

    /**
     * Create placeholder block (to be injected with inner blocks defined in context).
     *
     * @param string      $name
     * @param string|null $blockID
     *
     * @return string
     */
    protected function createPlaceholder(string $name, string &$blockID = null): string
    {
        $blockID = $name . '-' . $this->supervisor->uniquePlaceholder();

        //Short block declaration syntax
        return '${' . $blockID . '}';
    }
}