Each::begin() - Code Metrics - enzyme/loopy - Measure and Improve Code Quality continuously with Scrutinizer

Each::begin() A
last analyzed 2016-04-03 07:58 UTC

↳ Parent: Each

Complexity

Conditions	3
Paths	3

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	15
rs	9.4285
cc	3
eloc	9
nc	3
nop	3

<?php

namespace Enzyme\Loopy;

use ArrayAccess;
use Closure;
use Enzyme\Loopy\Filters\FilterInterface;

class Each implements LooperInterface
{
    /**
     * If this loop will go deep into the enumerated object.
     *
     * @var boolean
     */
    protected $deep;

    /**
     * Stores the current cycle value.
     *
     * @var integer
     */
    protected $cycle;

    /**
     * Stored the current index value.
     *
     * @var integer
     */
    protected $index;

    /**
     * Stored the current depth value.
     *
     * @var integer
     */
    protected $depth;

    /**
     * The optional filter to pass the key and value through
     * upon each iteration.
     *
     * @var FilterInterface
     */
    protected $filter;

    /**
     * Creates a new Each loop.
     *
     * @param bool $deep Whether to traverse deeply.
     *
     * @param FilterInterface|null $filter The optional filter to apply to each iteration.
     */
    private function __construct($deep, FilterInterface $filter = null)
    {
        $this->deep = $deep;
        $this->filter = $filter;
    }

    /**
     * Creates a new shallow Each loopy.
     *
     * @param FilterInterface|null $filter The optional filter to apply to each iteration.
     *
     * @return Each
     */
    public static function shallow(FilterInterface $filter = null)
    {
        $deep = false;

        return new static($deep, $filter);
    }

    /**
     * Creates a new deep Each loopy.
     *
     * @param FilterInterface|null $filter The optional filter to apply to each iteration.
     *
     * @return Each
     */
    public static function deep(FilterInterface $filter = null)
    {
        $deep = true;

        return new static($deep, $filter);
    }

    /**
     * {@inheritdoc}
     */
    public function begin($enumerable, Closure $function, $cycles = 1)
    {
        if ($this->isEnumerable($enumerable) === false) {
            throw new InvalidLoopException('The supplied $enumerable object cannot be enumerated.');
        }

        $this->index = 0;
        $this->depth = 0;
        $this->cycle = 0;

        for ($i = 0; $i < $cycles; $i++) {
            $this->doSingleForeachCycle($enumerable, $function);
            $this->cycle++;
        }
    }

    /**
     * Performs a single foreach cycle.
     *
     * @param mixed   $enumerable The object to iterate over.
     * @param Closure $function   The callback function.
     *
     * @return void
     */
    protected function doSingleForeachCycle($enumerable, Closure $function)
    {
        foreach ($enumerable as $key => $value) {
            if ($this->canGoDeeperInto($value)) {
                $this->doSingleForeachCycle($value, $function);
            } elseif ($this->passesThroughFilter($key, $value)) {
                $this->processIteration($key, $value, $function);
            }
        }
    }

    /**
     * Checks if the given key and value pass through the filter,
     * if one exists.
     *
     * @param mixed $key   The key.
     * @param mixed $value The value.
     *
     * @return boolean
     */
    protected function passesThroughFilter($key, $value)
    {
        if ($this->filter === null) {
            return true;
        }

        return $this->filter->passes($key, $value);
    }

    /**
     * Checks whether we can go deeper into this value,
     * if the deep setting is set to true.
     *
     * @param mixed $value The value to check.
     *
     * @return boolean
     */
    protected function canGoDeeperInto($value)
    {
        return $this->deep === true && $this->isEnumerable($value);
    }

    /**
     * Checks whether the given item is enumerable.
     *
     * @param mixed $item The item.
     *
     * @return boolean
     */
    protected function isEnumerable($item)
    {
        return is_array($item) === true || ($item instanceof ArrayAccess) === true;
    }

    /**
     * Processes this iterations key and value.
     *
     * @param mixed   $key      The key.
     * @param mixed   $value    The value.
     * @param Closure $function The callback function
     *
     * @return void
     */
    protected function processIteration($key, $value, $function)
    {
        $function($this->packBag($key, $value));
        $this->index++;
    }

    /**
     * Packs and returns a new bag with the given values.
     *
     * @param mixed $key   The key.
     * @param mixed $value The value.
     *
     * @return Bag
     */
    protected function packBag($key, $value)
    {
        $index = $this->index;
        $cycle = $this->cycle;
        $depth = $this->depth;

        return new Bag(compact('key', 'value', 'index', 'cycle', 'depth'));
    }
}

