WebinoDraw\Instructions\InstructionsRenderer

Complexity

Total Complexity

32

Size/Duplication

Total Lines	206
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
C	render()	0	48	15
A	createNodeSpec()	0	6	1
A	drawNodes()	0	6	1
A	resolveIsNodeDisabled()	0	5	3
A	resolveIsEmptyNodes()	0	4	1
A	subInstructions()	0	16	4
B	expandInstructions()	0	25	6

<?php
/**
 * Webino (http://webino.sk)
 *
 * @link        https://github.com/webino/WebinoDraw for the canonical source repository
 * @copyright   Copyright (c) 2012-2017 Webino, s. r. o. (http://webino.sk)
 * @author      Peter Bačinský <peter@bacinsky.sk>
 * @license     BSD-3-Clause
 */

namespace WebinoDraw\Instructions;

use ArrayObject;
use DOMNodeList;
use WebinoDraw\Dom\Element;
use WebinoDraw\Dom\NodeInterface;
use WebinoDraw\Dom\Factory\NodeListFactory;
use WebinoDraw\Dom\Locator;
use WebinoDraw\Dom\NodeList;
use WebinoDraw\Dom\Text;
use WebinoDraw\Draw\HelperPluginManager;
use WebinoDraw\Exception\InvalidArgumentException;
use WebinoDraw\Factory\InstructionsFactory;
use WebinoDraw\Options\ModuleOptions;
use WebinoDraw\VarTranslator\Translation;
use Zend\Stdlib\ArrayUtils;

/**
 * Class InstructionsRenderer
 */
class InstructionsRenderer implements InstructionsRendererInterface
{
    /**
     * Makes the helper setting optional for common use cases
     */
    const DEFAULT_DRAW_HELPER = 'WebinoDrawElement';

    /**
     * @var HelperPluginManager
     */
    protected $drawHelpers;

    /**
     * @var Locator
     */
    protected $locator;

    /**
     * @var NodeListFactory
     */
    protected $nodeListFactory;

    /**
     * @var InstructionsFactory
     */
    protected $instructionsFactory;

    /**
     * @var ModuleOptions
     */
    protected $drawOptions;

    /**
     * @param object|HelperPluginManager $drawHelpers
     * @param Locator $locator
     * @param NodeListFactory $nodeListFactory
     * @param InstructionsFactory $instructionsFactory
     * @param object|ModuleOptions $drawOptions
     */
    public function __construct(
        HelperPluginManager $drawHelpers,
        Locator $locator,
        NodeListFactory $nodeListFactory,
        InstructionsFactory $instructionsFactory,
        ModuleOptions $drawOptions
    ) {
        $this->drawHelpers         = $drawHelpers;
        $this->locator             = $locator;
        $this->nodeListFactory     = $nodeListFactory;
        $this->instructionsFactory = $instructionsFactory;
        $this->drawOptions         = $drawOptions;
    }

    /**
     * Render the DOMElement ownerDocument
     *
     * {@inheritDocs}
     * @throws InvalidArgumentException
     */
    public function render(NodeInterface $node, $instructions, array $vars)
    {
        $varTranslation = (new Translation($vars))->makeVarKeys();
        $drawInstructions = is_array($instructions)
                          ? $this->instructionsFactory->create($instructions)
                          : $instructions;

        if (!($drawInstructions instanceof Instructions)) {
            throw new InvalidArgumentException('Expected instructions as array|InstructionsInterface');
        }

        $nodePath = null;
        if ($node instanceof Element || $node instanceof Text) {
            $node->setOnReplace(function ($newNode) use (&$nodePath) {
                if ($newNode instanceof Element || $newNode instanceof Text) {
                    $nodePath = $newNode->getNodePath();
                }
            });
        }

        $_node = $node;
        foreach ($drawInstructions->getSortedArrayCopy() as $specs) {
            $spec = (array) $this->createNodeSpec($specs);
            unset($specs);

            if ($this->resolveIsNodeDisabled($_node, $spec)) {
                continue;
            }

            $varTranslation->translate($spec['locator']);
            $nodes = $this->locator->locate($_node, $spec['locator']);
            if ($this->resolveIsEmptyNodes($nodes)) {
                continue;
            }

            $helper = !empty($spec['helper'])
                    ? $varTranslation->translateString($spec['helper'])
                    : self::DEFAULT_DRAW_HELPER;

            $this->drawNodes($nodes, $helper, $spec, $vars);

            $ownerDocument = $node->getOwnerDocument();

It seems like you code against a concrete implementation and not the interface WebinoDraw\Dom\NodeInterface as the method getOwnerDocument() does only exist in the following implementations of said interface: WebinoDraw\Dom\Element, WebinoDraw\Dom\Text.

            if ($ownerDocument && empty($node->parentNode) && isset($nodePath)) {

Accessing parentNode on the interface WebinoDraw\Dom\NodeInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                $_newNode = $ownerDocument->getXpath()->query($nodePath)->item(0);
                $_newNode and $_node = $_newNode;
            }
        }
    }

