Collection - Code Metrics - Inspection of "Removing else from __get" - NukaCode/database - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f1ed3a...dbd3cd )

by Travis

created 2016-08-25 20:39 UTC

Collection C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	396
Duplicated Lines	9.09 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
wmc	73
c	3
b	0
f	0
lcom	1
cbo	1
dl	36
loc	396
ccs	103
cts	103
cp	1
rs	5.5447

18 Methods

Rating	Name	Duplication	Size	Complexity
C	__get()	0	26	8
B	__call()	0	22	5
A	insertAfter()	0	16	3
A	toSelectArray()	0	14	3
B	magicWhere()	0	32	4
B	determineMagicWhereDetails()	0	31	2
A	checkMagicWhereFinalOperator()	0	8	2
A	checkMagicWherePosition()	0	8	2
A	checkMagicWhereNot()	0	8	2
B	getWhere()	0	24	5
A	handleMultiTap()	0	14	3
A	tapThroughObjects()	0	14	2
A	whereObject()	0	16	4
B	getWhereIn()	11	11	5
B	getWhereBetween()	8	14	6
B	getWhereLike()	11	11	5
B	getWhereNull()	6	11	7
B	getWhereDefault()	0	11	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Collection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Collection, and based on these observations, apply Extract Interface, too.

<?php

namespace NukaCode\Database;

use Illuminate\Database\Eloquent\Collection as BaseCollection;

/**
 * Class Collection
 *
 * This class adds some magic to the collection class.
 * It allows you to tab through collections into other object or collections.
 * It also allows you to run a getWhere on a collection to find objects.
 *
 * @package NukaCode\Core\Database
 */
class Collection extends BaseCollection
{
    /**
     * Dynamically retrieve attributes on the model.
     *
     * @param  string $key
     *
     * @return mixed
     */
    public function __get($key)
    {
        $newCollection = new self();

        foreach ($this->items as $item) {
            if ($item instanceof self) { // This item is a collection.
                foreach ($item as $subItem) {
                    $newCollection->put($newCollection->count(), $subItem->$key);
                }

                continue;
            }

            if (is_object($item) && ! $item instanceof self && $item->$key instanceof self) { // Next tap is a collection.
                foreach ($item->$key as $subItem) {
                    $newCollection->put($newCollection->count(), $subItem);
                }

                continue;
            }

            $newCollection->put($newCollection->count(), $item->$key);
        }

        return $newCollection;
    }

    /**
     * Allow a method to be run on the entire collection.
     *
     * @param string $method
     * @param array  $args
     *
     * @return Collection
     */
    public function __call($method, $args)
    {
        // Look for magic where calls.
        if (strstr($method, 'getWhere')) {
            return $this->magicWhere(snake_case($method), $args);
        }

        // No data in the collection.
        if ($this->count() <= 0) {
            return $this;
        }

        // Run the command on each object in the collection.
        foreach ($this->items as $item) {
            if (! is_object($item)) {
                continue;
            }
            call_user_func_array([$item, $method], $args);
        }

        return $this;
    }

    /**
     * Insert into an object
     *
     * Should be able to do this with methods
     * that already exist on collection.
     *
     * @param mixed $value
     * @param int   $afterKey
     *
     * @return Collection
     */
    public function insertAfter($value, $afterKey)
    {
        $new_object = new self();

        foreach ((array)$this->items as $k => $v) {
            if ($afterKey == $k) {
                $new_object->add($value);
            }

            $new_object->add($v);
        }

        $this->items = $new_object->items;

        return $this;
    }

    /**
     * Turn a collection into a drop down for an html select element.
     *
     * @param  string $firstOptionText Text for the first object in the select array.
     * @param  string $id              The column to use for the id column in the option element.
     * @param  string $name            The column to use for the name column in the option element.
     *
     * @return array                    The new select element array.
     */
    public function toSelectArray($firstOptionText = 'Select one', $id = 'id', $name = 'name')
    {
        $selectArray = [];

        if ($firstOptionText != false) {

            $selectArray[0] = $firstOptionText;
        }

        foreach ($this->items as $item) {
            $selectArray[$item->{$id}] = $item->{$name};
        }

        return $selectArray;
    }

