Form::matchTemplate() - Code Metrics - webino/WebinoDraw - Measure and Improve Code Quality continuously with Scrutinizer

Form::matchTemplate() F
last analyzed 2019-12-25 16:24 UTC

↳ Parent: Form

Complexity

Conditions	29
Paths	2642

Size

Total Lines

153

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	153
rs	0
c	0
b	0
f	0
cc	29
nc	2642
nop	2

How to fix Long Method Complexity

<?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ý <[email protected]>
 * @license     BSD-3-Clause
 */

namespace WebinoDraw\Draw\Helper;

use WebinoDraw\Event\DrawFormEvent;
use WebinoDraw\Dom\NodeList;
use WebinoDraw\Exception;
use WebinoDraw\Instructions\InstructionsRenderer;
use Zend\Form\FormInterface;
use Zend\Form\View\Helper\FormCollection;
use WebinoDraw\Form\View\Helper\FormElement;
use Zend\Form\View\Helper\FormElementErrors;
use Zend\Form\View\Helper\FormRow;
use Zend\View\Helper\Url;
use Zend\ServiceManager\ServiceLocatorInterface;

/**
 * Draw helper used to render the form
 *
 * @todo redesign
 */
class Form extends AbstractHelper
{
    /**
     * Draw helper service name
     */
    const SERVICE = 'webinodrawform';

    /**
     * @var DrawFormEvent
     */
    private $formEvent;

    /**
     * @var ServiceLocatorInterface
     */
    protected $forms;

    /**
     * @var FormRow
     */
    protected $formRow;

    /**
     * @var FormElement
     */
    protected $formElement;

    /**
     * @var FormElementErrors
     */
    protected $formElementErrors;

    /**
     * @var FormCollection
     */
    protected $formCollection;

    /**
     * @var Url
     */
    protected $url;

    /**
     * @var InstructionsRenderer
     */
    protected $instructionsRenderer;

    /**
     * @todo redesign
     * @param ServiceLocatorInterface $forms
     * @param FormRow $formRow
     * @param FormElement $formElement
     * @param FormElementErrors $formElementErrors
     * @param FormCollection $formCollection
     * @param Url $url
     * @param InstructionsRenderer $instructionsRenderer
     */
    public function __construct(
        ServiceLocatorInterface $forms,
        FormRow $formRow,
        FormElement $formElement,
        FormElementErrors $formElementErrors,
        FormCollection $formCollection,
        Url $url,
        InstructionsRenderer $instructionsRenderer
    ) {
        $this->forms                = $forms;
        $this->formRow              = $formRow;
        $this->formElement          = $formElement;
        $this->formElementErrors    = $formElementErrors;
        $this->formCollection       = $formCollection;
        $this->url                  = $url;
        $this->instructionsRenderer = $instructionsRenderer;
    }

    /**
     * @param NodeList $nodes
     * @param array $spec
     */
    public function __invoke(NodeList $nodes, array $spec)
    {
        $event = $this->getFormEvent();
        $event
            ->setHelper($this)
            ->clearSpec()
            ->setSpec($spec)
            ->setNodes($nodes);

        $cache = $this->getCache();
        if ($cache->load($event)) {
            return;
        }

        $form = $this->createForm($spec);
        $event->setForm($form);

        array_key_exists('trigger', $spec)
            and $this->trigger($spec['trigger'], $event);

        $this->drawNodes($nodes, $event->getSpec()->getArrayCopy());
        $cache->save($event);
    }

    /**
     * @return DrawFormEvent
     */
    public function getFormEvent()
    {
        if (null === $this->formEvent) {
            $this->setFormEvent(new DrawFormEvent);
        }
        return $this->formEvent;
    }

    /**
     * @param DrawFormEvent $event
     * @return $this
     */
    public function setFormEvent(DrawFormEvent $event)
    {
        $this->formEvent = $event;
        return $this;
    }

    /**
     * @param string $textDomain
     * @return $this
     */
    public function setTranslatorTextDomain($textDomain = 'default')
    {
        $this->formRow->setTranslatorTextDomain($textDomain);
        $this->formElement->setTranslatorTextDomain($textDomain);
        return $this;
    }