    /**
     * @param array $specs
     * @return array
     */
    protected function createNodeSpec(array $specs)
    {
        // one node per stackIndex
        $spec = current($specs);
        return $spec;
    }

    /**
     * @param DOMNodeList $nodes
     * @param string $helper
     * @param array $spec
     * @param array $vars
     */
    protected function drawNodes(DOMNodeList $nodes, $helper, array $spec, array $vars)
    {
        $this->drawHelpers->get((string) $helper)
            ->setVars($vars)
            ->__invoke($this->nodeListFactory->create($nodes), $spec);
    }

    /**
     * @param NodeInterface|null $node
     * @param array $spec
     * @return bool
     */
    protected function resolveIsNodeDisabled($node, array $spec)
    {
        // locator not set or node already removed
        return empty($spec['locator']) || empty($node) || empty($node->ownerDocument);

Accessing ownerDocument on the interface WebinoDraw\Dom\NodeInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @param DOMNodeList|null $nodes
     * @return bool
     */
    protected function resolveIsEmptyNodes(DOMNodeList $nodes = null)
    {
        return empty($nodes->length);
    }

    /**
     * @param array|NodeList $nodes
     * @param array $instructions
     * @param ArrayObject $translation
     * @return $this
     */
    public function subInstructions($nodes, array $instructions, ArrayObject $translation)
    {
        $nodeList = is_array($nodes) ? $this->nodeListFactory->create($nodes) : $nodes;
        if (!($nodeList instanceof NodeList)) {
            throw new InvalidArgumentException('Expected nodes as array|NodeList');
        }

        $drawInstructions = $this->instructionsFactory->create($instructions);
        $vars = $translation->getArrayCopy();

        foreach ($nodeList as $node) {
            $this->render($node, $drawInstructions, $vars);
        }

        return $this;
    }

    /**
     * @param array $spec
     * @param Translation $translation
     * @return $this
     */
    public function expandInstructions(array &$spec, Translation $translation = null)
    {
        if (empty($spec['instructionset'])) {
            return $this;
        }

        $translation and $translation->makeVarKeys(clone $translation)->translate($spec['instructionset']);

It seems like you code against a concrete implementation and not the interface ArrayAccess as the method translate() does only exist in the following implementations of said interface: WebinoDraw\VarTranslator\Translation.

        $instructions = $this->instructionsFactory->create([]);
        foreach ($spec['instructionset'] as $instructionset) {
            $instructions->merge($this->drawOptions->instructionsFromSet($instructionset));
        }

        unset($spec['instructionset']);
        foreach ($instructions->getSortedArrayCopy() as $instruction) {
            $key = key($instruction);
            if (empty($spec['instructions'][$key])) {
                $spec['instructions'][$key] = current($instruction);
                continue;
            }
            $spec['instructions'][$key] = ArrayUtils::merge(current($instruction), $spec['instructions'][$key]);
        }

        return $this;
    }
}