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

NodeList::create() A
last analyzed 2019-12-25 16:24 UTC

↳ Parent: NodeList

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?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\Dom;

use ArrayObject;
use DOMNodeList;
use IteratorAggregate;
use IteratorIterator;
use WebinoDraw\Exception;
use WebinoDraw\View\Helper\EscapeHtmlTrait;

/**
 * Batch DOMElement manipulation
 */
class NodeList implements IteratorAggregate
{
    use EscapeHtmlTrait;

    /**
     * @var IteratorIterator
     */
    protected $nodes;

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

    /**
     * @param Locator $locator
     * @param array|DOMNodeList $nodes DOMNodes in array or DOMNodeList
     */
    public function __construct(Locator $locator, $nodes = null)
    {
        $this->locator = $locator;
        empty($nodes) or $this->setNodes($nodes);
    }

    /**
     * @param array|DOMNodeList $nodes DOMNodes in array or DOMNodeList
     * @return $this
     */
    public function create($nodes)
    {
        return new self($this->locator, $nodes);
    }

    /**
     * @return IteratorIterator
     */
    public function getNodes()
    {
        if (null === $this->nodes) {
            $this->setNodes([]);
        }
        return $this->nodes;
    }

    /**
     * @param array|DOMNodeList|IteratorIterator $nodes
     * @return $this
     * @throws Exception\InvalidArgumentException
     */
    public function setNodes($nodes)
    {
        if ($nodes instanceof IteratorIterator) {
            $this->nodes = $nodes;

        } elseif (is_array($nodes)) {
            $this->nodes = new IteratorIterator(new ArrayObject($nodes));

        } elseif ($nodes instanceof DOMNodeList) {
            $this->nodes = new IteratorIterator($nodes);

        } else {
            throw new Exception\InvalidArgumentException('Expected nodes as array|DOMNodelist');
        }

        foreach ($this->nodes as $node) {
            // inject locator to node
            $node instanceof Locator\LocatorAwareInterface
                and $node->setLocator($this->locator);
        }

        return $this;
    }

    /**
     * @return \Traversable
     */
    public function getIterator()
    {
        return $this->getNodes()->getInnerIterator();
    }

    /**
     * Set nodes text value
     *
     * @param string $value
     * @param Callable $preSet Modify and return value, passed parameters $node, $value
     * @return $this
     */
    public function setValue($value, $preSet = null)
    {
        $escapeHtml = $this->getEscapeHtml();
        foreach ($this as $node) {
            $nodeValue = is_callable($preSet) ? $preSet($node, $value, $this) : $value;
            $node->nodeValue = $escapeHtml($nodeValue);
        }

        return $this;
    }

    /**
     * Set nodes html value
     *
     * @param string $xhtml
     * @param Callable $preSet Modify and return xhtml, passed parameters $node, $xhtml
     * @return $this
     */
    public function setHtml($xhtml, $preSet = null)
    {
        foreach ($this as $node) {
            $nodeXhtml = is_callable($preSet) ? $preSet($node, $xhtml, $this) : $xhtml;
            $node->nodeValue = '';

            if (empty($nodeXhtml) || !($node instanceof Element)) {
                continue;
            }

            $frag = $node->ownerDocument->createDocumentFragment();
            $frag->appendXml($nodeXhtml);
            $node->appendChild($frag);
        }

        return $this;
    }

    /**
     * Append XHTML to nodes
     *
     * @param string $xhtml Valid XHTML
     * @return $this Newly created nodes
     */
    public function appendHtml($xhtml)
    {
        $nodes = [];
        $childNode = null;

        foreach ($this as $node) {
            if (!($node instanceof Element)) {
                continue;
            }

            if (empty($childNode)) {
                $childNode = $node->ownerDocument->createDocumentFragment();
                $childNode->appendXml($xhtml);
            }

            $nodes[] = $node->appendChild(clone $childNode);
        }

        return $this->create($nodes);
    }

    /**
     * Set nodes attributes
     *
     * @param array $attribs Attributes to set
     * @param Callable $preSet Modify and return value, assed parameters $node, $value
     * @return $this
     */
    public function setAttribs(array $attribs, $preSet = null)
    {
        foreach ($this as $node) {
            if (!($node instanceof Element)) {
                continue;
            }

            // prepare callback
            $callback = $preSet
                ? function ($value) use ($node, $preSet) {
                    return $preSet($node, $value, $this);
                }
                : null;

            $node->setAttributes($attribs, $callback);
        }

        return $this;
    }

    /**
     * Replace node with XHTML code
     *
     * @param string $xhtml XHTML to replace node
     * @param Callable $preSet Modify and return xhtml, assed parameters $node, $xhtml
     * @return $this
     */
    public function replace($xhtml, $preSet = null)
    {
        $remove   = [];
        $nodeList = new ArrayObject;

        foreach ($this as $node) {
            if (!($node instanceof Element)) {
                continue;
            }

            $nodeXhtml = is_callable($preSet) ? $preSet($node, $xhtml, $this) : $xhtml;
            if (empty($nodeXhtml)) {
                $node->nodeValue = '';
                continue;
            }

            $frag = $node->ownerDocument->createDocumentFragment();
            $frag->appendXml($nodeXhtml);

            $nodeList[] = $node->parentNode->insertBefore($frag, $node);
            $remove[]   = $node;
        }

        foreach ($remove as $node) {
            $node->parentNode->removeChild($node);
        }

        $this->nodes = new IteratorIterator($nodeList);
        return $this;
    }

