Vehikl\Flip\Feature

Complexity

Total Complexity

17

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	new()	0	4	1
	toggles()	0	1	?
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
A	alwaysOn()	0	4	1
A	alwaysOff()	0	4	1
A	hasForcedState()	0	4	1
A	isAlwaysOn()	0	4	1

<?php

namespace Vehikl\Flip;

/**
 * @method boolean enabled(...$params)
 */
abstract class Feature
{
    const ENABLED = 'enabled';
    const DISABLED = 'disabled';

    private static $resolver;
    protected $caller;
    protected static $forceState;

    // 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 registerResolver($resolver): void
    {
        self::$resolver = $resolver;
    }

    public function resolver(): 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);
    }

    public static function alwaysOn() : void
    {
        static::$forceState = self::ENABLED;
    }

    public static function alwaysOff() : void
    {
        static::$forceState = self::DISABLED;
    }

    public function hasForcedState() : bool
    {
        return static::$forceState !== null;
    }

    public function isAlwaysOn() : bool
    {
        return static::$forceState === self::ENABLED;
    }
}