Vehikl\Flip\Feature

Complexity

Total Complexity

16

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

82.05%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	new()	0	4	1
	toggles()	0	1	?
A	registerContainer()	0	4	1
A	container()	0	8	2
A	registerResolver()	0	4	1
A	resolver()	0	8	2
A	hasToggle()	0	4	1
A	caller()	0	4	1
A	methodToCall()	0	11	3
A	__call()	0	14	2
A	__callStatic()	0	10	1

<?php

namespace Vehikl\Flip;

use Illuminate\Container\Container;

/**
 * @method boolean enabled(...$params)
 */
abstract class Feature
{
    private static $container;
    private static $resolver;
    protected $caller;

    // Maybe it's worth requiring an interface be applied?
    public function __construct($caller)
    {
        $this->caller = $caller;
    }

    public static function new($caller): Feature
    {
        return new static($caller);
    }

    abstract public function toggles(): array;

    public static function registerContainer(Container $container): void
    {
        self::$container = $container;
    }

    public function container(): Container
    {
        if (! self::$container) {
            self::registerContainer(new Container);
        }

        return self::$container;
    }

    public static function registerResolver($resolver)
    {
        self::$resolver = $resolver;
    }

    public function resolver()
    {
        if (! self::$resolver) {
            self::registerResolver(new DefaultResolver);
        }

        return self::$resolver;
    }

    public function hasToggle(string $method): bool
    {
        return array_key_exists($method, $this->toggles());
    }

    protected function caller()
    {
        return $this->caller;
    }

    private function methodToCall(string $toggle): string
    {
        $toggles = $this->toggles();

        if (array_key_exists($toggle, $toggles)) {
            // if $toggles was a class, it'd be a lot less error prone.
            return $this->resolver()->resolve($this, 'enabled') ? $toggles[$toggle]['on'] : $toggles[$toggle]['off'];
        }

        return $toggle;
    }

    public function __call($name, $arguments)
    {
        $methodToCall = $this->methodToCall($name);

        if (method_exists($this, $methodToCall)) {
            return $this->{$methodToCall}(...$arguments);
        }

        // Probably easier to just expect a public method.
        $name = (new \ReflectionClass($this->caller()))->getMethod($methodToCall);
        $name->setAccessible(true);

        return $name->invoke($this->caller(), $arguments);
    }

    public static function __callStatic($method, $arguments)
    {
        // Could be extracted, but I wonder how reliable this would be?
        // Does it really improve the API that much?
        $caller = Caller::guess();

        $instance = new static($caller);

        return $instance->{$method}($arguments);
    }
}