Utils::callFuncArray() - Code Metrics - Inspection of "Minor fixes and dumped the PHP 5.4 support." - xeriab/konfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8d39d6...58e1d9 )

by Xeriab

created 2016-10-16 20:14 UTC

Utils::callFuncArray() C

↳ Parent: Utils

Complexity

Conditions	27
Paths	40

Size

Total Lines	75
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	75
rs	5.2073
cc	27
eloc	44
nc	40
nop	2

How to fix Long Method Complexity

<?php

/**
 * Konfig
 *
 * Yet another simple configuration loader library.
 *
 * @author  Xeriab Nabil (aka KodeBurner) <[email protected]>
 * @license https://raw.github.com/xeriab/konfig/master/LICENSE MIT
 * @link    https://xeriab.github.io/projects/konfig
 */

namespace Exen\Konfig;

use Closure;

const REQ = 'REQ';
const INC = 'INC';

final class Utils
{
    /**
     * Requires/Includes the given file and returns the results.
     *
     * @param string $file The path to the file
     * @param string $type Type of loading, REQ for require, INC for include
     * @param bool $once Require once or not
     * @return mixed The results of the include
     * @codeCoverageIgnore
     * @since 0.1.0
     */
    public static function load($file = null, $type = REQ, $once = false)
    {
        $path = realpath($file);

        if ($type === REQ || $type === 'REQ') {
            return ($once ? require_once $path : require $path);
        } elseif ($type === INC || $type === 'INC') {
            return ($once ? include_once $path : include $path);
        }

        return;
    }

    /**
     * Get the content of given file and returns the results.
     *
     * @param string $file The path to the file
     * @return mixed The results of the include
     * @codeCoverageIgnore
     * @since 0.2.4
     */
    public static function getContent($file = null)
    {
        return file_get_contents(realpath($file));
    }