    /**
     * Remove target nodes
     *
     * @param string $locator CSS selector or XPath (xpath=)
     * @return $this
     */
    public function remove($locator = '.')
    {
        if (empty($locator)) {
            return $this;
        }

        $remove = [];
        $this->each(
            $locator,
            function (NodeList $nodes) use (&$remove) {
                $remove = array_merge($remove, (array) $nodes->getIterator());
            }
        );

        foreach ($remove as $node) {
            empty($node->parentNode)
                or $node->parentNode->removeChild($node);
        }

        return $this;
    }

    /**
     * Perform callback on each node that match the locator
     *
     * @param string $locator
     * @param Callable $callback The NodeList parameter is passed
     * @return $this
     * @throws Exception\RuntimeException
     */
    public function each($locator, $callback)
    {
        if (empty($locator)) {
            return $this;
        }

        $xpath = $this->locator->set($locator)->xpathMatchAny();
        foreach ($this as $node) {
            if (!($node->ownerDocument instanceof Document)) {
                throw new Exception\RuntimeException('Expects `' . Document::class . '` with xpath');
            }

            $nodes = $node->ownerDocument->getXpath()->query($xpath, $node);
            foreach ($nodes as $subNode) {
                $callback($this->create([$subNode]));
            }
        }

        return $this;
    }

