Innmind\ProvisionerBundle\TriggerManager

Complexity

Total Complexity

17

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

75.51%

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	addVoter()	0	6	1
C	decide()	0	57	14

<?php

namespace Innmind\ProvisionerBundle;

use Innmind\ProvisionerBundle\Voter\VoterInterface;
use Symfony\Component\Console\Input\InputInterface;

class TriggerManager
{
    const STRATEGY_AFFIRMATIVE = 'affirmative';
    const STRATEGY_CONSENSUS = 'consensus';
    const STRATEGY_UNANIMOUS = 'unanimous';

    protected $voters = [];
    protected $strategy;
    protected $allowIfEqualGrantedDeniedDecisions;
    protected $allowIfAllAbstainDecisions;

    public function __construct($strategy = self::STRATEGY_AFFIRMATIVE, $allowIfEqualGrantedDeniedDecisions = true, $allowIfAllAbstainDecisions = false)
    {
        if (!defined(sprintf('self::STRATEGY_%s', strtoupper($strategy)))) {
            throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported', $strategy));
        }

        $this->strategy = $strategy;
        $this->allowIfEqualGrantedDeniedDecisions = $allowIfEqualGrantedDeniedDecisions;
        $this->allowIfAllAbstainDecisions = $allowIfAllAbstainDecisions;
    }

    /**
     * Add a new voter to the trigger manager
     *
     * @param VoterInterface $voter
     *
     * @return TriggerManager self
     */
    public function addVoter(VoterInterface $voter)
    {
        $this->voters[] = $voter;

        return $this;
    }

    /**
     * Decide if the decision manager should be triggered or not
     *
     * @param string $command
     * @param InputInterface $input
     *
     * @return bool
     */
    public function decide($command, InputInterface $input)
    {
        $grant = 0;
        $deny = 0;
        $abstain = 0;

        foreach ($this->voters as $voter) {
            if (!$voter->supportsCommand($command)) {
                continue;
            }

            $vote = $voter->vote($command, $input);

            switch ($vote) {
                case VoterInterface::TRIGGER_GRANTED:
                    $grant++;
                    break;
                case VoterInterface::TRIGGER_DENIED:
                    $deny++;
                    break;
                default:
                    $abstain++;
                    break;
            }
        }

        switch ($this->strategy) {
            case self::STRATEGY_AFFIRMATIVE:
                return $grant > 0;
            case self::STRATEGY_CONSENSUS:
                if ($grant > $deny) {
                    return true;
                }

                if ($deny > $grant) {
                    return false;
                }

                if ($grant === $deny && $grant !== 0) {
                    return $this->allowIfEqualGrantedDeniedDecisions;
                }

                return $this->allowIfAllAbstainDecisions;
            case self::STRATEGY_UNANIMOUS:
                if ($deny > 0) {
                    return false;
                }

                if ($grant > 0) {
                    return true;
                }

                return $this->allowIfAllAbstainDecisions;
            default:
                return false;
        }
    }
}