Macroable::__callStatic() - Code Metrics - Inspection of "updated dependencies for laravel 7" - antonioribeiro/ia-arr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2)

unknown

created 2020-03-09 21:40 UTC

Macroable::__callStatic() A

↳ Parent: Macroable

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	16
Ratio	100 %

Code Coverage

Tests	4
CRAP Score	3.7085

Importance

Changes

Metric	Value
cc	3
nc	3
nop	2
dl	16
loc	16
ccs	4
cts	7
cp	0.5714
crap	3.7085
rs	9.7333
c	0
b	0
f	0

<?php

namespace IlluminateAgnostic\Arr\Support\Traits;

use BadMethodCallException;
use Closure;
use ReflectionClass;
use ReflectionMethod;

trait Macroable
{
    /**
     * The registered string macros.
     *
     * @var array
     */
    protected static $macros = [];

    /**
     * Register a custom macro.
     *
     * @param  string $name
     * @param  object|callable  $macro
     *
     * @return void
     */
    public static function macro($name, $macro)
    {
        static::$macros[$name] = $macro;
    }

    /**
     * Mix another object into the class.
     *
     * @param  object  $mixin
     * @param  bool  $replace
     * @return void
     *
     * @throws \ReflectionException
     */
    public static function mixin($mixin, $replace = true)
    {
        $methods = (new ReflectionClass($mixin))->getMethods(
            ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
        );

        foreach ($methods as $method) {
            if ($replace || ! static::hasMacro($method->name)) {
                $method->setAccessible(true);
                static::macro($method->name, $method->invoke($mixin));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
        }
    }

    /**
     * Checks if macro is registered.
     *
     * @param  string  $name
     * @return bool
     */
    public static function hasMacro($name)
    {
        return isset(static::$macros[$name]);
    }

    /**
     * Dynamically handle calls to the class.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public static function __callStatic($method, $parameters)

    {
        if (! static::hasMacro($method)) {
            throw new BadMethodCallException(sprintf(
                'Method %s::%s does not exist.', static::class, $method
            ));
        }

        $macro = static::$macros[$method];

        if ($macro instanceof Closure) {
            return call_user_func_array(Closure::bind($macro, null, static::class), $parameters);
        }

        return $macro(...$parameters);
    }

    /**
     * Dynamically handle calls to the class.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $parameters)

    {
        if (! static::hasMacro($method)) {
            throw new BadMethodCallException(sprintf(
                'Method %s::%s does not exist.', static::class, $method
            ));
        }

        $macro = static::$macros[$method];

        if ($macro instanceof Closure) {
            return call_user_func_array($macro->bindTo($this, static::class), $parameters);
        }

        return $macro(...$parameters);
    }
}


1			<?php
2
3			namespace IlluminateAgnostic\Arr\Support\Traits;
4
5			use BadMethodCallException;
6			use Closure;
7			use ReflectionClass;
8			use ReflectionMethod;
9
10			trait Macroable
11			{
12			/**
13			* The registered string macros.
14			*
15			* @var array
16			*/
17			protected static $macros = [];
18
19			/**
20			* Register a custom macro.
21			*
22			* @param string $name
23			* @param object\|callable $macro
24			*
25			* @return void
26	9		*/
27			public static function macro($name, $macro)
28	9		{
29	9		static::$macros[$name] = $macro;
30			}
31
32			/**
33			* Mix another object into the class.
34			*
35			* @param object $mixin
36			* @param bool $replace
37			* @return void
38			*
39			* @throws \ReflectionException
40	2		*/
41			public static function mixin($mixin, $replace = true)
42	2		{
43	2		$methods = (new ReflectionClass($mixin))->getMethods(
44			ReflectionMethod::IS_PUBLIC \| ReflectionMethod::IS_PROTECTED
45			);
46	2
47	2		foreach ($methods as $method) {
48	2		if ($replace \|\| ! static::hasMacro($method->name)) {
49	2		$method->setAccessible(true);
50			static::macro($method->name, $method->invoke($mixin));
			0 ignored issues – show Documentation introduced 2019-03-17 16:52 UTC by Report Bug Copy Issue Report `$method->invoke($mixin)` is of type `*`, but the function expects a `callable`. 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...
51			}
52	2		}
53			}
54
55			/**
56			* Checks if macro is registered.
57			*
58			* @param string $name
59			* @return bool
60	9		*/
61			public static function hasMacro($name)
62	9		{
63			return isset(static::$macros[$name]);
64			}
65
66			/**
67			* Dynamically handle calls to the class.
68			*
69			* @param string $method
70			* @param array $parameters
71			* @return mixed
72			*
73			* @throws \BadMethodCallException
74	2		*/
75		View Code Duplication	public static function __callStatic($method, $parameters)
			0 ignored issues – show Duplication introduced 2019-09-12 03:14 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...
76	2		{
77			if (! static::hasMacro($method)) {
78			throw new BadMethodCallException(sprintf(
79			'Method %s::%s does not exist.', static::class, $method
80			));
81			}
82	2
83			$macro = static::$macros[$method];
84	2
85	2		if ($macro instanceof Closure) {
86			return call_user_func_array(Closure::bind($macro, null, static::class), $parameters);
87			}
88
89			return $macro(...$parameters);
90			}
91
92			/**
93			* Dynamically handle calls to the class.
94			*
95			* @param string $method
96			* @param array $parameters
97			* @return mixed
98			*
99			* @throws \BadMethodCallException
100	8		*/
101		View Code Duplication	public function __call($method, $parameters)
			0 ignored issues – show Duplication introduced 2019-09-12 03:14 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...
102	8		{
103			if (! static::hasMacro($method)) {
104			throw new BadMethodCallException(sprintf(
105			'Method %s::%s does not exist.', static::class, $method
106			));
107			}
108	8
109			$macro = static::$macros[$method];
110	8
111	8		if ($macro instanceof Closure) {
112			return call_user_func_array($macro->bindTo($this, static::class), $parameters);
113			}
114
115			return $macro(...$parameters);
116			}
117			}
118

antonioribeiro / ia-arr

Pull Request — master (#2)

Macroable::__callStatic() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like