    /**
     * @param bool $bool
     * @return $this
     */
    public function setRenderErrors($bool = true)
    {
        $this->formRow->setRenderErrors($bool);
        return $this;
    }

    /**
     * @param array $spec
     * @return FormInterface
     * @throws Exception\RuntimeException
     */
    protected function createForm(array $spec)
    {
        if (empty($spec['form'])) {
            throw new Exception\RuntimeException(
                sprintf('Expected form option in: %s', print_r($spec, true))
            );
        }

        try {
            $form = clone $this->forms->get($spec['form']);
        } catch (\Exception $exc) {
            throw new Exception\RuntimeException(
                sprintf('Expected form in: %s; ' . $exc->getMessage(), print_r($spec, true)),
                $exc->getCode(),
                $exc
            );
        }

        if (!($form instanceof FormInterface)) {
            throw new Exception\LogicException('Expected form of type FormInterface');
        }

        if (isset($spec['route'])) {
            try {
                $routeFormAction = $this->resolveRouteFormAction($spec['route']);
            } catch (\Exception $exc) {
                throw new Exception\RuntimeException(
                    $exc->getMessage() . sprintf(' for %s', print_r($spec, true)),
                    $exc->getCode(),
                    $exc
                );
            }

            $form->setAttribute('action', $routeFormAction);
        }

        if (!empty($spec['populate'])) {
            $this->translate($spec['populate']);
            $form->populateValues($spec['populate']);
        }

        return $form;
    }

    /**
     * @param string|array $spec
     * @return string
     * @throws Exception\InvalidArgumentException
     * @throws Exception\RuntimeException
     */
    protected function resolveRouteFormAction($spec)
    {
        if (!is_string($spec) && !is_array($spec)) {
            throw new Exception\InvalidArgumentException('Expected string or array');
        }

        $route = is_array($spec) ? $spec : ['name' => $spec];

        if (empty($route['name'])) {
            throw new Exception\RuntimeException('Expected route name option');
        }

        $params  = !empty($route['params']) ? $route['params'] : [];
        $options = !empty($route['options']) ? $route['options'] : [];
        $reusedMatchedParams = !empty($route['reuseMatchedParams']) ? $route['reuseMatchedParams'] : [];

        try {
            $routeFormAction = $this->url->__invoke(
                $route['name'],
                $params,
                $options,
                $reusedMatchedParams
            );

        } catch (\Exception $exc) {
            throw new Exception\RuntimeException(
                sprintf(
                    'Expected route `%s`',
                    $route['name']
                ),
                $exc->getCode(),
                $exc
            );
        }

        return $routeFormAction;
    }

    /**
     * @todo refactor
     *
     * @param NodeList $nodes
     * @param array $spec
     * @return $this
     */
    public function drawNodes(NodeList $nodes, array $spec)
    {
        $form = $this->getFormEvent()->getForm();

        // set form attributes without class,
        // it will be appended later
        $formAttribs = (array) $form->getAttributes();
        $formClass   = '';
        if (isset($formAttribs['class'])) {
            $formClass = $formAttribs['class'];
            unset($formAttribs['class']);
        }
        $nodes->setAttribs($formAttribs);

        isset($spec['wrap'])
            or $spec['wrap'] = false;

        isset($spec['text_domain'])
            or $spec['text_domain'] = 'default';

        $this->setTranslatorTextDomain($spec['text_domain']);

        // defer sub-instructions
        $subInstructions = !empty($spec['instructions']) ? $spec['instructions'] : [];
        unset($spec['instructions']);
        parent::drawNodes($nodes, $spec);

        array_key_exists('render_errors', $spec)
            and $this->setRenderErrors($spec['render_errors']);

        $translation = $this->getVarTranslator()->createTranslation($this->getVars());
        foreach ($nodes as $node) {

            // append the form class to the node class
            $node->setAttribute('class', trim($node->getAttribute('class') . ' ' . $formClass));

            $childNodes = $nodes->create([$node]);
            if (empty($node->childNodes->length)) {
                // easy render
                $childNodes->setHtml($this->formCollection->__invoke($form, $spec['wrap']));

            } else {
                $this->matchTemplate($childNodes, $form);
            }

            $this->instructionsRenderer->expandInstructions($spec, $translation);
            if (!empty($subInstructions)) {
                foreach ($childNodes as $childNode) {
                    // sub-instructions
                    $this->instructionsRenderer
                        ->subInstructions(
                            [$childNode],
                            $subInstructions,
                            $translation
                        );
                }
            }
        }

        return $this;
    }

