StrategyCollection::off() - Code Metrics - humweb/features - Measure and Improve Code Quality continuously with Scrutinizer

StrategyCollection::off() A
last analyzed 2019-12-04 20:16 UTC

↳ Parent: StrategyCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Humweb\Features;

use Humweb\Features\Resolvers\StrategyResolver;
use Humweb\Features\Strategy\StrategyInterface;

/**
 * StrategyCollection.
 */
class StrategyCollection implements \ArrayAccess
{
    const STATUS_DISABLED = 0;
    const STATUS_ENABLED  = 1;

    /**
     * @var array
     */
    public $strategies;

    protected $resolver;

    protected $status = 1;

    protected $threshold = 1;


    /**
     * @param array $strategies
     */
    public function __construct($strategies = array())
    {
        $this->resolver   = new StrategyResolver();
        $this->strategies = $strategies;
    }


    /**
     * Adds strategies to feature object.
     *
     * @param string|array                    $name
     * @param callable|StrategyInterface|null $strategy
     *
     * @return $this
     */
    public function add($name, $strategy = null, $args = [])
    {
        if (is_array($name)) {
            $strategy = $name;
            foreach ($strategy as $name => $class) {
                $args = isset($class[1]) ? $class[1] : [];
                $this->addStrategy($name, $class[0], $args);
            }
        } else {
            $this->addStrategy($name, $strategy, $args);
        }

        return $this;
    }


    /**
     * Adds strategy to feature object.
     *
     * @param string                          $name
     * @param callable|StrategyInterface|null $class Strategy class name.
     * @param array                           $args
     *
     * @return $this
     * @throws InvalidArgumentException
     */
    public function addStrategy($name, $class = null, $args = [])
    {
        if (is_callable($class)) {
            $this->strategies[$name] = [
                'class' => $class,
                'args'  => $args,
                'type'  => 'function'
            ];
        } elseif ($class instanceof StrategyInterface) {
            $this->strategies[$name] = [
                'class' => $class,
                'args'  => $args,
                'type'  => 'class_instance'
            ];
        } else {

            // Strategy must be a string
            if ( ! is_string($class)) {
                throw new \InvalidArgumentException(sprintf('Expected a string. Actual: %s', gettype($class)));
            }

            $class = $this->resolver->resolve($class);

            $this->strategies[$name] = [
                'class' => $class,
                'args'  => $args,
                'type'  => 'class'
            ];
        }

        return $this;
    }


    public function count()
    {
        return count($this->strategies);
    }


    public function flush()
    {
        return $this->strategies = [];
    }


    /**
     * @param array $args
     *
     * @return bool
     */
    public function check($args = [])
    {
        if ($this->status === self::STATUS_DISABLED) {
            return false;
        }

        $isEnabled = 0;
        foreach ($this->strategies as $name => $strategy) {
            if ($this->isAnonymousFunctionStrategy($strategy)) {
                if ($strategy['class']($strategy['args'])) {
                    $isEnabled++;
                }
            } elseif ($this->callStrategyInstance($strategy, $args)) {
                $isEnabled++;
            }
        }

        return $isEnabled >= $this->threshold;
    }


    protected function callStrategyInstance($strategy, $args = [])
    {
        if ($strategy['type'] == 'class_instance') {
            $instance = $strategy['class'];
        } else {
            $instance = new $strategy['class']($args);
        }
        return $instance->handle($strategy['args']);
    }


    /**
     * (PHP 5 &gt;= 5.0.0)<br/>
     * Whether a offset exists.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetexists.php
     *
     * @param mixed $offset <p>
     *                      An offset to check for.
     *                      </p>
     *
     * @return bool true on success or false on failure.
     *              </p>
     *              <p>
     *              The return value will be casted to boolean if non-boolean was returned.
     */
    public function offsetExists($offset)
    {
        return isset($this->strategies[$offset]) || isset($this->strategies['__'.$offset]);
    }


    /**
     * (PHP 5 &gt;= 5.0.0)<br/>
     * Offset to retrieve.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetget.php
     *
     * @param mixed $offset <p>
     *                      The offset to retrieve.
     *                      </p>
     *
     * @return mixed Can return all value types.
     */
    public function offsetGet($offset)
    {
        return $this->strategies[$offset];
    }