1			<?php
2
3			namespace Enzyme\Loopy;
4
5			use ArrayAccess;
6			use Closure;
7			use Enzyme\Loopy\Filters\FilterInterface;
8
9			class Each implements LooperInterface
10			{
11			/**
12			* If this loop will go deep into the enumerated object.
13			*
14			* @var boolean
15			*/
16			protected $deep;
17
18			/**
19			* Stores the current cycle value.
20			*
21			* @var integer
22			*/
23			protected $cycle;
24
25			/**
26			* Stored the current index value.
27			*
28			* @var integer
29			*/
30			protected $index;
31
32			/**
33			* Stored the current depth value.
34			*
35			* @var integer
36			*/
37			protected $depth;
38
39			/**
40			* The optional filter to pass the key and value through
41			* upon each iteration.
42			*
43			* @var FilterInterface
44			*/
45			protected $filter;
46
47			/**
48			* Creates a new Each loop.
49			*
50			* @param bool $deep Whether to traverse deeply.
51			*
52			* @param FilterInterface\|null $filter The optional filter to apply to each iteration.
53			*/
54			private function __construct($deep, FilterInterface $filter = null)
55			{
56			$this->deep = $deep;
57			$this->filter = $filter;
58			}
59
60			/**
61			* Creates a new shallow Each loopy.
62			*
63			* @param FilterInterface\|null $filter The optional filter to apply to each iteration.
64			*
65			* @return Each
66			*/
67			public static function shallow(FilterInterface $filter = null)
68			{
69			$deep = false;
70
71			return new static($deep, $filter);
72			}
73
74			/**
75			* Creates a new deep Each loopy.
76			*
77			* @param FilterInterface\|null $filter The optional filter to apply to each iteration.
78			*
79			* @return Each
80			*/
81			public static function deep(FilterInterface $filter = null)
82			{
83			$deep = true;
84
85			return new static($deep, $filter);
86			}
87
88			/**
89			* {@inheritdoc}
90			*/
91			public function begin($enumerable, Closure $function, $cycles = 1)
92			{
93			if ($this->isEnumerable($enumerable) === false) {
94			throw new InvalidLoopException('The supplied $enumerable object cannot be enumerated.');
95			}
96
97			$this->index = 0;
98			$this->depth = 0;
99			$this->cycle = 0;
100
101			for ($i = 0; $i < $cycles; $i++) {
102			$this->doSingleForeachCycle($enumerable, $function);
103			$this->cycle++;
104			}
105			}
106
107			/**
108			* Performs a single foreach cycle.
109			*
110			* @param mixed $enumerable The object to iterate over.
111			* @param Closure $function The callback function.
112			*
113			* @return void
114			*/
115			protected function doSingleForeachCycle($enumerable, Closure $function)
116			{
117			foreach ($enumerable as $key => $value) {
118			if ($this->canGoDeeperInto($value)) {
119			$this->doSingleForeachCycle($value, $function);
120			} elseif ($this->passesThroughFilter($key, $value)) {
121			$this->processIteration($key, $value, $function);
122			}
123			}
124			}
125
126			/**
127			* Checks if the given key and value pass through the filter,
128			* if one exists.
129			*
130			* @param mixed $key The key.
131			* @param mixed $value The value.
132			*
133			* @return boolean
134			*/
135			protected function passesThroughFilter($key, $value)
136			{
137			if ($this->filter === null) {
138			return true;
139			}
140
141			return $this->filter->passes($key, $value);
142			}
143
144			/**
145			* Checks whether we can go deeper into this value,
146			* if the deep setting is set to true.
147			*
148			* @param mixed $value The value to check.
149			*
150			* @return boolean
151			*/
152			protected function canGoDeeperInto($value)
153			{
154			return $this->deep === true && $this->isEnumerable($value);
155			}
156
157			/**
158			* Checks whether the given item is enumerable.
159			*
160			* @param mixed $item The item.
161			*
162			* @return boolean
163			*/
164			protected function isEnumerable($item)
165			{
166			return is_array($item) === true \|\| ($item instanceof ArrayAccess) === true;
167			}
168
169			/**
170			* Processes this iterations key and value.
171			*
172			* @param mixed $key The key.
173			* @param mixed $value The value.
174			* @param Closure $function The callback function
175			*
176			* @return void
177			*/
178			protected function processIteration($key, $value, $function)
179			{
180			$function($this->packBag($key, $value));
181			$this->index++;
182			}
183
184			/**
185			* Packs and returns a new bag with the given values.
186			*
187			* @param mixed $key The key.
188			* @param mixed $value The value.
189			*
190			* @return Bag
191			*/
192			protected function packBag($key, $value)
193			{
194			$index = $this->index;
195			$cycle = $this->cycle;
196			$depth = $this->depth;
197
198			return new Bag(compact('key', 'value', 'index', 'cycle', 'depth'));
199			}
200			}

enzyme / loopy

Each::begin() A last analyzed 2016-04-03 07:58 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Each::begin() A
last analyzed 2016-04-03 07:58 UTC