Loop::preLoopInternal() - Code Metrics - Inspection of "Updated Manipulator\Plugin\Loop::preLoopInternal()..." - webino/WebinoDraw - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 38b232...8588db )

by Peter

created 2016-02-26 06:30 UTC

Loop::preLoopInternal() D

↳ Parent: Loop

Complexity

Conditions	13
Paths	434

Size

Total Lines	70
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	3	Features	0

Metric	Value
c	7
b	3
f	0
dl	0
loc	70
rs	4.0321
cc	13
eloc	42
nc	434
nop	1

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-2015 Webino, s. r. o. (http://webino.sk)
 * @author      Peter Bačinský <[email protected]>
 * @license     BSD-3-Clause
 */

namespace WebinoDraw\Manipulator\Plugin;

use ArrayObject;
use WebinoDraw\Cache\DrawCache;
use WebinoDraw\Dom\Element;
use WebinoDraw\Dom\NodeList;
use WebinoDraw\Draw\Helper\AbstractHelper;
use WebinoDraw\Draw\LoopHelperPluginManager;
use WebinoDraw\Exception;
use WebinoDraw\Instructions\InstructionsRenderer;

/**
 * Class Loop
 */
class Loop extends AbstractPlugin implements PreLoopPluginInterface
{
    /**
     * @var InstructionsRenderer
     */
    protected $instructionsRenderer;

    /**
     * @var LoopHelperPluginManager
     */
    protected $loopHelpers;

    /**
     * @var DrawCache
     */
    protected $cache;

    /**
     * @param InstructionsRenderer $instructionsRenderer
     * @param LoopHelperPluginManager $loopHelpers
     * @param DrawCache $cache
     */
    public function __construct(
        InstructionsRenderer $instructionsRenderer,
        LoopHelperPluginManager $loopHelpers,
        DrawCache $cache
    ) {
        $this->instructionsRenderer = $instructionsRenderer;
        $this->loopHelpers = $loopHelpers;
        $this->cache = $cache;
    }

    /**
     * @param PluginArgument $arg
     */
    public function preLoop(PluginArgument $arg)
    {
        $spec = $arg->getSpec();
        if (empty($spec['loop'])) {
            return;
        }

        if (empty($spec['cache'])) {
            $this->preLoopInternal($arg);
            return;
        }

        $event = $arg->getHelper()->getEvent();
        $nodes = $arg->getNodes();

        foreach ($nodes as $node) {

            $parentNodes = $nodes->create([$node->parentNode]);
            $loopEvent   = clone $event;
            $loopEvent->setNodes($parentNodes);

            if ($this->cache->load($loopEvent)) {
                continue;
            }

            $localArg = clone $arg;
            $localArg->setNodes($nodes->create([$node]));

            $this->preLoopInternal($localArg);
            $this->cache->save($loopEvent);
        }
    }

    /**
     * @param PluginArgument $arg
     * @throws Exception\MissingPropertyException
     */
    protected function preLoopInternal(PluginArgument $arg)
    {
        $spec = $arg->getSpec();
        $translation = $arg->getTranslation();
        $varTranslation = $translation->makeVarKeys($translation);

        $translation->containsVar($spec['loop']['base'])
            and $varTranslation->translate($spec['loop']['base']);

        if (empty($spec['loop']['base'])) {
            throw new Exception\MissingPropertyException(
                sprintf('Loop base expected in: %s', print_r($spec, true))
            );
        }

        $arg->stopManipulation();

        $nodes = $arg->getNodes();

        isset($spec['loop']['offset']) && $translation->containsVar($spec['loop']['offset'])
            and $varTranslation->translate($spec['loop']['offset']);

        // TODO spec object default
        empty($spec['loop']['offset'])
            and $spec['loop']['offset'] = 0;

        isset($spec['loop']['length']) && $translation->containsVar($spec['loop']['length'])
            and $varTranslation->translate($spec['loop']['length']);

        // TODO spec object default
        empty($spec['loop']['length'])
            and $spec['loop']['length'] = null;

        // TODO spec object
        $arg->setSpec($spec);

        $helper = $arg->getHelper();
        if (!$translation->offsetExists($spec['loop']['base'])
            && $helper instanceof AbstractHelper
        ) {
            $varTranslator = $helper->getVarTranslator();
            $translation->offsetSet(
                $spec['loop']['base'],
                $varTranslator->getTranslation()->offsetGet($spec['loop']['base'])
            );
        }

        $items = array_slice(
            (array) $translation->fetch($spec['loop']['base']),
            $spec['loop']['offset'],
            $spec['loop']['length'],
            true
        );

        if (empty($items)) {
            $this->nothingToLoop($arg);
            return;
        }

        empty($spec['loop']['shuffle'])
            or shuffle($items);

        $this->instructionsRenderer
            ->expandInstructions($spec, $translation)
            ->expandInstructions($spec['loop'], $translation);

        // TODO spec object
        $arg->setSpec($spec);
        $this->nodesLoop($nodes, $items, $arg);
    }

    /**
     * @param PluginArgument $arg
     */
    protected function nothingToLoop(PluginArgument $arg)
    {
        $spec = $arg->getSpec();
        if (!array_key_exists('onEmpty', $spec['loop'])) {
            return;
        }

        $helper = $arg->getHelper();
        $nodes  = $arg->getNodes();
        $translation = $arg->getTranslation();
        $onEmptySpec = $spec['loop']['onEmpty'];

        if (!empty($onEmptySpec['locator'])) {
            $this->instructionsRenderer->subInstructions($nodes, [$onEmptySpec], $translation);
            return;
        }

        $this->instructionsRenderer->expandInstructions($onEmptySpec, $translation);
        empty($onEmptySpec['instructions'])
            or $this->instructionsRenderer->subInstructions(
                $nodes,
                $onEmptySpec['instructions'],
                $translation
            );

        $helper->manipulateNodes($nodes, $onEmptySpec, $translation);
    }

    /**
     * @param NodeList $nodes
     * @param array $items
     * @param PluginArgument $arg
     * @return self
     */
    protected function nodesLoop(NodeList $nodes, array $items, PluginArgument $arg)
    {
        $spec = $arg->getSpec();
        $translation = $arg->getTranslation();

        foreach ($nodes as $node) {

            $beforeNode = $node->nextSibling ? $node->nextSibling : null;
            $nodeClone  = clone $node;
            $parentNode = $node->parentNode;
            
            if (empty($node->parentNode)) {
                continue;
            }

            $node->parentNode->removeChild($node);

            $loopArg = new ArrayObject([
                'spec'   => $spec,
                'vars'   => $translation,
                'target' => $this,
                'parentNode' => $parentNode,
                'beforeNode' => $beforeNode,
            ]);

            $this->itemsLoop($items, $arg, $loopArg, $nodeClone);

            empty($spec['instructions'])
                or $this->instructionsRenderer->subInstructions(
                    $nodes->create([$node]),
                    $spec['instructions'],
                    $translation
                );
        }

        return $this;
    }

    /**
     * @param array $items
     * @param PluginArgument $arg
     * @param ArrayObject $loopArg
     * @param Element $nodeClone
     * @return self
     */
    protected function itemsLoop(array $items, PluginArgument $arg, ArrayObject $loopArg, Element $nodeClone)
    {
        $spec   = $arg->getSpec();
        $helper = $arg->getHelper();
        $nodes  = $arg->getNodes();
        $translation = $arg->getTranslation();

        $loopArg['index'] = !empty($spec['loop']['index']) ? $spec['loop']['index'] : 0;
        foreach ($items as $key => $item) {
            $loopArg['index']++;

            $loopArg['key']  = $key;
            $loopArg['item'] = (array) $item;
            $loopArg['node'] = clone $nodeClone;

            if ($this->invokeLoopHelpers($spec['loop'], $loopArg)) {
                continue;
            }

            $loopArg['item'][$translation->makeExtraVarKey('key')]   = (string) $loopArg['key'];
            $loopArg['item'][$translation->makeExtraVarKey('index')] = (string) $loopArg['index'];

            // create local translation
            $localTranslation = clone $translation;
            $localTranslation->mergeValues($loopArg['item']);

            // add node
            if ($loopArg['beforeNode']) {
                $loopArg['parentNode']->insertBefore($loopArg['node'], $loopArg['beforeNode']);
            } else {
                $loopArg['parentNode']->appendChild($loopArg['node']);
            }

            // manipulate item nodes with local spec and translation
            $localSpec = $spec;
            unset($localSpec['loop']);
            $helper->manipulateNodes(
                $nodes->create([$loopArg['node']]),
                $localSpec,
                $localTranslation
            );

            // render sub-instructions
            empty($spec['loop']['instructions'])
                or $this->instructionsRenderer->subInstructions(
                    $nodes->create([$loopArg['node']]),
                    $spec['loop']['instructions'],
                    $localTranslation
                );
        }

        return $this;
    }

    /**
     * @param array $spec
     * @param ArrayObject $loopArg
     * @return bool
     */
    protected function invokeLoopHelpers(array $spec, ArrayObject $loopArg)
    {
        if (empty($spec['helper'])) {
            return false;
        }

        foreach ((array) $spec['helper'] as $helperOptions) {
            $this->invokeLoopHelper((array) $helperOptions, $loopArg);

            if (empty($loopArg['node'])) {
                // allows to skip node
                return true;
            }
        }

        return false;
    }

    /**
     * @param array $helperOptions
     * @param ArrayObject $loopArg
     * @return self
     * @throws Exception\InvalidLoopHelperException
     */
    protected function invokeLoopHelper(array $helperOptions, ArrayObject $loopArg)
    {
        $helper = current($helperOptions);
        if (is_string($helper)) {
            if (!$this->loopHelpers->has($helper)) {
                throw new Exception\InvalidLoopHelperException('Loop helper `' . $helper . '` not found');
            }

            $loopHelper = $this->loopHelpers->get($helper);
            $loopHelper($loopArg, (array) next($helperOptions));
            return $this;

        } elseif (is_callable($helper)) {
            call_user_func($helper, $loopArg, (array) next($helperOptions));
            return $this;
        }

        throw new Exception\InvalidLoopHelperException('Loop helper can\'t execute');
    }
}


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-2015 Webino, s. r. o. (http://webino.sk)
7			* @author Peter Bačinský <[email protected]>
8			* @license BSD-3-Clause
9			*/
10
11			namespace WebinoDraw\Manipulator\Plugin;
12
13			use ArrayObject;
14			use WebinoDraw\Cache\DrawCache;
15			use WebinoDraw\Dom\Element;
16			use WebinoDraw\Dom\NodeList;
17			use WebinoDraw\Draw\Helper\AbstractHelper;
18			use WebinoDraw\Draw\LoopHelperPluginManager;
19			use WebinoDraw\Exception;
20			use WebinoDraw\Instructions\InstructionsRenderer;
21
22			/**
23			* Class Loop
24			*/
25			class Loop extends AbstractPlugin implements PreLoopPluginInterface
26			{
27			/**
28			* @var InstructionsRenderer
29			*/
30			protected $instructionsRenderer;
31
32			/**
33			* @var LoopHelperPluginManager
34			*/
35			protected $loopHelpers;
36
37			/**
38			* @var DrawCache
39			*/
40			protected $cache;
41
42			/**
43			* @param InstructionsRenderer $instructionsRenderer
44			* @param LoopHelperPluginManager $loopHelpers
45			* @param DrawCache $cache
46			*/
47			public function __construct(
48			InstructionsRenderer $instructionsRenderer,
49			LoopHelperPluginManager $loopHelpers,
50			DrawCache $cache
51			) {
52			$this->instructionsRenderer = $instructionsRenderer;
53			$this->loopHelpers = $loopHelpers;
54			$this->cache = $cache;
55			}
56
57			/**
58			* @param PluginArgument $arg
59			*/
60			public function preLoop(PluginArgument $arg)
61			{
62			$spec = $arg->getSpec();
63			if (empty($spec['loop'])) {
64			return;
65			}
66
67			if (empty($spec['cache'])) {
68			$this->preLoopInternal($arg);
69			return;
70			}
71
72			$event = $arg->getHelper()->getEvent();
73			$nodes = $arg->getNodes();
74
75			foreach ($nodes as $node) {
76
77			$parentNodes = $nodes->create([$node->parentNode]);
78			$loopEvent = clone $event;
79			$loopEvent->setNodes($parentNodes);
80
81			if ($this->cache->load($loopEvent)) {
82			continue;
83			}
84
85			$localArg = clone $arg;
86			$localArg->setNodes($nodes->create([$node]));
87
88			$this->preLoopInternal($localArg);
89			$this->cache->save($loopEvent);
90			}
91			}
92
93			/**
94			* @param PluginArgument $arg
95			* @throws Exception\MissingPropertyException
96			*/
97			protected function preLoopInternal(PluginArgument $arg)
98			{
99			$spec = $arg->getSpec();
100			$translation = $arg->getTranslation();
101			$varTranslation = $translation->makeVarKeys($translation);
102
103			$translation->containsVar($spec['loop']['base'])
104			and $varTranslation->translate($spec['loop']['base']);
105
106			if (empty($spec['loop']['base'])) {
107			throw new Exception\MissingPropertyException(
108			sprintf('Loop base expected in: %s', print_r($spec, true))
109			);
110			}
111
112			$arg->stopManipulation();
113
114			$nodes = $arg->getNodes();
115
116			isset($spec['loop']['offset']) && $translation->containsVar($spec['loop']['offset'])
117			and $varTranslation->translate($spec['loop']['offset']);
118
119			// TODO spec object default
120			empty($spec['loop']['offset'])
121			and $spec['loop']['offset'] = 0;
122
123			isset($spec['loop']['length']) && $translation->containsVar($spec['loop']['length'])
124			and $varTranslation->translate($spec['loop']['length']);
125
126			// TODO spec object default
127			empty($spec['loop']['length'])
128			and $spec['loop']['length'] = null;
129
130			// TODO spec object
131			$arg->setSpec($spec);
132
133			$helper = $arg->getHelper();
134			if (!$translation->offsetExists($spec['loop']['base'])
135			&& $helper instanceof AbstractHelper
136			) {
137			$varTranslator = $helper->getVarTranslator();
138			$translation->offsetSet(
139			$spec['loop']['base'],
140			$varTranslator->getTranslation()->offsetGet($spec['loop']['base'])
141			);
142			}
143
144			$items = array_slice(
145			(array) $translation->fetch($spec['loop']['base']),
146			$spec['loop']['offset'],
147			$spec['loop']['length'],
148			true
149			);
150
151			if (empty($items)) {
152			$this->nothingToLoop($arg);
153			return;
154			}
155
156			empty($spec['loop']['shuffle'])
157			or shuffle($items);
158
159			$this->instructionsRenderer
160			->expandInstructions($spec, $translation)
161			->expandInstructions($spec['loop'], $translation);
162
163			// TODO spec object
164			$arg->setSpec($spec);
165			$this->nodesLoop($nodes, $items, $arg);
166			}
167
168			/**
169			* @param PluginArgument $arg
170			*/
171			protected function nothingToLoop(PluginArgument $arg)
172			{
173			$spec = $arg->getSpec();
174			if (!array_key_exists('onEmpty', $spec['loop'])) {
175			return;
176			}
177
178			$helper = $arg->getHelper();
179			$nodes = $arg->getNodes();
180			$translation = $arg->getTranslation();
181			$onEmptySpec = $spec['loop']['onEmpty'];
182
183			if (!empty($onEmptySpec['locator'])) {
184			$this->instructionsRenderer->subInstructions($nodes, [$onEmptySpec], $translation);
185			return;
186			}
187
188			$this->instructionsRenderer->expandInstructions($onEmptySpec, $translation);
189			empty($onEmptySpec['instructions'])
190			or $this->instructionsRenderer->subInstructions(
191			$nodes,
192			$onEmptySpec['instructions'],
193			$translation
194			);
195
196			$helper->manipulateNodes($nodes, $onEmptySpec, $translation);
197			}
198
199			/**
200			* @param NodeList $nodes
201			* @param array $items
202			* @param PluginArgument $arg
203			* @return self
204			*/
205			protected function nodesLoop(NodeList $nodes, array $items, PluginArgument $arg)
206			{
207			$spec = $arg->getSpec();
208			$translation = $arg->getTranslation();
209
210			foreach ($nodes as $node) {
211
212			$beforeNode = $node->nextSibling ? $node->nextSibling : null;
213			$nodeClone = clone $node;
214			$parentNode = $node->parentNode;
215
216			if (empty($node->parentNode)) {
217			continue;
218			}
219
220			$node->parentNode->removeChild($node);
221
222			$loopArg = new ArrayObject([
223			'spec' => $spec,
224			'vars' => $translation,
225			'target' => $this,
226			'parentNode' => $parentNode,
227			'beforeNode' => $beforeNode,
228			]);
229
230			$this->itemsLoop($items, $arg, $loopArg, $nodeClone);
231
232			empty($spec['instructions'])
233			or $this->instructionsRenderer->subInstructions(
234			$nodes->create([$node]),
235			$spec['instructions'],
236			$translation
237			);
238			}
239
240			return $this;
241			}
242
243			/**
244			* @param array $items
245			* @param PluginArgument $arg
246			* @param ArrayObject $loopArg
247			* @param Element $nodeClone
248			* @return self
249			*/
250			protected function itemsLoop(array $items, PluginArgument $arg, ArrayObject $loopArg, Element $nodeClone)
251			{
252			$spec = $arg->getSpec();
253			$helper = $arg->getHelper();
254			$nodes = $arg->getNodes();
255			$translation = $arg->getTranslation();
256
257			$loopArg['index'] = !empty($spec['loop']['index']) ? $spec['loop']['index'] : 0;
258			foreach ($items as $key => $item) {
259			$loopArg['index']++;
260
261			$loopArg['key'] = $key;
262			$loopArg['item'] = (array) $item;
263			$loopArg['node'] = clone $nodeClone;
264
265			if ($this->invokeLoopHelpers($spec['loop'], $loopArg)) {
266			continue;
267			}
268
269			$loopArg['item'][$translation->makeExtraVarKey('key')] = (string) $loopArg['key'];
270			$loopArg['item'][$translation->makeExtraVarKey('index')] = (string) $loopArg['index'];
271
272			// create local translation
273			$localTranslation = clone $translation;
274			$localTranslation->mergeValues($loopArg['item']);
275
276			// add node
277			if ($loopArg['beforeNode']) {
278			$loopArg['parentNode']->insertBefore($loopArg['node'], $loopArg['beforeNode']);
279			} else {
280			$loopArg['parentNode']->appendChild($loopArg['node']);
281			}
282
283			// manipulate item nodes with local spec and translation
284			$localSpec = $spec;
285			unset($localSpec['loop']);
286			$helper->manipulateNodes(
287			$nodes->create([$loopArg['node']]),
288			$localSpec,
289			$localTranslation
290			);
291
292			// render sub-instructions
293			empty($spec['loop']['instructions'])
294			or $this->instructionsRenderer->subInstructions(
295			$nodes->create([$loopArg['node']]),
296			$spec['loop']['instructions'],
297			$localTranslation
298			);
299			}
300
301			return $this;
302			}
303
304			/**
305			* @param array $spec
306			* @param ArrayObject $loopArg
307			* @return bool
308			*/
309			protected function invokeLoopHelpers(array $spec, ArrayObject $loopArg)
310			{
311			if (empty($spec['helper'])) {
312			return false;
313			}
314
315			foreach ((array) $spec['helper'] as $helperOptions) {
316			$this->invokeLoopHelper((array) $helperOptions, $loopArg);
317
318			if (empty($loopArg['node'])) {
319			// allows to skip node
320			return true;
321			}
322			}
323
324			return false;
325			}
326
327			/**
328			* @param array $helperOptions
329			* @param ArrayObject $loopArg
330			* @return self
331			* @throws Exception\InvalidLoopHelperException
332			*/
333			protected function invokeLoopHelper(array $helperOptions, ArrayObject $loopArg)
334			{
335			$helper = current($helperOptions);
336			if (is_string($helper)) {
337			if (!$this->loopHelpers->has($helper)) {
338			throw new Exception\InvalidLoopHelperException('Loop helper `' . $helper . '` not found');
339			}
340
341			$loopHelper = $this->loopHelpers->get($helper);
342			$loopHelper($loopArg, (array) next($helperOptions));
343			return $this;
344
345			} elseif (is_callable($helper)) {
346			call_user_func($helper, $loopArg, (array) next($helperOptions));
347			return $this;
348			}
349
350			throw new Exception\InvalidLoopHelperException('Loop helper can\'t execute');
351			}
352			}
353

webino / WebinoDraw

Push — develop ( 38b232...8588db )

Loop::preLoopInternal() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like