    /**
     * (PHP 5 &gt;= 5.0.0)<br/>
     * Offset to set.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetset.php
     *
     * @param mixed $offset <p>
     *                      The offset to assign the value to.
     *                      </p>
     * @param mixed $value  <p>
     *                      The value to set.
     *                      </p>
     */
    public function offsetSet($offset, $value)
    {
        $this->add([$offset => $value]);
    }


    /**
     * (PHP 5 &gt;= 5.0.0)<br/>
     * Offset to unset.
     *
     * @link http://php.net/manual/en/arrayaccess.offsetunset.php
     *
     * @param mixed $offset <p>
     *                      The offset to unset.
     *                      </p>
     */
    public function offsetUnset($offset)
    {
        unset($this->strategies[$offset]);
    }


    public function off()
    {
        $this->status = self::STATUS_DISABLED;

        return $this;
    }


    public function on()
    {
        $this->status = self::STATUS_ENABLED;

        return $this;
    }


    public function getStatus()
    {
        return $this->status;
    }


    /**
     * @param int $threshold
     *
     * @return StrategyCollection
     */
    public function setThreshold($threshold)
    {
        $this->threshold = $threshold;

        return $this;
    }


    protected function isAnonymousFunctionStrategy($strategy = [])
    {
        return $strategy['type'] === 'function';
    }


    /**
     * @return int
     */
    public function getThreshold()
    {
        return $this->threshold;
    }


    /**
     * @return array
     */
    public function getStrategies()
    {
        return $this->strategies;
    }
}


