IsEmpty::inspect() - Code Metrics - Inspection of "Refactor: move is_XXX() to be check_is_XXX()" - ganbarodigital/php-the-missing-bits - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 97bd6f...558873 )

by Stuart

created 2016-10-11 11:14 UTC

IsEmpty::inspect() A

↳ Parent: IsEmpty

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php

/**
 * Copyright (c) 2016-present Ganbaro Digital Ltd
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *
 *   * Neither the names of the copyright holders nor the names of his
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * @category  Libraries
 * @package   MissingBits/TypeChecks
 * @author    Stuart Herbert <[email protected]>
 * @copyright 2016-present Ganbaro Digital Ltd www.ganbarodigital.com
 * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @link      http://ganbarodigital.github.io/php-the-missing-bits
 */

namespace GanbaroDigital\MissingBits\TypeChecks;

use GanbaroDigital\MissingBits\Checks\Check;
use GanbaroDigital\MissingBits\Checks\ListCheck;
use GanbaroDigital\MissingBits\Checks\ListCheckHelper;
use GanbaroDigital\MissingBits\TypeInterfaces\CanBeEmpty;
use stdClass;
use Traversable;

/**
 * do we have something that is empty?
 */
class IsEmpty implements Check, ListCheck
{
    // saves us having to implement inspectList() ourselves
    use ListCheckHelper;

