PhpAbac\Manager\ComparisonManager

Complexity

Total Complexity

15

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

92.5%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
C	compare()	0	32	7
A	setDynamicAttributes()	0	3	1
A	getDynamicAttribute()	0	6	2
A	addComparison()	0	3	1
A	getAttributeManager()	0	3	1
A	getResult()	0	9	2

<?php

namespace PhpAbac\Manager;

use PhpAbac\Model\PolicyRuleAttribute;

use PhpAbac\Comparison\ArrayComparison;
use PhpAbac\Comparison\BooleanComparison;
use PhpAbac\Comparison\DatetimeComparison;
use PhpAbac\Comparison\NumericComparison;
use PhpAbac\Comparison\ObjectComparison;
use PhpAbac\Comparison\UserComparison;
use PhpAbac\Comparison\StringComparison;

class ComparisonManager {
    /** @var \PhpAbac\Manager\AttributeManager **/
    protected $attributeManager;
    /** @var array **/
    protected $comparisons = [
        'array' => ArrayComparison::class,
        'boolean' => BooleanComparison::class,
        'datetime' => DatetimeComparison::class,
        'numeric' => NumericComparison::class,
        'object' => ObjectComparison::class,
        'user' => UserComparison::class,
        'string' => StringComparison::class,
    ];
    /** @var array **/
    protected $rejectedAttributes = [];

    /**
     * @param \PhpAbac\Manager\AttributeManager $manager
     */
    public function __construct(AttributeManager $manager) {
        $this->attributeManager = $manager;
    }

    /**
     * This method retrieve the comparison class, instanciate it,
     * and then perform the configured comparison
     * It does return a control value for special operations,
     * but the real check is at the end of the enforce() method,
     * when the rejected attributes are counted.
     *
     * If the second parameter is set to true, compare will not report errors.
     * This is used to test a bunch of comparisons expecting not all of them true to return a granted access.
     * In fact, this parameter is used in comparisons which need to perform comparisons on their own.
     *
     * @param PolicyRuleAttribute $pra
     * @param boolean $subComparing
     * @return bool
     */
    public function compare(PolicyRuleAttribute $pra, $subComparing = false) {
        $attribute = $pra->getAttribute();
        // The expected value can be set in the configuration as dynamic
        // In this case, we retrieve the expected value in the passed options
        $praValue =
            ($pra->getValue() === 'dynamic')
            ? $this->getDynamicAttribute($attribute->getSlug())
            : $pra->getValue()
        ;
        // Checking that the configured comparison type is available
        if(!isset($this->comparisons[$pra->getComparisonType()])) {

Expected 1 space after IF keyword; 0 found

            throw new \InvalidArgumentException('The requested comparison class does not exist');
        }
        // The comparison class will perform the attribute check with the configured method
        // For more complex comparisons, the comparison manager is injected
        $comparison = new $this->comparisons[$pra->getComparisonType()]($this);
        if(!method_exists($comparison, $pra->getComparison())) {

Expected 1 space after IF keyword; 0 found

            throw new \InvalidArgumentException('The requested comparison method does not exist');
        }
        // Then the comparison is performed with needed
        $result = $comparison->{$pra->getComparison()}($praValue, $attribute->getValue(), $pra->getExtraData());
        // If the checked attribute is not valid, the attribute slug is marked as rejected
        // The rejected attributes will be returned instead of the expected true boolean
        if($result !== true) {

Expected 1 space after IF keyword; 0 found

            // In case of sub comparing, the error reporting is disabled
            if(!in_array($attribute->getSlug(), $this->rejectedAttributes) && $subComparing === false) {

Expected 1 space after IF keyword; 0 found

                $this->rejectedAttributes[] = $attribute->getSlug();
            }
            return false;
        }
        return true;
    }

    /**
     * @param array $dynamicAttributes
     */
    public function setDynamicAttributes($dynamicAttributes) {
        $this->dynamicAttributes = $dynamicAttributes;

The property dynamicAttributes does not exist. Did you maybe forget to declare it?

    }

    /**
     * A dynamic attribute is a value given by the user code as an option
     * If a policy rule attribute is dynamic,
     * we check that the developer has given a dynamic value in the options
     *
     * Dynamic attributes are given with slugs as key
     *
     * @param string $attributeSlug
     * @return mixed
     * @throws \InvalidArgumentException
     */
    public function getDynamicAttribute($attributeSlug) {
        if(!isset($this->dynamicAttributes[$attributeSlug])) {

Expected 1 space after IF keyword; 0 found

            throw new \InvalidArgumentException("The dynamic value for attribute $attributeSlug was not given");
        }
        return $this->dynamicAttributes[$attributeSlug];
    }

    /**
     * @param string $type
     * @param string $class
     */
    public function addComparison($type, $class) {
        $this->comparisons[$type] = $class;
    }

    /**
     * @return \PhpAbac\Manager\AttributeManager
     */
    public function getAttributeManager() {
        return $this->attributeManager;
    }

    /**
     * This method is called when all the policy rule attributes are checked
     * All along the comparisons, the failing attributes slugs are stored
     * If the rejected attributes array is not empty, it means that the rule is not enforced
     *
     * @return array|bool
     */
    public function getResult() {
        $result =
            (count($this->rejectedAttributes) > 0)
            ? $this->rejectedAttributes
            : true
        ;
        $this->rejectedAttributes = [];
        return $result;
    }
}