    /**
     * Turn the magic getWhere into a real where query.
     *
     * @param $method
     * @param $args
     *
     * @return Collection
     */
    private function magicWhere($method, $args)
    {
        $whereStatement = explode('_', $method);

        // Get where
        if (count($whereStatement) == 2) {
            return $this->getWhere($args[0], '=', $args[1]);
        }

        $operators = [
            'in', 'between', 'like', 'null',
            'not',
            'first', 'last',
            'many',
        ];

        // If an operator is found then add operators.
        if (array_intersect($whereStatement, $operators)) {
            list($operator, $firstOrLast, $inverse) = $this->determineMagicWhereDetails($whereStatement);

            $column = $args[0];
            $value  = (isset($args[1]) ? $args[1] : null);

            return $this->getWhere(
                $column,
                $operator,
                $value,
                $inverse,
                $firstOrLast
            );
        }
    }

    /**
     * @param $whereStatement
     *
     * @return array
     */
    private function determineMagicWhereDetails($whereStatement)
    {
        $finalOperator = '=';
        $position      = null;
        $not           = false;

        foreach ($whereStatement as $operator) {
            $finalOperator = $this->checkMagicWhereFinalOperator($operator, $finalOperator);
            $position      = $this->checkMagicWherePosition($operator, $position);
            $not           = $this->checkMagicWhereNot($operator, $not);
        }

        return [$finalOperator, $position, $not];

        // This is not working at the moment
        // todo riddles - fix this
        //if ($finalOperator == 'many') {

        //    $where = null;

        //    foreach ($args[0] as $column => $value) {

        //        $where = $this->getWhere(

        //            $column,            // Column
        //            $finalOperator,    // Operator
        //            $value,             // Value
        //            $not,               // Inverse
        //            $position            // First or last
        //        );
        //    }
        //
        //    return $where;
        //}
    }

    private function checkMagicWhereFinalOperator($operator, $finalOperator)
    {
        if (in_array($operator, ['in', 'between', 'like', 'null', '='])) {
            return $operator;
        }

        return $finalOperator;
    }

    private function checkMagicWherePosition($operator, $position)
    {
        if (in_array($operator, ['first', 'last'])) {
            return $operator;
        }

        return $position;
    }

    private function checkMagicWhereNot($operator, $not)
    {
        if (in_array($operator, ['not'])) {
            return true;
        }

        return $not;
    }

    /**
     * Search a collection for the value specified.
     *
     * @param  string  $column   The column to search.
     * @param  string  $operator The operation to use during search.
     * @param  mixed   $value    The value to search for.
     * @param  boolean $inverse  Invert the results.
     * @param  string  $position Return the first or last object in the collection.
     *
     * @return self                 Return the filtered collection.
     */
    protected function getWhere($column, $operator, $value = null, $inverse = false, $position = null)
    {
        $output = clone $this;
        foreach ($output->items as $key => $item) {
            if (strstr($column, '->')) {
                $forget = $this->handleMultiTap($item, $column, $value, $operator, $inverse);
            } else {
                // No tap direct object access
                $forget = $this->whereObject($item, $column, $operator, $value, $inverse);
            }

            if ($forget == true) {
                $output->forget($key);
                continue;
            }
        }

        // Handel first and last.
        if (! is_null($position)) {
            return $output->$position();
        }

        return $output;
    }

    /**
     * @param $item
     * @param $column
     * @param $value
     * @param $operator
     * @param $inverse
     *
     * @return bool
     */
    private function handleMultiTap($item, $column, $value, $operator, $inverse)
    {
        list($objectToSearch, $columnToSearch) = $this->tapThroughObjects($column, $item);

        if ($objectToSearch instanceof self) {
            foreach ($objectToSearch as $subObject) {
                // The column has a tap that ends in a collection.
                return $this->whereObject($subObject, $columnToSearch, $operator, $value, $inverse);
            }
        } else {
            // The column has a tap that ends in direct access
            return $this->whereObject($objectToSearch, $columnToSearch, $operator, $value, $inverse);
        }
    }

    /**
     * @param $column
     * @param $item
     *
     * @return mixed
     */
    private function tapThroughObjects($column, $item)
    {
        $taps = explode('->', $column);

        $objectToSearch = $item;
        $columnToSearch = array_pop($taps);

        foreach ($taps as $tapKey => $tap) {
            // Keep tapping till we hit the last object.
            $objectToSearch = $objectToSearch->$tap;
        }

        return [$objectToSearch, $columnToSearch];
    }

    /**
     * Compare the object and column passed with the value using the operator
     *
     * @param  object  $object   The object we are searching.
     * @param  string  $column   The column to compare.
     * @param  string  $operator What type of comparison operation to perform.
     * @param  mixed   $value    The value to search for.
     * @param  boolean $inverse  Invert the results.
     *
     * @return boolean              Return true if the object should be removed from the collection.
     */
    private function whereObject($object, $column, $operator, $value = null, $inverse = false)
    {
        // Remove the object is the column does not exits.
        // Only do this if we aren't looking for null
        if (! $object->$column && $operator != 'null') {
            return true;
        }

        $method = 'getWhere' . ucfirst($operator);

        if (method_exists($this, $method)) {
            return $this->{$method}($object, $column, $value, $inverse);
        }

        return $this->getWhereDefault($object, $column, $value, $inverse);
    }