    // TODO DrawFormRenderer
    // todo decouple & redesign
    protected function matchTemplate(NodeList $nodes, FormInterface $form)
    {
        // todo injection
        $translator = $this->formRow->getTranslator();

        $matched  = [];
        $toRemove = [];
        $elements = $form->getElements();

        /* @var $node \WebinoDraw\Dom\Element */
        foreach ($nodes as $node) {
            /** @var \WebinoDraw\Dom\Document $ownerDocument */
            $ownerDocument = $node->ownerDocument;

            $nodePath = $node->getNodePath();
            $elementNodes = $ownerDocument->getXpath()->query('.//*[@name]', $node);
            /* @var $elementNode \WebinoDraw\Dom\Element */
            foreach ($elementNodes as $elementNode) {

                $elementName = $elementNode->getAttribute('name');
                $matched[$elementName] = true;

                if (!$form->has($elementName)) {
                    // remove node of the missing form element
                    $parentNode = $elementNode->parentNode;
                    if ('label' === $parentNode->nodeName) {
                        $parentNode->parentNode->removeChild($parentNode);
                    } else {
                        $toRemove[$nodePath][] = $elementName;
                        $elementNode->parentNode->removeChild($elementNode);
                    }
                    continue;
                }

                $elementNode->setAttribute('id', $elementName);

                /* @var $element \Zend\Form\Element */
                $element    = $form->get($elementName);
                $attributes = $element->getAttributes();

                // TODO remaining elements
                if (isset($attributes['type'])) {
                    switch ($attributes['type']) {
                        case 'checkbox':
                            /* @var $element \Zend\Form\Element\Checkbox */
                            $attributes['value'] = $element->getCheckedValue();
                            // todo checkbox use hidden element
                            break;
                        case 'multi_checkbox':
                            $multiNode = $ownerDocument->createDocumentFragment();
                            $multiNode->appendXml($this->formRow->__invoke($element));
                            $elementNode = $elementNode->parentNode->replaceChild($multiNode, $elementNode);
                            unset($multiNode);
                            break;
                        case 'select':
                            $selectNode = $ownerDocument->createDocumentFragment();
                            $selectNode->appendXml($this->formElement->__invoke($element));
                            $newNode = $selectNode->firstChild;
                            $elementNode->parentNode->replaceChild($newNode, $elementNode);
                            $elementNode = $newNode;
                            unset($selectNode);
                            unset($newNode);
                            break;

                        case 'text':
                        case 'email':
                        case 'submit':
                        case 'reset':
                        case 'button':

                            // set element node value if available
                            $value = $elementNode->hasAttribute('value')
                                ? $elementNode->getAttribute('value')
                                : $element->getValue();

                            $attributes['value'] = !empty($value) ? $translator->translate($value) : '';
                            unset($value);
                            break;
                    }
                }

                // glue form & template element class
                empty($attributes['class'])
                    or $attributes['class'] = trim($attributes['class'] . ' ' . $elementNode->getAttribute('class'));

                $subElementNodes = $nodes->create([$elementNode]);
                $subElementNodes->setAttribs($attributes);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

                // labels
                $subElementNodes->each(
                    'xpath=../span[name(..)="label"]|..//label[@for="' . $elementName . '"]',
                    function ($nodes) use ($element, $translator) {
                        $label = $translator->translate($element->getLabel());

                        /* @var $subNode \WebinoDraw\Dom\Element */
                        foreach ($nodes as $subNode) {
                            $subNode->nodeValue = !$subNode->isEmpty()
                                ? $translator->translate($subNode->nodeValue)
                                : $label;
                        }
                    }
                );

                // errors
                $messages = $element->getMessages();
                if (!empty($messages)) {

                    $errorNode = $ownerDocument->createDocumentFragment();
                    $errorNode->appendXml($this->formElementErrors->__invoke($element));

                    foreach ($subElementNodes as $subElementNode) {
                        if (empty($subElementNode->nextSibling)) {
                            $subElementNode->parentNode->appendChild($errorNode);
                        } else {
                            $subElementNode->parentNode->insertBefore($errorNode, $subElementNode);
                        }
                    }
                }
            }

            // auto draw hidden nodes
            /** @var \Zend\Form\Element $element */
            foreach ($elements as $element) {
                $attributes = $element->getAttributes();
                if (empty($attributes['type'])
                    || 'hidden' !== $attributes['type']
                ) {
                    continue;
                }

                // skip matched elements
                if (isset($matched[$attributes['name']])) {
                    continue;
                }

                $hiddenNode = $ownerDocument->createDocumentFragment();
                $xhtml      = (string) $this->formRow->__invoke($element);

                $hiddenNode->appendXml($xhtml);
                if (!$hiddenNode->hasChildNodes()) {
                    throw new Exception\RuntimeException('Invalid XHTML ' . $xhtml);
                }
                $node->appendChild($hiddenNode);
            }
        }

        // remove labels of missing elements
        foreach ($toRemove as $nodePath => $elementNames) {
            foreach ($elementNames as $elementName) {
                $nodes->remove('xpath=' . $nodePath . '//label[@for="' . $elementName . '"]');
            }
        }
    }
}