    /**
     * check if an item is empty
     *
     * empty means one of:
     * - item itself is empty
     * - item is a data container, and only contains empty data items
     *
     * BE AWARE that this check WILL descend down into the contents of $fieldOrVar
     * until it finds the first piece of non-empty data. This has the potential
     * to be computationally expensive.
     *
     * @param  mixed $fieldOrVar
     *         the item to check
     * @return bool
     *         TRUE if the item is empty
     *         FALSE otherwise
     */
    public static function check($fieldOrVar)
    {
        // general case
        if (is_null($fieldOrVar)) {
            return true;
        }

        // type-specific checks
        if (is_array($fieldOrVar)) {
            return self::checkArray($fieldOrVar);
        }
        if ($fieldOrVar instanceof Traversable || $fieldOrVar instanceof stdClass) {
            return self::checkTraversable($fieldOrVar);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if ($fieldOrVar instanceof CanBeEmpty) {
            return $fieldOrVar->isEmpty();
        }

        if (is_string($fieldOrVar)) {
            return self::checkString($fieldOrVar);
        }

        // if we get here, we've run out of ways to check
        return false;
    }

    /**
     * check if an item is empty
     *
     * empty means one of:
     * - item itself has no content
     * - item is a data container, and only contains empty data items
     *
     * BE AWARE that this check WILL descend down into the contents of $fieldOrVar
     * until it finds the first piece of non-empty data. This has the potential
     * to be computationally expensive.
     *
     * @param  array $fieldOrVar
     *         the item to check
     * @return bool
     *         TRUE if the item is empty
     *         FALSE otherwise
     */
    private static function checkArray($fieldOrVar)
    {
        if (count($fieldOrVar) === 0) {
            return true;
        }

        return self::checkTraversable($fieldOrVar);
    }

    /**
     * check if an item is empty
     *
     * empty means one of:
     * - the string has zero length
     * - the string only contains whitespace
     *
     * @param  string $fieldOrVar
     *         the item to check
     * @return bool
     *         TRUE if the item is empty
     *         FALSE otherwise
     */
    private static function checkString($fieldOrVar)
    {
        if (trim((string)$fieldOrVar) === '') {
            return true;
        }

        return false;
    }

    /**
     * check if an item is empty
     *
     * empty means one of:
     * - item itself has no content
     * - item is a data container, and only contains empty data items
     *
     * BE AWARE that this check WILL descend down into the contents of $fieldOrVar
     * until it finds the first piece of non-empty data. This has the potential
     * to be computationally expensive.
     *
     * @param  array $fieldOrVar
     *         the item to check
     * @return bool
     *         TRUE if the item is empty
     *         FALSE otherwise
     */
    private static function checkTraversable($fieldOrVar)
    {
        foreach ($fieldOrVar as $value) {
            if (!self::check($value)) {
                return false;
            }
        }

        // if we get here, item's contents are entirely empty
        return true;
    }

    /**
     * check if an item is empty
     *
     * empty means one of:
     * - item itself is empty
     * - item is a data container, and only contains empty data items
     *
     * BE AWARE that this check WILL descend down into the contents of $fieldOrVar
     * until it finds the first piece of non-empty data. This has the potential
     * to be computationally expensive.
     *
     * @param  mixed $fieldOrVar
     *         the item to check
     * @return bool
     *         TRUE if the item is empty
     *         FALSE otherwise
     */
    public function inspect($fieldOrVar)
    {
        return static::check($fieldOrVar);
    }

    /**
     * is every entry in $list empty?
     *
     * @param  mixed $list
     *         the list of items to be checked
     * @return bool
     *         TRUE if every item in $list is empty
     *         FALSE otherwise
     */
    public static function checkList($list)
    {
        $check = new static;
        return $check->inspectList($list);
    }
}


1			<?php
2
3			/**
4			* Copyright (c) 2016-present Ganbaro Digital Ltd
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			*
11			* * Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			*
14			* * Redistributions in binary form must reproduce the above copyright
15			* notice, this list of conditions and the following disclaimer in
16			* the documentation and/or other materials provided with the
17			* distribution.
18			*
19			* * Neither the names of the copyright holders nor the names of his
20			* contributors may be used to endorse or promote products derived
21			* from this software without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26			* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27			* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29			* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30			* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31			* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33			* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34			* POSSIBILITY OF SUCH DAMAGE.
35			*
36			* @category Libraries
37			* @package MissingBits/TypeChecks
38			* @author Stuart Herbert <[email protected]>
39			* @copyright 2016-present Ganbaro Digital Ltd www.ganbarodigital.com
40			* @license http://www.opensource.org/licenses/bsd-license.php BSD License
41			* @link http://ganbarodigital.github.io/php-the-missing-bits
42			*/
43
44			namespace GanbaroDigital\MissingBits\TypeChecks;
45
46			use GanbaroDigital\MissingBits\Checks\Check;
47			use GanbaroDigital\MissingBits\Checks\ListCheck;
48			use GanbaroDigital\MissingBits\Checks\ListCheckHelper;
49			use GanbaroDigital\MissingBits\TypeInterfaces\CanBeEmpty;
50			use stdClass;
51			use Traversable;
52
53			/**
54			* do we have something that is empty?
55			*/
56			class IsEmpty implements Check, ListCheck
57			{
58			// saves us having to implement inspectList() ourselves
59			use ListCheckHelper;
60
61			/**
62			* check if an item is empty
63			*
64			* empty means one of:
65			* - item itself is empty
66			* - item is a data container, and only contains empty data items
67			*
68			* BE AWARE that this check WILL descend down into the contents of $fieldOrVar
69			* until it finds the first piece of non-empty data. This has the potential
70			* to be computationally expensive.
71			*
72			* @param mixed $fieldOrVar
73			* the item to check
74			* @return bool
75			* TRUE if the item is empty
76			* FALSE otherwise
77			*/
78			public static function check($fieldOrVar)
79			{
80			// general case
81			if (is_null($fieldOrVar)) {
82			return true;
83			}
84
85			// type-specific checks
86			if (is_array($fieldOrVar)) {
87			return self::checkArray($fieldOrVar);
88			}
89			if ($fieldOrVar instanceof Traversable \|\| $fieldOrVar instanceof stdClass) {
90			return self::checkTraversable($fieldOrVar);
			0 ignored issues – show Documentation introduced 2016-10-11 11:16 UTC by Report Bug Copy Issue Report `$fieldOrVar` is of type `object<Traversable>\|object<stdClass>`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
91			}
92			if ($fieldOrVar instanceof CanBeEmpty) {
93			return $fieldOrVar->isEmpty();
94			}
95
96			if (is_string($fieldOrVar)) {
97			return self::checkString($fieldOrVar);
98			}
99
100			// if we get here, we've run out of ways to check
101			return false;
102			}
103
104			/**
105			* check if an item is empty
106			*
107			* empty means one of:
108			* - item itself has no content
109			* - item is a data container, and only contains empty data items
110			*
111			* BE AWARE that this check WILL descend down into the contents of $fieldOrVar
112			* until it finds the first piece of non-empty data. This has the potential
113			* to be computationally expensive.
114			*
115			* @param array $fieldOrVar
116			* the item to check
117			* @return bool
118			* TRUE if the item is empty
119			* FALSE otherwise
120			*/
121			private static function checkArray($fieldOrVar)
122			{
123			if (count($fieldOrVar) === 0) {
124			return true;
125			}
126
127			return self::checkTraversable($fieldOrVar);
128			}
129
130			/**
131			* check if an item is empty
132			*
133			* empty means one of:
134			* - the string has zero length
135			* - the string only contains whitespace
136			*
137			* @param string $fieldOrVar
138			* the item to check
139			* @return bool
140			* TRUE if the item is empty
141			* FALSE otherwise
142			*/
143			private static function checkString($fieldOrVar)
144			{
145			if (trim((string)$fieldOrVar) === '') {
146			return true;
147			}
148
149			return false;
150			}
151
152			/**
153			* check if an item is empty
154			*
155			* empty means one of:
156			* - item itself has no content
157			* - item is a data container, and only contains empty data items
158			*
159			* BE AWARE that this check WILL descend down into the contents of $fieldOrVar
160			* until it finds the first piece of non-empty data. This has the potential
161			* to be computationally expensive.
162			*
163			* @param array $fieldOrVar
164			* the item to check
165			* @return bool
166			* TRUE if the item is empty
167			* FALSE otherwise
168			*/
169			private static function checkTraversable($fieldOrVar)
170			{
171			foreach ($fieldOrVar as $value) {
172			if (!self::check($value)) {
173			return false;
174			}
175			}
176
177			// if we get here, item's contents are entirely empty
178			return true;
179			}
180
181			/**
182			* check if an item is empty
183			*
184			* empty means one of:
185			* - item itself is empty
186			* - item is a data container, and only contains empty data items
187			*
188			* BE AWARE that this check WILL descend down into the contents of $fieldOrVar
189			* until it finds the first piece of non-empty data. This has the potential
190			* to be computationally expensive.
191			*
192			* @param mixed $fieldOrVar
193			* the item to check
194			* @return bool
195			* TRUE if the item is empty
196			* FALSE otherwise
197			*/
198			public function inspect($fieldOrVar)
199			{
200			return static::check($fieldOrVar);
201			}
202
203			/**
204			* is every entry in $list empty?
205			*
206			* @param mixed $list
207			* the list of items to be checked
208			* @return bool
209			* TRUE if every item in $list is empty
210			* FALSE otherwise
211			*/
212			public static function checkList($list)
213			{
214			$check = new static;
215			return $check->inspectList($list);
216			}
217			}
218

ganbarodigital / php-the-missing-bits

Push — develop ( 97bd6f...558873 )

IsEmpty::inspect() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like