PhpAbac\Abac

Complexity

Total Complexity

17

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

80%

Importance

Changes	14
Bugs	1	Features	5

4 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	5	1
A	__construct()	0	8	1
C	enforce()	0	37	11
B	processExtraData()	0	22	4

<?php

namespace PhpAbac;

use PhpAbac\Manager\AttributeManager;
use PhpAbac\Manager\PolicyRuleManager;
use PhpAbac\Manager\ConfigurationManager;
use PhpAbac\Manager\CacheManager;
use PhpAbac\Manager\ComparisonManager;

use Symfony\Component\Config\FileLocator;

use PhpAbac\Model\PolicyRuleAttribute;

class Abac
{
    /** @var \PhpAbac\Manager\ConfigurationManager **/
    private $configuration;
    /** @var \PhpAbac\Manager\PolicyRuleManager **/
    private $policyRuleManager;
    /** @var \PhpAbac\Manager\AttributeManager **/
    private $attributeManager;
    /** @var \PhpAbac\Manager\CacheManager **/
    private $cacheManager;
    /** @var \PhpAbac\Manager\ComparisonManager **/
    private $comparisonManager;

    /**
     * @param array $configPaths
     */
    public function __construct($configPaths)
    {
        $this->configure($configPaths);
        $this->attributeManager = new AttributeManager($this->configuration->getAttributes());
        $this->policyRuleManager = new PolicyRuleManager($this->attributeManager, $this->configuration->getRules());
        $this->cacheManager = new CacheManager();
        $this->comparisonManager = new ComparisonManager($this->attributeManager);
    }
    
    /**
     * @param array $configPaths
     */
    public function configure($configPaths) {
        $locator = new FileLocator($configPaths);
        $this->configuration = new ConfigurationManager($locator);
        $this->configuration->parseConfigurationFile($configPaths);
    }

    /**
     * Return true if both user and object respects all the rules conditions
     * If the objectId is null, policy rules about its attributes will be ignored
     * In case of mismatch between attributes and expected values,
     * an array with the concerned attributes slugs will be returned.
     * 
     * Available options are :
     * * dynamic_attributes: array
     * * cache_result: boolean
     * * cache_ttl: integer
     * * cache_driver: string
     * 
     * Available cache drivers are :
     * * memory
     * 
     * @param string $ruleName
     * @param object $user
     * @param object $resource
     * @param array $options
     * @return boolean|array
     */
    public function enforce($ruleName, $user, $resource = null, $options = []) {
        // If there is dynamic attributes, we pass them to the comparison manager
        // When a comparison will be performed, the passed values will be retrieved and used
        if(isset($options['dynamic_attributes'])) {

Expected 1 space after IF keyword; 0 found

            $this->comparisonManager->setDynamicAttributes($options['dynamic_attributes']);
        }
        // Retrieve cache value for the current rule and values if cache item is valid
        if(($cacheResult = isset($options['cache_result']) && $options['cache_result'] === true) === true) {

Consider adding parentheses for clarity. Current Interpretation: $cacheResult = (isset($options['cache_result']) && $options['cache_result'] === true), Probably Intended Meaning: ($cacheResult = isset($options['cache_result'])) && $options['cache_result'] === true

Expected 1 space after IF keyword; 0 found

            $cacheItem = $this->cacheManager->getItem(
                "$ruleName-{$user->getId()}-" . (($resource !== null) ? $resource->getId() : ''),
                (isset($options['cache_driver'])) ? $options['cache_driver'] : null,
                (isset($options['cache_ttl'])) ? $options['cache_ttl'] : null
            );
            // We check if the cache value s valid before returning it
            if(($cacheValue = $cacheItem->get()) !== null) {

Expected 1 space after IF keyword; 0 found

                return $cacheValue;
            }
        }
        $policyRule = $this->policyRuleManager->getRule($ruleName);
        // For each policy rule attribute, we retrieve the attribute value and proceed configured extra data
        foreach ($policyRule->getPolicyRuleAttributes() as $pra) {
            $attribute = $pra->getAttribute();
            $attribute->setValue($this->attributeManager->retrieveAttribute($attribute, $user, $resource));
            if(count($pra->getExtraData()) > 0) {

Expected 1 space after IF keyword; 0 found

                $this->processExtraData($pra, $user, $resource);

It seems like $resource defined by parameter $resource on line 70 can also be of type null; however, PhpAbac\Abac::processExtraData() does only seem to accept object, maybe add an additional type check?

            }
            $this->comparisonManager->compare($pra);
        }
        // The given result could be an array of rejected attributes or true
        // True means that the rule is correctly enforced for the given user and resource
        $result = $this->comparisonManager->getResult();
        if($cacheResult) {

Expected 1 space after IF keyword; 0 found

            $cacheItem->set($result);

The variable $cacheItem does not seem to be defined for all execution paths leading up to this point.

            $this->cacheManager->save($cacheItem);
        }
        return $result;
    }
    
    /**
     * @param \PhpAbac\Model\PolicyRuleAttribute $pra
     * @param object $user
     * @param object $resource
     */
    public function processExtraData(PolicyRuleAttribute $pra, $user, $resource) {
        foreach($pra->getExtraData() as $key => $data) {

Expected 1 space after FOREACH keyword; 0 found

            switch($key) {

Expected 1 space after SWITCH keyword; 0 found

                case 'with':
                    // This data has to be removed for it will be stored elsewhere
                    // in the policy rule attribute
                    $pra->removeExtraData('with');
                    // The "with" extra data is an array of attributes, which are objects
                    // Once we process it as policy rule attributes, we set it as the main policy rule attribute value
                    $subPolicyRuleAttributes = [];
                    foreach($this->policyRuleManager->processRuleAttributes($data) as $subPolicyRuleAttribute) {

Expected 1 space after FOREACH keyword; 0 found

                        $subPolicyRuleAttributes[] = $subPolicyRuleAttribute;
                    }
                    $pra->setValue($subPolicyRuleAttributes);
                    // This data can be used in complex comparisons
                    $pra->addExtraData('attribute', $pra->getAttribute());
                    $pra->addExtraData('user', $user);

$user is of type object, but the function expects a string.

                    $pra->addExtraData('resource', $resource);

$resource is of type object, but the function expects a string.

                    break;
            }
        }
    }
}