1			<?php
2
3			namespace Humweb\Features;
4
5			use Humweb\Features\Resolvers\StrategyResolver;
6			use Humweb\Features\Strategy\StrategyInterface;
7
8			/**
9			* StrategyCollection.
10			*/
11			class StrategyCollection implements \ArrayAccess
12			{
13			const STATUS_DISABLED = 0;
14			const STATUS_ENABLED = 1;
15
16			/**
17			* @var array
18			*/
19			public $strategies;
20
21			protected $resolver;
22
23			protected $status = 1;
24
25			protected $threshold = 1;
26
27
28			/**
29			* @param array $strategies
30			*/
31			public function __construct($strategies = array())
32			{
33			$this->resolver = new StrategyResolver();
34			$this->strategies = $strategies;
35			}
36
37
38			/**
39			* Adds strategies to feature object.
40			*
41			* @param string\|array $name
42			* @param callable\|StrategyInterface\|null $strategy
43			*
44			* @return $this
45			*/
46			public function add($name, $strategy = null, $args = [])
47			{
48			if (is_array($name)) {
49			$strategy = $name;
50			foreach ($strategy as $name => $class) {
51			$args = isset($class[1]) ? $class[1] : [];
52			$this->addStrategy($name, $class[0], $args);
53			}
54			} else {
55			$this->addStrategy($name, $strategy, $args);
56			}
57
58			return $this;
59			}
60
61
62			/**
63			* Adds strategy to feature object.
64			*
65			* @param string $name
66			* @param callable\|StrategyInterface\|null $class Strategy class name.
67			* @param array $args
68			*
69			* @return $this
70			* @throws InvalidArgumentException
71			*/
72			public function addStrategy($name, $class = null, $args = [])
73			{
74			if (is_callable($class)) {
75			$this->strategies[$name] = [
76			'class' => $class,
77			'args' => $args,
78			'type' => 'function'
79			];
80			} elseif ($class instanceof StrategyInterface) {
81			$this->strategies[$name] = [
82			'class' => $class,
83			'args' => $args,
84			'type' => 'class_instance'
85			];
86			} else {
87
88			// Strategy must be a string
89			if ( ! is_string($class)) {
90			throw new \InvalidArgumentException(sprintf('Expected a string. Actual: %s', gettype($class)));
91			}
92
93			$class = $this->resolver->resolve($class);
94
95			$this->strategies[$name] = [
96			'class' => $class,
97			'args' => $args,
98			'type' => 'class'
99			];
100			}
101
102			return $this;
103			}
104
105
106			public function count()
107			{
108			return count($this->strategies);
109			}
110
111
112			public function flush()
113			{
114			return $this->strategies = [];
115			}
116
117
118			/**
119			* @param array $args
120			*
121			* @return bool
122			*/
123			public function check($args = [])
124			{
125			if ($this->status === self::STATUS_DISABLED) {
126			return false;
127			}
128
129			$isEnabled = 0;
130			foreach ($this->strategies as $name => $strategy) {
131			if ($this->isAnonymousFunctionStrategy($strategy)) {
132			if ($strategy['class']($strategy['args'])) {
133			$isEnabled++;
134			}
135			} elseif ($this->callStrategyInstance($strategy, $args)) {
136			$isEnabled++;
137			}
138			}
139
140			return $isEnabled >= $this->threshold;
141			}
142
143
144			protected function callStrategyInstance($strategy, $args = [])
145			{
146			if ($strategy['type'] == 'class_instance') {
147			$instance = $strategy['class'];
148			} else {
149			$instance = new $strategy['class']($args);
150			}
151			return $instance->handle($strategy['args']);
152			}
153
154
155			/**
156			* (PHP 5 >= 5.0.0)<br/>
157			* Whether a offset exists.
158			*
159			* @link http://php.net/manual/en/arrayaccess.offsetexists.php
160			*
161			* @param mixed $offset <p>
162			* An offset to check for.
163			* </p>
164			*
165			* @return bool true on success or false on failure.
166			* </p>
167			* <p>
168			* The return value will be casted to boolean if non-boolean was returned.
169			*/
170			public function offsetExists($offset)
171			{
172			return isset($this->strategies[$offset]) \|\| isset($this->strategies['__'.$offset]);
173			}
174
175
176			/**
177			* (PHP 5 >= 5.0.0)<br/>
178			* Offset to retrieve.
179			*
180			* @link http://php.net/manual/en/arrayaccess.offsetget.php
181			*
182			* @param mixed $offset <p>
183			* The offset to retrieve.
184			* </p>
185			*
186			* @return mixed Can return all value types.
187			*/
188			public function offsetGet($offset)
189			{
190			return $this->strategies[$offset];
191			}
192
193
194			/**
195			* (PHP 5 >= 5.0.0)<br/>
196			* Offset to set.
197			*
198			* @link http://php.net/manual/en/arrayaccess.offsetset.php
199			*
200			* @param mixed $offset <p>
201			* The offset to assign the value to.
202			* </p>
203			* @param mixed $value <p>
204			* The value to set.
205			* </p>
206			*/
207			public function offsetSet($offset, $value)
208			{
209			$this->add([$offset => $value]);
210			}
211
212
213			/**
214			* (PHP 5 >= 5.0.0)<br/>
215			* Offset to unset.
216			*
217			* @link http://php.net/manual/en/arrayaccess.offsetunset.php
218			*
219			* @param mixed $offset <p>
220			* The offset to unset.
221			* </p>
222			*/
223			public function offsetUnset($offset)
224			{
225			unset($this->strategies[$offset]);
226			}
227
228
229			public function off()
230			{
231			$this->status = self::STATUS_DISABLED;
232
233			return $this;
234			}
235
236
237			public function on()
238			{
239			$this->status = self::STATUS_ENABLED;
240
241			return $this;
242			}
243
244
245			public function getStatus()
246			{
247			return $this->status;
248			}
249
250
251			/**
252			* @param int $threshold
253			*
254			* @return StrategyCollection
255			*/
256			public function setThreshold($threshold)
257			{
258			$this->threshold = $threshold;
259
260			return $this;
261			}
262
263
264			protected function isAnonymousFunctionStrategy($strategy = [])
265			{
266			return $strategy['type'] === 'function';
267			}
268
269
270			/**
271			* @return int
272			*/
273			public function getThreshold()
274			{
275			return $this->threshold;
276			}
277
278
279			/**
280			* @return array
281			*/
282			public function getStrategies()
283			{
284			return $this->strategies;
285			}
286			}
287

humweb / features

StrategyCollection::off() A last analyzed 2019-12-04 20:16 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

StrategyCollection::off() A
last analyzed 2019-12-04 20:16 UTC