    /**
     * Return nodes in array
     *
     * Error-free nodes
     * manipulation in a loop.
     *
     * @return array
     */
    public function toArray()
    {
        $return = [];
        foreach ($this as $node) {
            (null === $node) or $return[] = $node;
        }
        return $return;
    }
}


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\Dom;
12
13			use ArrayObject;
14			use DOMNodeList;
15			use IteratorAggregate;
16			use IteratorIterator;
17			use WebinoDraw\Exception;
18			use WebinoDraw\View\Helper\EscapeHtmlTrait;
19
20			/**
21			* Batch DOMElement manipulation
22			*/
23			class NodeList implements IteratorAggregate
24			{
25			use EscapeHtmlTrait;
26
27			/**
28			* @var IteratorIterator
29			*/
30			protected $nodes;
31
32			/**
33			* @var Locator
34			*/
35			protected $locator;
36
37			/**
38			* @param Locator $locator
39			* @param array\|DOMNodeList $nodes DOMNodes in array or DOMNodeList
40			*/
41			public function __construct(Locator $locator, $nodes = null)
42			{
43			$this->locator = $locator;
44			empty($nodes) or $this->setNodes($nodes);
45			}
46
47			/**
48			* @param array\|DOMNodeList $nodes DOMNodes in array or DOMNodeList
49			* @return $this
50			*/
51			public function create($nodes)
52			{
53			return new self($this->locator, $nodes);
54			}
55
56			/**
57			* @return IteratorIterator
58			*/
59			public function getNodes()
60			{
61			if (null === $this->nodes) {
62			$this->setNodes([]);
63			}
64			return $this->nodes;
65			}
66
67			/**
68			* @param array\|DOMNodeList\|IteratorIterator $nodes
69			* @return $this
70			* @throws Exception\InvalidArgumentException
71			*/
72			public function setNodes($nodes)
73			{
74			if ($nodes instanceof IteratorIterator) {
75			$this->nodes = $nodes;
76
77			} elseif (is_array($nodes)) {
78			$this->nodes = new IteratorIterator(new ArrayObject($nodes));
79
80			} elseif ($nodes instanceof DOMNodeList) {
81			$this->nodes = new IteratorIterator($nodes);
82
83			} else {
84			throw new Exception\InvalidArgumentException('Expected nodes as array\|DOMNodelist');
85			}
86
87			foreach ($this->nodes as $node) {
88			// inject locator to node
89			$node instanceof Locator\LocatorAwareInterface
90			and $node->setLocator($this->locator);
91			}
92
93			return $this;
94			}
95
96			/**
97			* @return \Traversable
98			*/
99			public function getIterator()
100			{
101			return $this->getNodes()->getInnerIterator();
102			}
103
104			/**
105			* Set nodes text value
106			*
107			* @param string $value
108			* @param Callable $preSet Modify and return value, passed parameters $node, $value
109			* @return $this
110			*/
111			public function setValue($value, $preSet = null)
112			{
113			$escapeHtml = $this->getEscapeHtml();
114			foreach ($this as $node) {
115			$nodeValue = is_callable($preSet) ? $preSet($node, $value, $this) : $value;
116			$node->nodeValue = $escapeHtml($nodeValue);
117			}
118
119			return $this;
120			}
121
122			/**
123			* Set nodes html value
124			*
125			* @param string $xhtml
126			* @param Callable $preSet Modify and return xhtml, passed parameters $node, $xhtml
127			* @return $this
128			*/
129			public function setHtml($xhtml, $preSet = null)
130			{
131			foreach ($this as $node) {
132			$nodeXhtml = is_callable($preSet) ? $preSet($node, $xhtml, $this) : $xhtml;
133			$node->nodeValue = '';
134
135			if (empty($nodeXhtml) \|\| !($node instanceof Element)) {
136			continue;
137			}
138
139			$frag = $node->ownerDocument->createDocumentFragment();
140			$frag->appendXml($nodeXhtml);
141			$node->appendChild($frag);
142			}
143
144			return $this;
145			}
146
147			/**
148			* Append XHTML to nodes
149			*
150			* @param string $xhtml Valid XHTML
151			* @return $this Newly created nodes
152			*/
153			public function appendHtml($xhtml)
154			{
155			$nodes = [];
156			$childNode = null;
157
158			foreach ($this as $node) {
159			if (!($node instanceof Element)) {
160			continue;
161			}
162
163			if (empty($childNode)) {
164			$childNode = $node->ownerDocument->createDocumentFragment();
165			$childNode->appendXml($xhtml);
166			}
167
168			$nodes[] = $node->appendChild(clone $childNode);
169			}
170
171			return $this->create($nodes);
172			}
173
174			/**
175			* Set nodes attributes
176			*
177			* @param array $attribs Attributes to set
178			* @param Callable $preSet Modify and return value, assed parameters $node, $value
179			* @return $this
180			*/
181			public function setAttribs(array $attribs, $preSet = null)
182			{
183			foreach ($this as $node) {
184			if (!($node instanceof Element)) {
185			continue;
186			}
187
188			// prepare callback
189			$callback = $preSet
190			? function ($value) use ($node, $preSet) {
191			return $preSet($node, $value, $this);
192			}
193			: null;
194
195			$node->setAttributes($attribs, $callback);
196			}
197
198			return $this;
199			}
200
201			/**
202			* Replace node with XHTML code
203			*
204			* @param string $xhtml XHTML to replace node
205			* @param Callable $preSet Modify and return xhtml, assed parameters $node, $xhtml
206			* @return $this
207			*/
208			public function replace($xhtml, $preSet = null)
209			{
210			$remove = [];
211			$nodeList = new ArrayObject;
212
213			foreach ($this as $node) {
214			if (!($node instanceof Element)) {
215			continue;
216			}
217
218			$nodeXhtml = is_callable($preSet) ? $preSet($node, $xhtml, $this) : $xhtml;
219			if (empty($nodeXhtml)) {
220			$node->nodeValue = '';
221			continue;
222			}
223
224			$frag = $node->ownerDocument->createDocumentFragment();
225			$frag->appendXml($nodeXhtml);
226
227			$nodeList[] = $node->parentNode->insertBefore($frag, $node);
228			$remove[] = $node;
229			}
230
231			foreach ($remove as $node) {
232			$node->parentNode->removeChild($node);
233			}
234
235			$this->nodes = new IteratorIterator($nodeList);
236			return $this;
237			}
238
239			/**
240			* Remove target nodes
241			*
242			* @param string $locator CSS selector or XPath (xpath=)
243			* @return $this
244			*/
245			public function remove($locator = '.')
246			{
247			if (empty($locator)) {
248			return $this;
249			}
250
251			$remove = [];
252			$this->each(
253			$locator,
254			function (NodeList $nodes) use (&$remove) {
255			$remove = array_merge($remove, (array) $nodes->getIterator());
256			}
257			);
258
259			foreach ($remove as $node) {
260			empty($node->parentNode)
261			or $node->parentNode->removeChild($node);
262			}
263
264			return $this;
265			}
266
267			/**
268			* Perform callback on each node that match the locator
269			*
270			* @param string $locator
271			* @param Callable $callback The NodeList parameter is passed
272			* @return $this
273			* @throws Exception\RuntimeException
274			*/
275			public function each($locator, $callback)
276			{
277			if (empty($locator)) {
278			return $this;
279			}
280
281			$xpath = $this->locator->set($locator)->xpathMatchAny();
282			foreach ($this as $node) {
283			if (!($node->ownerDocument instanceof Document)) {
284			throw new Exception\RuntimeException('Expects `' . Document::class . '` with xpath');
285			}
286
287			$nodes = $node->ownerDocument->getXpath()->query($xpath, $node);
288			foreach ($nodes as $subNode) {
289			$callback($this->create([$subNode]));
290			}
291			}
292
293			return $this;
294			}
295
296			/**
297			* Return nodes in array
298			*
299			* Error-free nodes
300			* manipulation in a loop.
301			*
302			* @return array
303			*/
304			public function toArray()
305			{
306			$return = [];
307			foreach ($this as $node) {
308			(null === $node) or $return[] = $node;
309			}
310			return $return;
311			}
312			}
313

webino / WebinoDraw

NodeList::create() A last analyzed 2019-12-25 16:24 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

NodeList::create() A
last analyzed 2019-12-25 16:24 UTC