Jlis\Judge\Judges\Judge

Complexity

Total Complexity

21

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	decideRules()	0	30	11
D	decideRule()	0	42	9

<?php

namespace Jlis\Judge\Judges;

use Jlis\Judge\Contracts\VoterInterface;
use Jlis\Judge\Adapters\AdapterInterface;

/**
 * @author Julius Ehrlich <julius@ehrlich-bros.de>
 */
class Judge
{
    const RULE_PARAM_DELIMITER = ':';
    const RULE_INVERTER = '!';
    const FIELD_VALUE = 'value';
    const FIELD_FILTERS = 'filters';

    /**
     * @var AdapterInterface
     */
    protected $adapter;
    /**
     * @var VoterInterface[]
     */
    protected $voters = [];

    /**
     * Constructor.
     *
     * @param AdapterInterface $adapter
     * @param VoterInterface[] $voters
     */
    public function __construct(AdapterInterface $adapter, array $voters = [])
    {
        $this->adapter = $adapter;
        $this->voters = $voters;
    }

    /**
     * Decides multiple rules.
     *
     * @param string|array $rules
     * @param mixed        $user
     *
     * @return bool
     */
    protected function decideRules($rules, $user = null)
    {
        if (is_string($rules)) {
            return $this->decideRule($rules, $user);
        }

        if (! is_array($rules) || empty($rules)) {
            return false;
        }

        if (isset($rules[self::FIELD_VALUE]) && ! isset($rules[self::FIELD_FILTERS])) {
            return $rules[self::FIELD_VALUE];
        }

        if (array_key_exists(self::FIELD_VALUE, $rules) && array_key_exists(self::FIELD_FILTERS, $rules)) {
            if ($this->decideRules($rules[self::FIELD_FILTERS], $user)) {
                return $rules[self::FIELD_VALUE];
            }

            return false;
        }

        foreach ($rules as $subRules) {
            if (! $this->decideRule($subRules, $user)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Decides a single rule.
     *
     * @param string $rule
     * @param mixed  $user
     *
     * @return bool
     */
    protected function decideRule($rule, $user = null)
    {
        $parameter = null;
        $additional = [];
        $negative = false;

        if (0 === strpos($rule, self::RULE_INVERTER)) {
            $negative = true;
            $rule = substr($rule, 1);
        }

        if (false !== strpos($rule, self::RULE_PARAM_DELIMITER)) {
            $splits = explode(self::RULE_PARAM_DELIMITER, $rule);
            $rule = array_shift($splits);
            $parameter = array_shift($splits);

            if (! empty($splits)) {
                $additional = $splits;
            }
        }

        if (! isset($this->voters[strtolower($rule)])) {
            return false;
        }

        $voter = $this->voters[strtolower($rule)];
        if (! is_object($voter)) {
            if (! class_exists($voter)) {
                return false;
            }

            $voter = new $voter();
        }

        if (! $voter instanceof VoterInterface) {
            return false;
        }

        $result = $voter->vote($parameter, $user, $additional);

        return $negative ? (false === $result) : $result;
    }
}