    /**
     * Get the given file and returns the results.
     *
     * @param string $path The path to the file
     * @return mixed The results of the include
     * @codeCoverageIgnore
     * @since 0.2.4
     */
    public static function getFile($path = null)
    {
        return file($path, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
    }

    /**
     * Takes a value and checks if it's a Closure or not, if it's a Closure it
     * will return the result of the closure, if not, it will simply return the
     * value.
     *
     * @param mixed $var The value to get
     * @return mixed
     * @since 0.1.0
     * @codeCoverageIgnore
     */
    public static function checkValue($var = null)
    {
        return ($var instanceof Closure) ? $var() : $var;
    }

    /**
     * Trim array elements
     *
     * @param array $content The array to trim
     * @return mixed
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function trimArrayElements($content = null)
    {
        $cb = function ($el) {
            return trim($el);
        };

        $content = array_map($cb, $content);

        return $content;
    }

    /**
     * Remove quotes
     *
     * @param string $string The string to remove quotes from
     * @return string
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function removeQuotes($string = null)
    {
        if (substr($string, -1) === '"' && substr($string, 0, 1) === '"') {
            $string = substr($string, 1, -1);
        }

        return $string;
    }

    /**
     * @param array $content
     * @return array
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function stripBackslashes($content = null)
    {
        foreach ($content as $lineNb => $line) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if (substr($line[2], -1) === '\\') {
                $content[$lineNb][2] = trim(substr($line[2], 0, -1));
            }
        }

        return $content;
    }

    /**
     * @param string $needle
     * @param string $string
     * @return bool
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function stringStart($needle, $string)
    {
        return (substr($string, 0, 1) === $needle) ? true : false;
    }

    /**
     * @param string $path The path to the file
     * @return array
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function fileToArray($path = null)
    {
        // $result = self::getFile($path);
        $result = self::getContent($path);

        $lines = explode(PHP_EOL, $result);

        print_r($lines);

        $result = self::trimArrayElements($result);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = array_filter($result);

        return $result;
    }

    /**
     * @param string $content The file content
     * @return string
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function fileContentToArray($content = null)
    {
        $result = [];

        $lines = explode(PHP_EOL, $content);

        foreach ($lines as $key) {
            if ($key !== "" || !is_null($key) || !empty($key)) {
                $result[] = $key;
            }
        }

        $result = self::trimArrayElements($result);
        $result = array_filter($result);

        return $result;
    }

    /**
     * @param string $type The line type
     * @param array $analysis Array to analyze
     * @return int
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function getNumberLinesMatching($type, array $analysis)
    {
        $counter = 0;

        foreach ($analysis as $value) {
            if ($value[0] === $type) {
                $counter++;
            }
        }

        return $counter;
    }

    /**
     * @param $callback
     * @param array $args
     * @return void
     * @since 0.2.4
     * @codeCoverageIgnore
     */
    public static function callFuncArray($callback, array $args)
    {
        // deal with "class::method" syntax
        if (is_string($callback) && strpos($callback, '::') !== false) {
            $callback = explode('::', $callback);
        }

        // if an array is passed, extract the object and method to call
        if (is_array($callback) && isset($callback[1]) && is_object($callback[0])) {
            list($instance, $method) = $callback;

            // Calling the method directly is faster then call_user_func_array() !
            switch (count($args)) {
                case 0:
                    return $instance->$method();

                case 1:
                    return $instance->$method($args[0]);

                case 2:
                    return $instance->$method($args[0], $args[1]);

                case 3:
                    return $instance->$method($args[0], $args[1], $args[2]);

                case 4:
                    return $instance->$method($args[0], $args[1], $args[2], $args[3]);
            }
        } elseif (is_array($callback) && isset($callback[1]) && is_string($callback[0])) {
            list($class, $method) = $callback;
            $class = '\\'.ltrim($class, '\\');

            // Calling the method directly is faster then call_user_func_array() !
            switch (count($args)) {
                case 0:
                    return $class::$method();

                case 1:
                    return $class::$method($args[0]);

                case 2:
                    return $class::$method($args[0], $args[1]);

                case 3:
                    return $class::$method($args[0], $args[1], $args[2]);

                case 4:
                    return $class::$method($args[0], $args[1], $args[2], $args[3]);
            }
            // if it's a string, it's a native function or a static method call
        } elseif (is_string($callback) || $callback instanceof Closure) {
            is_string($callback) && $callback = ltrim($callback, '\\');

            // calling the method directly is faster then call_user_func_array() !
            switch (count($args)) {
                case 0:
                    return $callback();

                case 1:
                    return $callback($args[0]);

                case 2:
                    return $callback($args[0], $args[1]);

                case 3:
                    return $callback($args[0], $args[1], $args[2]);

                case 4:
                    return $callback($args[0], $args[1], $args[2], $args[3]);
            }
        }

        // fallback, handle the old way
        return call_user_func_array($callback, $args);
    }

    /**
     * @return string
     * @codeCoverageIgnore
     * @since 0.1.2
     */
    public function __toString()
    {
        return 'Exen\Konfig\Utils' . PHP_EOL;
    }
}

// END OF ./src/Utils.php FILE


1			<?php
2
3			/**
4			* Konfig
5			*
6			* Yet another simple configuration loader library.
7			*
8			* @author Xeriab Nabil (aka KodeBurner) <[email protected]>
9			* @license https://raw.github.com/xeriab/konfig/master/LICENSE MIT
10			* @link https://xeriab.github.io/projects/konfig
11			*/
12
13			namespace Exen\Konfig;
14
15			use Closure;
16
17			const REQ = 'REQ';
18			const INC = 'INC';
19
20			final class Utils
21			{
22			/**
23			* Requires/Includes the given file and returns the results.
24			*
25			* @param string $file The path to the file
26			* @param string $type Type of loading, REQ for require, INC for include
27			* @param bool $once Require once or not
28			* @return mixed The results of the include
29			* @codeCoverageIgnore
30			* @since 0.1.0
31			*/
32			public static function load($file = null, $type = REQ, $once = false)
33			{
34			$path = realpath($file);
35
36			if ($type === REQ \|\| $type === 'REQ') {
37			return ($once ? require_once $path : require $path);
38			} elseif ($type === INC \|\| $type === 'INC') {
39			return ($once ? include_once $path : include $path);
40			}
41
42			return;
43			}
44
45			/**
46			* Get the content of given file and returns the results.
47			*
48			* @param string $file The path to the file
49			* @return mixed The results of the include
50			* @codeCoverageIgnore
51			* @since 0.2.4
52			*/
53			public static function getContent($file = null)
54			{
55			return file_get_contents(realpath($file));
56			}
57
58			/**
59			* Get the given file and returns the results.
60			*
61			* @param string $path The path to the file
62			* @return mixed The results of the include
63			* @codeCoverageIgnore
64			* @since 0.2.4
65			*/
66			public static function getFile($path = null)
67			{
68			return file($path, FILE_IGNORE_NEW_LINES \| FILE_SKIP_EMPTY_LINES);
69			}
70
71			/**
72			* Takes a value and checks if it's a Closure or not, if it's a Closure it
73			* will return the result of the closure, if not, it will simply return the
74			* value.
75			*
76			* @param mixed $var The value to get
77			* @return mixed
78			* @since 0.1.0
79			* @codeCoverageIgnore
80			*/
81			public static function checkValue($var = null)
82			{
83			return ($var instanceof Closure) ? $var() : $var;
84			}
85
86			/**
87			* Trim array elements
88			*
89			* @param array $content The array to trim
90			* @return mixed
91			* @since 0.2.4
92			* @codeCoverageIgnore
93			*/
94			public static function trimArrayElements($content = null)
95			{
96			$cb = function ($el) {
97			return trim($el);
98			};
99
100			$content = array_map($cb, $content);
101
102			return $content;
103			}
104
105			/**
106			* Remove quotes
107			*
108			* @param string $string The string to remove quotes from
109			* @return string
110			* @since 0.2.4
111			* @codeCoverageIgnore
112			*/
113			public static function removeQuotes($string = null)
114			{
115			if (substr($string, -1) === '"' && substr($string, 0, 1) === '"') {
116			$string = substr($string, 1, -1);
117			}
118
119			return $string;
120			}
121
122			/**
123			* @param array $content
124			* @return array
125			* @since 0.2.4
126			* @codeCoverageIgnore
127			*/
128			public static function stripBackslashes($content = null)
129			{
130			foreach ($content as $lineNb => $line) {
			0 ignored issues – show Bug introduced 2016-10-16 20:17 UTC by Report Bug Copy Issue Report The expression `$content` of type `array\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
131			if (substr($line[2], -1) === '\\') {
132			$content[$lineNb][2] = trim(substr($line[2], 0, -1));
133			}
134			}
135
136			return $content;
137			}
138
139			/**
140			* @param string $needle
141			* @param string $string
142			* @return bool
143			* @since 0.2.4
144			* @codeCoverageIgnore
145			*/
146			public static function stringStart($needle, $string)
147			{
148			return (substr($string, 0, 1) === $needle) ? true : false;
149			}
150
151			/**
152			* @param string $path The path to the file
153			* @return array
154			* @since 0.2.4
155			* @codeCoverageIgnore
156			*/
157			public static function fileToArray($path = null)
158			{
159			// $result = self::getFile($path);
160			$result = self::getContent($path);
161
162			$lines = explode(PHP_EOL, $result);
163
164			print_r($lines);
165
166			$result = self::trimArrayElements($result);
			0 ignored issues – show Documentation introduced 2016-10-16 20:17 UTC by Report Bug Copy Issue Report `$result` is of type `string`, but the function expects a `array\|null`. 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...
167			$result = array_filter($result);
168
169			return $result;
170			}
171
172			/**
173			* @param string $content The file content
174			* @return string
175			* @since 0.2.4
176			* @codeCoverageIgnore
177			*/
178			public static function fileContentToArray($content = null)
179			{
180			$result = [];
181
182			$lines = explode(PHP_EOL, $content);
183
184			foreach ($lines as $key) {
185			if ($key !== "" \|\| !is_null($key) \|\| !empty($key)) {
186			$result[] = $key;
187			}
188			}
189
190			$result = self::trimArrayElements($result);
191			$result = array_filter($result);
192
193			return $result;
194			}
195
196			/**
197			* @param string $type The line type
198			* @param array $analysis Array to analyze
199			* @return int
200			* @since 0.2.4
201			* @codeCoverageIgnore
202			*/
203			public static function getNumberLinesMatching($type, array $analysis)
204			{
205			$counter = 0;
206
207			foreach ($analysis as $value) {
208			if ($value[0] === $type) {
209			$counter++;
210			}
211			}
212
213			return $counter;
214			}
215
216			/**
217			* @param $callback
218			* @param array $args
219			* @return void
220			* @since 0.2.4
221			* @codeCoverageIgnore
222			*/
223			public static function callFuncArray($callback, array $args)
224			{
225			// deal with "class::method" syntax
226			if (is_string($callback) && strpos($callback, '::') !== false) {
227			$callback = explode('::', $callback);
228			}
229
230			// if an array is passed, extract the object and method to call
231			if (is_array($callback) && isset($callback[1]) && is_object($callback[0])) {
232			list($instance, $method) = $callback;
233
234			// Calling the method directly is faster then call_user_func_array() !
235			switch (count($args)) {
236			case 0:
237			return $instance->$method();
238
239			case 1:
240			return $instance->$method($args[0]);
241
242			case 2:
243			return $instance->$method($args[0], $args[1]);
244
245			case 3:
246			return $instance->$method($args[0], $args[1], $args[2]);
247
248			case 4:
249			return $instance->$method($args[0], $args[1], $args[2], $args[3]);
250			}
251			} elseif (is_array($callback) && isset($callback[1]) && is_string($callback[0])) {
252			list($class, $method) = $callback;
253			$class = '\\'.ltrim($class, '\\');
254
255			// Calling the method directly is faster then call_user_func_array() !
256			switch (count($args)) {
257			case 0:
258			return $class::$method();
259
260			case 1:
261			return $class::$method($args[0]);
262
263			case 2:
264			return $class::$method($args[0], $args[1]);
265
266			case 3:
267			return $class::$method($args[0], $args[1], $args[2]);
268
269			case 4:
270			return $class::$method($args[0], $args[1], $args[2], $args[3]);
271			}
272			// if it's a string, it's a native function or a static method call
273			} elseif (is_string($callback) \|\| $callback instanceof Closure) {
274			is_string($callback) && $callback = ltrim($callback, '\\');
275
276			// calling the method directly is faster then call_user_func_array() !
277			switch (count($args)) {
278			case 0:
279			return $callback();
280
281			case 1:
282			return $callback($args[0]);
283
284			case 2:
285			return $callback($args[0], $args[1]);
286
287			case 3:
288			return $callback($args[0], $args[1], $args[2]);
289
290			case 4:
291			return $callback($args[0], $args[1], $args[2], $args[3]);
292			}
293			}
294
295			// fallback, handle the old way
296			return call_user_func_array($callback, $args);
297			}
298
299			/**
300			* @return string
301			* @codeCoverageIgnore
302			* @since 0.1.2
303			*/
304			public function __toString()
305			{
306			return 'Exen\Konfig\Utils' . PHP_EOL;
307			}
308			}
309
310			// END OF ./src/Utils.php FILE
311

xeriab / konfig

Push — master ( 8d39d6...58e1d9 )

Utils::callFuncArray() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like