CallbackRegistrar::hasProxy() - Code Metrics - Inspection of "Default callback" - LaraCrafts/laravel-geo-routes - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#42)

by Raed

created 2020-03-07 15:02 UTC

CallbackRegistrar::hasProxy() A

↳ Parent: CallbackRegistrar

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
ccs	0
cts	0
cp	0
rs	10
cc	1
nc	1
nop	1
crap	2

<?php

namespace LaraCrafts\GeoRoutes;

use Exception;
use Illuminate\Support\Str;
use InvalidArgumentException;
use ReflectionClass;
use ReflectionMethod;

class CallbackRegistrar
{
    /**
     * The callbacks' proxies.
     *
     * @var array
     */
    protected $proxies;

    /**
     * The default callback and its arguments.
     *
     * @var array
     */
    protected $default = [[Callbacks::class, 'unauthorized'], []];

    /**
     * Create a new CallbacksRegistrar instance.
     */
    public function __construct()
    {
        $this->proxies = [];
    }

    /**
     * Add a callback proxy from a given name and callable.
     *
     * @param string $name
     * @param callable $callback
     *
     * @return void
     */
    public function addCallback(string $name, callable $callback)
    {
        $this->proxies['or' . Str::studly($name)] = $callback;
    }

    /**
     * Load callbacks proxies from a given associative array.
     *
     * @param array $callbacks
     *
     * @return void
     */
    public function loadCallbacks(array $callbacks)
    {
        foreach ($callbacks as $key => $callback) {
            $this->addCallback($key, $callback);
        }
    }

    /**
     * Get or Load callbacks.
     *
     * If the callbacks parameter is present the callbacks
     * will be loaded, otherwise the current callbacks array
     * will be returned.
     *
     * @param array|null $callbacks
     *
     * @return array|null
     */
    public function callbacks(array $callbacks = null)
    {
        if ($callbacks) {
            return $this->loadCallbacks($callbacks);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        }

        return $this->proxies;
    }

    /**
     * Parse callbacks from a given class.
     *
     * This method will use reflection to loop through all of the static
     * methods.
     *
     * @param string $class
     *
     * @return void
     */
    public function parseCallbacks(string $class)
    {
        $reflection = new ReflectionClass($class);
        $callbacks = $reflection->getMethods(ReflectionMethod::IS_STATIC);

        foreach ($callbacks as $callback) {
            $this->addCallback($callback->getName(), $callback->getClosure());
        }
    }

    /**
     * Get/Set the callable for a given callback name.
     *
     * @param string $name
     * @param callable|null $callable
     *
     * @return mixed
     *
     * @throws \Exception
     */
    public function callback(string $name, callable $callable = null)
    {
        if (is_callable($callable)) {
            return $this->addCallback($name, $callable);
            return $this->addCallback($name, /** @scrutinizer ignore-type */ $callable);
        }

        if ($this->hasProxy($name)) {
            return $this->proxies[$name];
        }

        if ($this->hasCallback($name)) {
            return $this->proxies['or' . Str::ucfirst($name)];
        }

        throw new Exception("Undefined callback [$name]");
    }

    /**
     * Determine if a given callback exists.
     *
     * @param string $name
     *
     * @return boolean
     */
    public function hasCallback(string $name)
    {
        return array_key_exists('or' . Str::ucfirst($name), $this->proxies);
    }

    /**
     * Determine if a given proxy exists.
     *
     * @param string $proxy
     *
     * @return boolean
     */
    public function hasProxy(string $proxy)
    {
        return array_key_exists($proxy, $this->proxies);
    }

    /**
     * Set the default callback and its arguments.
     *
     * @param string|callable $callback
     * @param  mixed ...$arguments
     *
     * @return void
     */
    public function setDefault($callback, ...$arguments)
    {
        if (is_callable($callback)) {
            return $this->default = [$callback, $arguments];

        }
        
        if (is_string($callback)) {
            return $this->default = [$this->callback($callback), $arguments];

        }

        throw new InvalidArgumentException(sprintf(
            "%s expects parameter 1 to be string or callable %s given",
            __FUNCTION__,
            gettype($callback)
        ));
    }

    /**
     * Get the default callback callable and its arguments.
     *
     * @return array
     */
    public function getDefault()
    {
        return $this->default;
    }

    /**
     * Invoke the default callback.
     *
     * @return mixed
     */
    public function invokeDefaultCallback()
    {
        return call_user_func_array(...$this->default);
    }
}


LaraCrafts / laravel-geo-routes

Pull Request — master (#42)

CallbackRegistrar::hasProxy() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like