Casbin\Model\Model

Complexity

Total Complexity

51

Size/Duplication

Total Lines	334
Duplicated Lines	0 %

Test Coverage

Coverage

99.34%

Importance

Changes	3
Bugs	2	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	2	1
A	getNameWithDomain()	0	3	1
A	loadSection()	0	8	3
A	newModelFromFile()	0	7	1
C	getSubjectHierarchyMap()	0	52	12
A	loadFunctionMap()	0	3	1
A	loadModel()	0	10	1
A	getKeySuffix()	0	7	2
A	newModelFromString()	0	7	1
A	printModel()	0	6	3
A	loadModelFromText()	0	10	1
A	newModel()	0	3	1
A	loadAssertion()	0	5	1
A	addDef()	0	22	5
A	sortPoliciesByPriority()	0	19	6
B	sortPoliciesBySubjectHierarchy()	0	37	8
A	__clone()	0	10	3

<?php

Missing file doc comment

declare(strict_types=1);

namespace Casbin\Model;

use Casbin\Config\Config;
use Casbin\Config\ConfigContract;
use Casbin\Constant\Constants;
use Casbin\Exceptions\CasbinException;
use Casbin\Log\Log;
use Casbin\Util\Util;

/**
 * Class Model.
 * Represents the whole access control model.
 *
 * @package Casbin\Model
 * @author techlee@qq.com

Content of the @author tag must be in the form "Display Name <username@example.com>"

Tag value for @author tag indented incorrectly; expected 2 spaces but found 1

 */

