LaraCrafts\GeoRoutes\GeoRoute

Complexity

Total Complexity

17

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Test Coverage

Coverage

60.87%

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	allow()	0	5	1
A	__destruct()	0	3	1
A	__call()	0	11	4
A	applyConstraint()	0	17	3
A	setCallback()	0	10	3
A	__construct()	0	6	1
A	orNotFound()	0	3	1
A	orUnauthorized()	0	5	1
A	orRedirectTo()	0	3	1
A	deny()	0	5	1

<?php

namespace LaraCrafts\GeoRoutes;

use BadMethodCallException;
use Illuminate\Routing\Route;
use Illuminate\Support\Str;
use LaraCrafts\GeoRoutes\Support\Facades\CallbackRegistrar;

This use statement conflicts with another class in this namespace, LaraCrafts\GeoRoutes\CallbackRegistrar. Consider defining an alias.

/**
 * @mixin \Illuminate\Routing\Route
 */
class GeoRoute
{
    /**
     * Rule is applied.
     *
     * @var bool
     */
    protected $applied;

    /**
     * The callback to execute if the visitor
     * is not allowed.
     *
     * @var array
     */
    protected $callback;

    /**
     * The countries to apply the rule for.
     *
     * @var array
     */
    protected $countries;

    /**
     * The route.
     *
     * @var \Illuminate\Routing\Route
     */
    protected $route;

    /**
     * The rule's strategy.
     *
     * @var string
     */
    protected $strategy;

    /**
     * Create a new GeoRoute instance.
     *
     * @param  \Illuminate\Routing\Route $route
     * @param  array $countries
     * @param  string $strategy
     */
    public function __construct(Route $route, array $countries, string $strategy)
    {
        $this->applied = false;
        $this->countries = array_map('strtoupper', $countries);
        $this->route = $route;
        $this->strategy = $strategy;
    }

    /**
     * Dynamically call the underlying route.
     *
     * @param string $method
     * @param array $arguments
     *
     * @return mixed
     */
    public function __call(string $method, array $arguments)
    {
        if (method_exists($this->route, $method) || Route::hasMacro($method)) {
            return $this->route->$method(...$arguments);
        }

        if (CallbackRegistrar::hasProxy($method)) {

The method hasProxy() does not exist on LaraCrafts\GeoRoutes\Support\Facades\CallbackRegistrar. Since you implemented __callStatic, consider adding a @method annotation.

            return $this->setCallback(CallbackRegistrar::callback($method), $arguments);

The method callback() does not exist on LaraCrafts\GeoRoutes\Support\Facades\CallbackRegistrar. Since you implemented __callStatic, consider adding a @method annotation.

        }

        throw new BadMethodCallException("Undefined method '$method'");
    }

    /**
     * Destruct the GeoRoute instance and apply the middleware.
     */
    public function __destruct()
    {
        $this->applyConstraint();
    }

    /**
     * Allow given countries.
     *
     * @return $this
     */
    public function allow()
    {
        $this->strategy = 'allow';

        return $this;
    }

    /**
     * Apply the geo-constraint to the route.
     */
    protected function applyConstraint()
    {
        if ($this->applied || !$this->countries) {

The expression $this->countries of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }

        $action = $this->route->getAction();
        $action['middleware'][] = 'geo';
        $action['geo'] = [
            'strategy' => $this->strategy,
            'countries' => (array)$this->countries,
            'callback' => $this->callback,
        ];

        $this->route->setAction($action);

It seems like $action can also be of type null; however, parameter $action of Illuminate\Routing\Route::setAction() does only seem to accept array, maybe add an additional type check?

        $this->applied = true;
    }

    /**
     * Deny given countries.
     *
     * @return $this
     */
    public function deny()
    {
        $this->strategy = 'deny';

        return $this;
    }

    /**
     * Return a HTTP 404 error if access is denied.
     *
     * @return $this
     */
    public function orNotFound()
    {
        return $this->setCallback('LaraCrafts\GeoRoutes\Callbacks::notFound', func_get_args());
    }

    /**
     * Redirect to given route if access is denied.
     *
     * @param string $routeName
     *
     * @return $this
     */
    public function orRedirectTo(string $routeName)
    {
        return $this->setCallback('LaraCrafts\GeoRoutes\Callbacks::redirectTo', func_get_args());
    }

    /**
     * Return a HTTP 401 error if access is denied (this is the default behavior).
     *
     * @return $this
     */
    public function orUnauthorized()
    {
        $this->callback = null;

        return $this;
    }

    /**
     * Set the callback.
     *
     * @param callable $callback
     * @param array $arguments
     *
     * @return $this
     */
    protected function setCallback(callable $callback, array $arguments)
    {
        if (is_string($callback) && Str::contains($callback, '@')) {
            $callback = Str::parseCallback($callback, '__invoke');
            $callback[0] = resolve($callback[0]);
        }

        $this->callback = [$callback, $arguments];

        return $this;
    }
}