    private function getWhereIn($object, $column, $value, $inverse)

    {
        if (! in_array($object->$column, $value) && $inverse == false) {
            return true;
        }
        if (in_array($object->$column, $value) && $inverse == true) {
            return true;
        }

        return false;
    }

    private function getWhereBetween($object, $column, $value, $inverse)
    {
        if ($inverse == false) {
            if ($object->$column < $value[0] || $object->$column > $value[1]) {

                return true;
            }
        } else {

            if ($object->$column >= $value[0] && $object->$column <= $value[1]) {
                return true;
            }
        }

        return false;
    }

    private function getWhereLike($object, $column, $value, $inverse)

    {
        if (! strstr($object->$column, $value) && $inverse == false) {
            return true;
        }
        if (strstr($object->$column, $value) && $inverse == true) {
            return true;
        }

        return false;
    }

    private function getWhereNull($object, $column, $value, $inverse)

    {
        if ((! is_null($object->$column) || $object->$column != null) && $inverse == false) {

            return true;
        }
        if ((is_null($object->$column) || $object->$column == null) && $inverse == true) {

            return true;
        }

        return false;
    }

    private function getWhereDefault($object, $column, $value, $inverse)
    {
        if ($object->$column != $value && $inverse == false) {
            return true;
        }
        if ($object->$column == $value && $inverse == true) {
            return true;
        }

        return false;
    }
}