Missing @category tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class Model extends Policy
{
    const DEFAULT_DOMAIN = '';
    const DEFAULT_SEPARATOR = '::';

    /**

Missing short description in doc comment

     * @var array<string, string>
     */
    protected $sectionNameMap = [
        'r' => 'request_definition',
        'p' => 'policy_definition',
        'g' => 'role_definition',
        'e' => 'policy_effect',
        'm' => 'matchers',
    ];

    public function __construct()

Missing doc comment for function __construct()

    {
    }

    public function __clone()

Missing doc comment for function __clone()

    {
        $this->sectionNameMap = $this->sectionNameMap;
        $newAstMap = [];
        foreach ($this->items as $ptype => $ast) {
            foreach ($ast as $i => $v) {
                $newAstMap[$ptype][$i] = clone $v;
            }
        }
        $this->items = $newAstMap;
    }

    /**

Missing short description in doc comment

     * @param ConfigContract $cfg

Missing parameter comment

     * @param string $sec

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     * @param string $key

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     *
     * @return bool
     * @throws CasbinException
     */
    private function loadAssertion(ConfigContract $cfg, string $sec, string $key): bool

Private method name "Model::loadAssertion" must be prefixed with an underscore

    {
        $value = $cfg->getString($this->sectionNameMap[$sec] . '::' . $key);

        return $this->addDef($sec, $key, $value);
    }

    /**
     * Adds an assertion to the model.
     *
     * @param string $sec

Missing parameter comment

     * @param string $key

Missing parameter comment

     * @param string $value

Missing parameter comment

     *
     * @return bool
     * @throws CasbinException
     */
    public function addDef(string $sec, string $key, string $value): bool
    {
        if ('' == $value) {
            return false;
        }

        $ast = new Assertion();
        $ast->key = $key;
        $ast->value = $value;

        if ('r' == $sec || 'p' == $sec) {
            $ast->tokens = explode(',', $ast->value);
            foreach ($ast->tokens as $i => $token) {
                $ast->tokens[$i] = $key . '_' . trim($token);
            }
        } else {
            $ast->value = Util::removeComments(Util::escapeAssertion($ast->value));
        }

        $this->items[$sec][$key] = $ast;

        return true;
    }

    /**

Missing short description in doc comment

     * @param int $i

Missing parameter comment

     *
     * @return string
     */
    private function getKeySuffix(int $i): string

Private method name "Model::getKeySuffix" must be prefixed with an underscore

    {
        if (1 == $i) {
            return '';
        }

        return (string)$i;
    }

    /**

Missing short description in doc comment

     * @param ConfigContract $cfg

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @param string $sec

Expected 9 spaces after parameter type; 1 found

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @throws CasbinException

Tag @throws cannot be grouped with parameter tags in a doc comment

     */

Missing @return tag in function comment

    private function loadSection(ConfigContract $cfg, string $sec): void

Private method name "Model::loadSection" must be prefixed with an underscore

    {
        $i = 1;
        for (; ;) {
            if (!$this->loadAssertion($cfg, $sec, $sec . $this->getKeySuffix($i))) {
                break;
            } else {
                ++$i;
            }
        }
    }

    /**
     * Creates an empty model.
     *
     * @return Model
     */
    public static function newModel(): self
    {
        return new self();
    }

    /**
     * Creates a model from a .CONF file.
     *
     * @param string $path

Missing parameter comment

     *
     * @return Model
     * @throws CasbinException
     */
    public static function newModelFromFile(string $path): self
    {
        $m = self::newModel();

        $m->loadModel($path);

        return $m;
    }

    /**
     * Creates a model from a string which contains model text.
     *
     * @param string $text

Missing parameter comment

     *
     * @return Model
     * @throws CasbinException
     */
    public static function newModelFromString(string $text): self
    {
        $m = self::newModel();

        $m->loadModelFromText($text);

        return $m;
    }

    /**
     * Loads the model from model CONF file.
     *
     * @param string $path

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @throws CasbinException

Tag @throws cannot be grouped with parameter tags in a doc comment

     */

Missing @return tag in function comment

    public function loadModel(string $path): void
    {
        $cfg = Config::newConfig($path);

        $this->loadSection($cfg, 'r');
        $this->loadSection($cfg, 'p');
        $this->loadSection($cfg, 'e');
        $this->loadSection($cfg, 'm');

        $this->loadSection($cfg, 'g');
    }

    /**
     * Loads the model from the text.
     *
     * @param string $text

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @throws CasbinException

Tag @throws cannot be grouped with parameter tags in a doc comment

     */

Missing @return tag in function comment

    public function loadModelFromText(string $text): void
    {
        $cfg = Config::newConfigFromText($text);

        $this->loadSection($cfg, 'r');
        $this->loadSection($cfg, 'p');
        $this->loadSection($cfg, 'e');
        $this->loadSection($cfg, 'm');

        $this->loadSection($cfg, 'g');
    }

    /**
     * Prints the model to the log.
     */

Missing @return tag in function comment

    public function printModel(): void
    {
        Log::logPrint('Model:');
        foreach ($this->items as $k => $v) {
            foreach ($v as $i => $j) {
                Log::logPrintf('%s.%s: %s', $k, $i, $j->value);
            }
        }
    }

    /**
     * Loads an initial function map.
     *
     * @return FunctionMap
     */
    public static function loadFunctionMap(): FunctionMap
    {
        return FunctionMap::loadFunctionMap();
    }

    public function getNameWithDomain(string $domain, string $name): string

Missing doc comment for function getNameWithDomain()

    {
        return $domain . self::DEFAULT_SEPARATOR . $name;
    }

    public function getSubjectHierarchyMap(array $policies): array

Missing doc comment for function getSubjectHierarchyMap()

    {
        $subjectHierarchyMap = [];
        // Tree structure of role
        $policyMap = [];
        foreach ($policies as $policy) {
            if (count($policy) < 2) {
                throw new CasbinException('policy g expect 2 more params');
            }
            $domain = self::DEFAULT_DOMAIN;
            if (count($policy) != 2) {
                $domain = $policy[2];
            }
            $child = $this->getNameWithDomain($domain, $policy[0]);
            $parent = $this->getNameWithDomain($domain, $policy[1]);
            $policyMap[$parent][] = $child;
            if (!isset($subjectHierarchyMap[$child])) {
                $subjectHierarchyMap[$child] = 0;
            }
            if (!isset($subjectHierarchyMap[$parent])) {
                $subjectHierarchyMap[$parent] = 0;
            }
            $subjectHierarchyMap[$child] = 1;
        }
        // Use queues for levelOrder
        $queue = [];
        foreach ($subjectHierarchyMap as $k => $v) {
            $root = $k;
            if ($v != 0) {
                continue;
            }
            $lv = 0;
            $queue[] = $root;
            while (count($queue) != 0) {
                $sz = count($queue);
                for ($i = 0; $i < $sz; $i++) {
                    $node = $queue[array_key_first($queue)];
                    unset($queue[array_key_first($queue)]);

                    $nodeValue = $node;
                    $subjectHierarchyMap[$nodeValue] = $lv;
                    if (isset($policyMap[$nodeValue])) {
                        foreach ($policyMap[$nodeValue] as $child) {
                            $queue[] = $child;
                        }
                    }
                }
                $lv++;
            }
        }

        return $subjectHierarchyMap;
    }

    public function sortPoliciesBySubjectHierarchy(): void

Missing doc comment for function sortPoliciesBySubjectHierarchy()

    {
        if ($this->items['e']['e']->value != Constants::SUBJECT_PRIORITY_EFFECT) {
            return;
        }
        $subIndex = 0;

        foreach ($this->items['p'] as $ptype => $assertion) {
            try {
                $domainIndex = $this->getFieldIndex($ptype, Constants::DOMAIN_INDEX);
            } catch (CasbinException $e) {
                $domainIndex = -1;
            }
            $policies = &$assertion->policy;
            $subjectHierarchyMap = $this->getSubjectHierarchyMap($this->items['g']['g']->policy);

            usort($policies, function ($i, $j) use ($subIndex, $domainIndex, $subjectHierarchyMap): int {

The opening parenthesis of a multi-line function call should be the last content on the line.

                $domain1 = self::DEFAULT_DOMAIN;
                $domain2 = self::DEFAULT_DOMAIN;
                if ($domainIndex != -1) {
                    $domain1 = $i[$domainIndex];
                    $domain2 = $j[$domainIndex];
                }
                $name1 = $this->getNameWithDomain($domain1, $i[$subIndex]);
                $name2 = $this->getNameWithDomain($domain2, $j[$subIndex]);

                $p1 = $subjectHierarchyMap[$name1] ?? 0;
                $p2 = $subjectHierarchyMap[$name2] ?? 0;

                if ($p1 == $p2) {
                    return 0;
                }
                return ($p1 > $p2) ? -1 : 1;
            });

For multi-line function calls, the closing parenthesis should be on a new line.

            foreach ($assertion->policy as $i => $policy) {
                $assertion->policyMap[implode(',', $policy)] = $i;
            }
        }
    }

    public function sortPoliciesByPriority(): void

Missing doc comment for function sortPoliciesByPriority()

    {
        foreach ($this->items['p'] as $ptype => $assertion) {
            try {
                $priorityIndex = $this->getFieldIndex($ptype, Constants::PRIORITY_INDEX);
            } catch (CasbinException $e) {
                continue;
            }
            $policies = &$assertion->policy;
            usort($policies, function ($i, $j) use ($priorityIndex): int {

The opening parenthesis of a multi-line function call should be the last content on the line.

                $p1 = $i[$priorityIndex];
                $p2 = $j[$priorityIndex];
                if ($p1 == $p2) {
                    return 0;
                }
                return ($p1 < $p2) ? -1 : 1;
            });

For multi-line function calls, the closing parenthesis should be on a new line.

            foreach ($assertion->policy as $i => $policy) {
                $assertion->policyMap[implode(',', $policy)] = $i;
            }
        }
    }
}