1			<?php
2			/**
3			* Webino (http://webino.sk)
4			*
5			* @link https://github.com/webino/WebinoDraw for the canonical source repository
6			* @copyright Copyright (c) 2012-2017 Webino, s. r. o. (http://webino.sk)
7			* @author Peter Bačinský <[email protected]>
8			* @license BSD-3-Clause
9			*/
10
11			namespace WebinoDraw\Draw\Helper;
12
13			use WebinoDraw\Event\DrawFormEvent;
14			use WebinoDraw\Dom\NodeList;
15			use WebinoDraw\Exception;
16			use WebinoDraw\Instructions\InstructionsRenderer;
17			use Zend\Form\FormInterface;
18			use Zend\Form\View\Helper\FormCollection;
19			use WebinoDraw\Form\View\Helper\FormElement;
20			use Zend\Form\View\Helper\FormElementErrors;
21			use Zend\Form\View\Helper\FormRow;
22			use Zend\View\Helper\Url;
23			use Zend\ServiceManager\ServiceLocatorInterface;
24
25			/**
26			* Draw helper used to render the form
27			*
28			* @todo redesign
29			*/
30			class Form extends AbstractHelper
31			{
32			/**
33			* Draw helper service name
34			*/
35			const SERVICE = 'webinodrawform';
36
37			/**
38			* @var DrawFormEvent
39			*/
40			private $formEvent;
41
42			/**
43			* @var ServiceLocatorInterface
44			*/
45			protected $forms;
46
47			/**
48			* @var FormRow
49			*/
50			protected $formRow;
51
52			/**
53			* @var FormElement
54			*/
55			protected $formElement;
56
57			/**
58			* @var FormElementErrors
59			*/
60			protected $formElementErrors;
61
62			/**
63			* @var FormCollection
64			*/
65			protected $formCollection;
66
67			/**
68			* @var Url
69			*/
70			protected $url;
71
72			/**
73			* @var InstructionsRenderer
74			*/
75			protected $instructionsRenderer;
76
77			/**
78			* @todo redesign
79			* @param ServiceLocatorInterface $forms
80			* @param FormRow $formRow
81			* @param FormElement $formElement
82			* @param FormElementErrors $formElementErrors
83			* @param FormCollection $formCollection
84			* @param Url $url
85			* @param InstructionsRenderer $instructionsRenderer
86			*/
87			public function __construct(
88			ServiceLocatorInterface $forms,
89			FormRow $formRow,
90			FormElement $formElement,
91			FormElementErrors $formElementErrors,
92			FormCollection $formCollection,
93			Url $url,
94			InstructionsRenderer $instructionsRenderer
95			) {
96			$this->forms = $forms;
97			$this->formRow = $formRow;
98			$this->formElement = $formElement;
99			$this->formElementErrors = $formElementErrors;
100			$this->formCollection = $formCollection;
101			$this->url = $url;
102			$this->instructionsRenderer = $instructionsRenderer;
103			}
104
105			/**
106			* @param NodeList $nodes
107			* @param array $spec
108			*/
109			public function __invoke(NodeList $nodes, array $spec)
110			{
111			$event = $this->getFormEvent();
112			$event
113			->setHelper($this)
114			->clearSpec()
115			->setSpec($spec)
116			->setNodes($nodes);
117
118			$cache = $this->getCache();
119			if ($cache->load($event)) {
120			return;
121			}
122
123			$form = $this->createForm($spec);
124			$event->setForm($form);
125
126			array_key_exists('trigger', $spec)
127			and $this->trigger($spec['trigger'], $event);
128
129			$this->drawNodes($nodes, $event->getSpec()->getArrayCopy());
130			$cache->save($event);
131			}
132
133			/**
134			* @return DrawFormEvent
135			*/
136			public function getFormEvent()
137			{
138			if (null === $this->formEvent) {
139			$this->setFormEvent(new DrawFormEvent);
140			}
141			return $this->formEvent;
142			}
143
144			/**
145			* @param DrawFormEvent $event
146			* @return $this
147			*/
148			public function setFormEvent(DrawFormEvent $event)
149			{
150			$this->formEvent = $event;
151			return $this;
152			}
153
154			/**
155			* @param string $textDomain
156			* @return $this
157			*/
158			public function setTranslatorTextDomain($textDomain = 'default')
159			{
160			$this->formRow->setTranslatorTextDomain($textDomain);
161			$this->formElement->setTranslatorTextDomain($textDomain);
162			return $this;
163			}
164
165			/**
166			* @param bool $bool
167			* @return $this
168			*/
169			public function setRenderErrors($bool = true)
170			{
171			$this->formRow->setRenderErrors($bool);
172			return $this;
173			}
174
175			/**
176			* @param array $spec
177			* @return FormInterface
178			* @throws Exception\RuntimeException
179			*/
180			protected function createForm(array $spec)
181			{
182			if (empty($spec['form'])) {
183			throw new Exception\RuntimeException(
184			sprintf('Expected form option in: %s', print_r($spec, true))
185			);
186			}
187
188			try {
189			$form = clone $this->forms->get($spec['form']);
190			} catch (\Exception $exc) {
191			throw new Exception\RuntimeException(
192			sprintf('Expected form in: %s; ' . $exc->getMessage(), print_r($spec, true)),
193			$exc->getCode(),
194			$exc
195			);
196			}
197
198			if (!($form instanceof FormInterface)) {
199			throw new Exception\LogicException('Expected form of type FormInterface');
200			}
201
202			if (isset($spec['route'])) {
203			try {
204			$routeFormAction = $this->resolveRouteFormAction($spec['route']);
205			} catch (\Exception $exc) {
206			throw new Exception\RuntimeException(
207			$exc->getMessage() . sprintf(' for %s', print_r($spec, true)),
208			$exc->getCode(),
209			$exc
210			);
211			}
212
213			$form->setAttribute('action', $routeFormAction);
214			}
215
216			if (!empty($spec['populate'])) {
217			$this->translate($spec['populate']);
218			$form->populateValues($spec['populate']);
219			}
220
221			return $form;
222			}
223
224			/**
225			* @param string\|array $spec
226			* @return string
227			* @throws Exception\InvalidArgumentException
228			* @throws Exception\RuntimeException
229			*/
230			protected function resolveRouteFormAction($spec)
231			{
232			if (!is_string($spec) && !is_array($spec)) {
233			throw new Exception\InvalidArgumentException('Expected string or array');
234			}
235
236			$route = is_array($spec) ? $spec : ['name' => $spec];
237
238			if (empty($route['name'])) {
239			throw new Exception\RuntimeException('Expected route name option');
240			}
241
242			$params = !empty($route['params']) ? $route['params'] : [];
243			$options = !empty($route['options']) ? $route['options'] : [];
244			$reusedMatchedParams = !empty($route['reuseMatchedParams']) ? $route['reuseMatchedParams'] : [];
245
246			try {
247			$routeFormAction = $this->url->__invoke(
248			$route['name'],
249			$params,
250			$options,
251			$reusedMatchedParams
252			);
253
254			} catch (\Exception $exc) {
255			throw new Exception\RuntimeException(
256			sprintf(
257			'Expected route `%s`',
258			$route['name']
259			),
260			$exc->getCode(),
261			$exc
262			);
263			}
264
265			return $routeFormAction;
266			}
267
268			/**
269			* @todo refactor
270			*
271			* @param NodeList $nodes
272			* @param array $spec
273			* @return $this
274			*/
275			public function drawNodes(NodeList $nodes, array $spec)
276			{
277			$form = $this->getFormEvent()->getForm();
278
279			// set form attributes without class,
280			// it will be appended later
281			$formAttribs = (array) $form->getAttributes();
282			$formClass = '';
283			if (isset($formAttribs['class'])) {
284			$formClass = $formAttribs['class'];
285			unset($formAttribs['class']);
286			}
287			$nodes->setAttribs($formAttribs);
288
289			isset($spec['wrap'])
290			or $spec['wrap'] = false;
291
292			isset($spec['text_domain'])
293			or $spec['text_domain'] = 'default';
294
295			$this->setTranslatorTextDomain($spec['text_domain']);
296
297			// defer sub-instructions
298			$subInstructions = !empty($spec['instructions']) ? $spec['instructions'] : [];
299			unset($spec['instructions']);
300			parent::drawNodes($nodes, $spec);
301
302			array_key_exists('render_errors', $spec)
303			and $this->setRenderErrors($spec['render_errors']);
304
305			$translation = $this->getVarTranslator()->createTranslation($this->getVars());
306			foreach ($nodes as $node) {
307
308			// append the form class to the node class
309			$node->setAttribute('class', trim($node->getAttribute('class') . ' ' . $formClass));
310
311			$childNodes = $nodes->create([$node]);
312			if (empty($node->childNodes->length)) {
313			// easy render
314			$childNodes->setHtml($this->formCollection->__invoke($form, $spec['wrap']));
			0 ignored issues – show Bug introduced 2015-12-15 01:22 UTC by Report Bug Copy Issue Report It seems like `$this->formCollection->_...e($form, $spec['wrap'])` targeting `Zend\Form\View\Helper\FormCollection::__invoke()` can also be of type `object<Zend\Form\View\Helper\FormCollection>`; however, `WebinoDraw\Dom\NodeList::setHtml()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
315			} else {
316			$this->matchTemplate($childNodes, $form);
317			}
318
319			$this->instructionsRenderer->expandInstructions($spec, $translation);
320			if (!empty($subInstructions)) {
321			foreach ($childNodes as $childNode) {
322			// sub-instructions
323			$this->instructionsRenderer
324			->subInstructions(
325			[$childNode],
326			$subInstructions,
327			$translation
328			);
329			}
330			}
331			}
332
333			return $this;
334			}
335
336			// TODO DrawFormRenderer
337			// todo decouple & redesign
338			protected function matchTemplate(NodeList $nodes, FormInterface $form)
339			{
340			// todo injection
341			$translator = $this->formRow->getTranslator();
342
343			$matched = [];
344			$toRemove = [];
345			$elements = $form->getElements();
346
347			/* @var $node \WebinoDraw\Dom\Element */
348			foreach ($nodes as $node) {
349			/** @var \WebinoDraw\Dom\Document $ownerDocument */
350			$ownerDocument = $node->ownerDocument;
351
352			$nodePath = $node->getNodePath();
353			$elementNodes = $ownerDocument->getXpath()->query('.//*[@name]', $node);
354			/* @var $elementNode \WebinoDraw\Dom\Element */
355			foreach ($elementNodes as $elementNode) {
356
357			$elementName = $elementNode->getAttribute('name');
358			$matched[$elementName] = true;
359
360			if (!$form->has($elementName)) {
361			// remove node of the missing form element
362			$parentNode = $elementNode->parentNode;
363			if ('label' === $parentNode->nodeName) {
364			$parentNode->parentNode->removeChild($parentNode);
365			} else {
366			$toRemove[$nodePath][] = $elementName;
367			$elementNode->parentNode->removeChild($elementNode);
368			}
369			continue;
370			}
371
372			$elementNode->setAttribute('id', $elementName);
373
374			/* @var $element \Zend\Form\Element */
375			$element = $form->get($elementName);
376			$attributes = $element->getAttributes();
377
378			// TODO remaining elements
379			if (isset($attributes['type'])) {
380			switch ($attributes['type']) {
381			case 'checkbox':
382			/* @var $element \Zend\Form\Element\Checkbox */
383			$attributes['value'] = $element->getCheckedValue();
384			// todo checkbox use hidden element
385			break;
386			case 'multi_checkbox':
387			$multiNode = $ownerDocument->createDocumentFragment();
388			$multiNode->appendXml($this->formRow->__invoke($element));
389			$elementNode = $elementNode->parentNode->replaceChild($multiNode, $elementNode);
390			unset($multiNode);
391			break;
392			case 'select':
393			$selectNode = $ownerDocument->createDocumentFragment();
394			$selectNode->appendXml($this->formElement->__invoke($element));
395			$newNode = $selectNode->firstChild;
396			$elementNode->parentNode->replaceChild($newNode, $elementNode);
397			$elementNode = $newNode;
398			unset($selectNode);
399			unset($newNode);
400			break;
401
402			case 'text':
403			case 'email':
404			case 'submit':
405			case 'reset':
406			case 'button':
407
408			// set element node value if available
409			$value = $elementNode->hasAttribute('value')
410			? $elementNode->getAttribute('value')
411			: $element->getValue();
412
413			$attributes['value'] = !empty($value) ? $translator->translate($value) : '';
414			unset($value);
415			break;
416			}
417			}
418
419			// glue form & template element class
420			empty($attributes['class'])
421			or $attributes['class'] = trim($attributes['class'] . ' ' . $elementNode->getAttribute('class'));
422
423			$subElementNodes = $nodes->create([$elementNode]);
424			$subElementNodes->setAttribs($attributes);
			0 ignored issues – show Bug introduced 2016-08-02 17:37 UTC by Report Bug Copy Issue Report It seems like `$attributes` defined by `$element->getAttributes()` on line `376` can also be of type `object<Traversable>`; however, `WebinoDraw\Dom\NodeList::setAttribs()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
425
426			// labels
427			$subElementNodes->each(
428			'xpath=../span[name(..)="label"]\|..//label[@for="' . $elementName . '"]',
429			function ($nodes) use ($element, $translator) {
430			$label = $translator->translate($element->getLabel());
431
432			/* @var $subNode \WebinoDraw\Dom\Element */
433			foreach ($nodes as $subNode) {
434			$subNode->nodeValue = !$subNode->isEmpty()
435			? $translator->translate($subNode->nodeValue)
436			: $label;
437			}
438			}
439			);
440
441			// errors
442			$messages = $element->getMessages();
443			if (!empty($messages)) {
444
445			$errorNode = $ownerDocument->createDocumentFragment();
446			$errorNode->appendXml($this->formElementErrors->__invoke($element));
447
448			foreach ($subElementNodes as $subElementNode) {
449			if (empty($subElementNode->nextSibling)) {
450			$subElementNode->parentNode->appendChild($errorNode);
451			} else {
452			$subElementNode->parentNode->insertBefore($errorNode, $subElementNode);
453			}
454			}
455			}
456			}
457
458			// auto draw hidden nodes
459			/** @var \Zend\Form\Element $element */
460			foreach ($elements as $element) {
461			$attributes = $element->getAttributes();
462			if (empty($attributes['type'])
463			\|\| 'hidden' !== $attributes['type']
464			) {
465			continue;
466			}
467
468			// skip matched elements
469			if (isset($matched[$attributes['name']])) {
470			continue;
471			}
472
473			$hiddenNode = $ownerDocument->createDocumentFragment();
474			$xhtml = (string) $this->formRow->__invoke($element);
475
476			$hiddenNode->appendXml($xhtml);
477			if (!$hiddenNode->hasChildNodes()) {
478			throw new Exception\RuntimeException('Invalid XHTML ' . $xhtml);
479			}
480			$node->appendChild($hiddenNode);
481			}
482			}
483
484			// remove labels of missing elements
485			foreach ($toRemove as $nodePath => $elementNames) {
486			foreach ($elementNames as $elementName) {
487			$nodes->remove('xpath=' . $nodePath . '//label[@for="' . $elementName . '"]');
488			}
489			}
490			}
491			}
492

webino / WebinoDraw

Form::matchTemplate() F last analyzed 2019-12-25 16:24 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Form::matchTemplate() F
last analyzed 2019-12-25 16:24 UTC