1			<?php
2
3			namespace NukaCode\Database;
4
5			use Illuminate\Database\Eloquent\Collection as BaseCollection;
6
7			/**
8			* Class Collection
9			*
10			* This class adds some magic to the collection class.
11			* It allows you to tab through collections into other object or collections.
12			* It also allows you to run a getWhere on a collection to find objects.
13			*
14			* @package NukaCode\Core\Database
15			*/
16			class Collection extends BaseCollection
17			{
18			/**
19			* Dynamically retrieve attributes on the model.
20			*
21			* @param string $key
22			*
23			* @return mixed
24			*/
25	1		public function __get($key)
26			{
27	1		$newCollection = new self();
28
29	1		foreach ($this->items as $item) {
30	1		if ($item instanceof self) { // This item is a collection.
31			foreach ($item as $subItem) {
32			$newCollection->put($newCollection->count(), $subItem->$key);
33			}
34
35			continue;
36			}
37
38	1		if (is_object($item) && ! $item instanceof self && $item->$key instanceof self) { // Next tap is a collection.
39			foreach ($item->$key as $subItem) {
40			$newCollection->put($newCollection->count(), $subItem);
41			}
42
43			continue;
44			}
45
46	1		$newCollection->put($newCollection->count(), $item->$key);
47			}
48
49	1		return $newCollection;
50			}
51
52			/**
53			* Allow a method to be run on the entire collection.
54			*
55			* @param string $method
56			* @param array $args
57			*
58			* @return Collection
59			*/
60	24		public function __call($method, $args)
61			{
62			// Look for magic where calls.
63	24		if (strstr($method, 'getWhere')) {
64	24		return $this->magicWhere(snake_case($method), $args);
65			}
66
67			// No data in the collection.
68			if ($this->count() <= 0) {
69			return $this;
70			}
71
72			// Run the command on each object in the collection.
73			foreach ($this->items as $item) {
74			if (! is_object($item)) {
75			continue;
76			}
77			call_user_func_array([$item, $method], $args);
78			}
79
80			return $this;
81			}
82
83			/**
84			* Insert into an object
85			*
86			* Should be able to do this with methods
87			* that already exist on collection.
88			*
89			* @param mixed $value
90			* @param int $afterKey
91			*
92			* @return Collection
93			*/
94			public function insertAfter($value, $afterKey)
95			{
96			$new_object = new self();
97
98			foreach ((array)$this->items as $k => $v) {
99			if ($afterKey == $k) {
100			$new_object->add($value);
101			}
102
103			$new_object->add($v);
104			}
105
106			$this->items = $new_object->items;
107
108			return $this;
109			}
110
111			/**
112			* Turn a collection into a drop down for an html select element.
113			*
114			* @param string $firstOptionText Text for the first object in the select array.
115			* @param string $id The column to use for the id column in the option element.
116			* @param string $name The column to use for the name column in the option element.
117			*
118			* @return array The new select element array.
119			*/
120			public function toSelectArray($firstOptionText = 'Select one', $id = 'id', $name = 'name')
121			{
122			$selectArray = [];
123
124			if ($firstOptionText != false) {
			0 ignored issues – show Bug Best Practice introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$firstOptionText` of type `string` to the boolean `false`. If you are specifically checking for a non-empty string, consider using the more explicit `!== ''` instead. Loading history...
125			$selectArray[0] = $firstOptionText;
126			}
127
128			foreach ($this->items as $item) {
129			$selectArray[$item->{$id}] = $item->{$name};
130			}
131
132			return $selectArray;
133			}
134
135			/**
136			* Turn the magic getWhere into a real where query.
137			*
138			* @param $method
139			* @param $args
140			*
141			* @return Collection
142			*/
143	24		private function magicWhere($method, $args)
144			{
145	24		$whereStatement = explode('_', $method);
146
147			// Get where
148	24		if (count($whereStatement) == 2) {
149	2		return $this->getWhere($args[0], '=', $args[1]);
150			}
151
152			$operators = [
153	22		'in', 'between', 'like', 'null',
154			'not',
155			'first', 'last',
156			'many',
157			];
158
159			// If an operator is found then add operators.
160	22		if (array_intersect($whereStatement, $operators)) {
161	22		list($operator, $firstOrLast, $inverse) = $this->determineMagicWhereDetails($whereStatement);
162
163	22		$column = $args[0];
164	22		$value = (isset($args[1]) ? $args[1] : null);
165
166	22		return $this->getWhere(
167			$column,
168			$operator,
169			$value,
170			$inverse,
171			$firstOrLast
172			);
173			}
174			}
175
176			/**
177			* @param $whereStatement
178			*
179			* @return array
180			*/
181	22		private function determineMagicWhereDetails($whereStatement)
182			{
183	22		$finalOperator = '=';
184	22		$position = null;
185	22		$not = false;
186
187	22		foreach ($whereStatement as $operator) {
188	22		$finalOperator = $this->checkMagicWhereFinalOperator($operator, $finalOperator);
189	22		$position = $this->checkMagicWherePosition($operator, $position);
190	22		$not = $this->checkMagicWhereNot($operator, $not);
191			}
192
193	22		return [$finalOperator, $position, $not];
194
195			// This is not working at the moment
196			// todo riddles - fix this
197			//if ($finalOperator == 'many') {
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report `55%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
198			// $where = null;
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report `43%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
199			// foreach ($args[0] as $column => $value) {
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report `64%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
200			// $where = $this->getWhere(
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report `45%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
201			// $column, // Column
202			// $finalOperator, // Operator
203			// $value, // Value
204			// $not, // Inverse
205			// $position // First or last
206			// );
207			// }
208			//
209			// return $where;
210			//}
211			}
212
213	22		private function checkMagicWhereFinalOperator($operator, $finalOperator)
214			{
215	22		if (in_array($operator, ['in', 'between', 'like', 'null', '='])) {
216	20		return $operator;
217			}
218
219	22		return $finalOperator;
220			}
221
222	22		private function checkMagicWherePosition($operator, $position)
223			{
224	22		if (in_array($operator, ['first', 'last'])) {
225	4		return $operator;
226			}
227
228	22		return $position;
229			}
230
231	22		private function checkMagicWhereNot($operator, $not)
232			{
233	22		if (in_array($operator, ['not'])) {
234	10		return true;
235			}
236
237	22		return $not;
238			}
239
240			/**
241			* Search a collection for the value specified.
242			*
243			* @param string $column The column to search.
244			* @param string $operator The operation to use during search.
245			* @param mixed $value The value to search for.
246			* @param boolean $inverse Invert the results.
247			* @param string $position Return the first or last object in the collection.
248			*
249			* @return self Return the filtered collection.
250			*/
251	24		protected function getWhere($column, $operator, $value = null, $inverse = false, $position = null)
252			{
253	24		$output = clone $this;
254	24		foreach ($output->items as $key => $item) {
255	24		if (strstr($column, '->')) {
256	12		$forget = $this->handleMultiTap($item, $column, $value, $operator, $inverse);
257			} else {
258			// No tap direct object access
259	12		$forget = $this->whereObject($item, $column, $operator, $value, $inverse);
260			}
261
262	24		if ($forget == true) {
263	24		$output->forget($key);
264	24		continue;
265			}
266			}
267
268			// Handel first and last.
269	24		if (! is_null($position)) {
270	4		return $output->$position();
271			}
272
273	20		return $output;
274			}
275
276			/**
277			* @param $item
278			* @param $column
279			* @param $value
280			* @param $operator
281			* @param $inverse
282			*
283			* @return bool
284			*/
285	12		private function handleMultiTap($item, $column, $value, $operator, $inverse)
286			{
287	12		list($objectToSearch, $columnToSearch) = $this->tapThroughObjects($column, $item);
288
289	12		if ($objectToSearch instanceof self) {
290	12		foreach ($objectToSearch as $subObject) {
291			// The column has a tap that ends in a collection.
292	12		return $this->whereObject($subObject, $columnToSearch, $operator, $value, $inverse);
293			}
294			} else {
295			// The column has a tap that ends in direct access
296			return $this->whereObject($objectToSearch, $columnToSearch, $operator, $value, $inverse);
297			}
298			}
299
300			/**
301			* @param $column
302			* @param $item
303			*
304			* @return mixed
305			*/
306	12		private function tapThroughObjects($column, $item)
307			{
308	12		$taps = explode('->', $column);
309
310	12		$objectToSearch = $item;
311	12		$columnToSearch = array_pop($taps);
312
313	12		foreach ($taps as $tapKey => $tap) {
314			// Keep tapping till we hit the last object.
315	12		$objectToSearch = $objectToSearch->$tap;
316			}
317
318	12		return [$objectToSearch, $columnToSearch];
319			}
320
321			/**
322			* Compare the object and column passed with the value using the operator
323			*
324			* @param object $object The object we are searching.
325			* @param string $column The column to compare.
326			* @param string $operator What type of comparison operation to perform.
327			* @param mixed $value The value to search for.
328			* @param boolean $inverse Invert the results.
329			*
330			* @return boolean Return true if the object should be removed from the collection.
331			*/
332	24		private function whereObject($object, $column, $operator, $value = null, $inverse = false)
333			{
334			// Remove the object is the column does not exits.
335			// Only do this if we aren't looking for null
336	24		if (! $object->$column && $operator != 'null') {
337	12		return true;
338			}
339
340	24		$method = 'getWhere' . ucfirst($operator);
341
342	24		if (method_exists($this, $method)) {
343	20		return $this->{$method}($object, $column, $value, $inverse);
344			}
345
346	4		return $this->getWhereDefault($object, $column, $value, $inverse);
347			}
348
349	8	View Code Duplication	private function getWhereIn($object, $column, $value, $inverse)
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
350			{
351	8		if (! in_array($object->$column, $value) && $inverse == false) {
352	6		return true;
353			}
354	8		if (in_array($object->$column, $value) && $inverse == true) {
355	2		return true;
356			}
357
358	8		return false;
359			}
360
361	4		private function getWhereBetween($object, $column, $value, $inverse)
362			{
363	4		if ($inverse == false) {
364	2	View Code Duplication	if ($object->$column < $value[0] \|\| $object->$column > $value[1]) {
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
365	2		return true;
366			}
367		View Code Duplication	} else {
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
368	2		if ($object->$column >= $value[0] && $object->$column <= $value[1]) {
369	2		return true;
370			}
371			}
372
373	4		return false;
374			}
375
376	4	View Code Duplication	private function getWhereLike($object, $column, $value, $inverse)
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
377			{
378	4		if (! strstr($object->$column, $value) && $inverse == false) {
379	2		return true;
380			}
381	4		if (strstr($object->$column, $value) && $inverse == true) {
382	2		return true;
383			}
384
385	4		return false;
386			}
387
388	4		private function getWhereNull($object, $column, $value, $inverse)
			0 ignored issues – show Unused Code introduced 2016-08-12 13:50 UTC by Report Bug Copy Issue Report The parameter `$value` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
389			{
390	4	View Code Duplication	if ((! is_null($object->$column) \|\| $object->$column != null) && $inverse == false) {
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
391	2		return true;
392			}
393	4	View Code Duplication	if ((is_null($object->$column) \|\| $object->$column == null) && $inverse == true) {
			0 ignored issues – show Duplication introduced 2016-08-12 13:26 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
394	2		return true;
395			}
396
397	4		return false;
398			}
399
400	4		private function getWhereDefault($object, $column, $value, $inverse)
401			{
402	4		if ($object->$column != $value && $inverse == false) {
403	2		return true;
404			}
405	4		if ($object->$column == $value && $inverse == true) {
406	2		return true;
407			}
408
409	4		return false;
410			}
411			}
412

NukaCode / database