11444189732

Committed 21 Oct 2024 04:08PM UTC coverage: 94.006% (+0.2%) from 93.837%

Build # 11444189732

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #167 from php-casbin/4.x

BREAKING CHANGE: Upgrade the minimum PHP version to 8.0.

Run Details

716 of 758 new or added lines in 23 files covered. (94.46%)

10 existing lines in 4 files now uncovered.

1976 of 2102 relevant lines covered (94.01%)

134.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.25

/src/Rbac/DefaultRoleManager/Traits/DomainManager.php

<?php

declare(strict_types=1);

namespace Casbin\Rbac\DefaultRoleManager\Traits;

use Casbin\Rbac\DefaultRoleManager\RoleManager as DefaultRoleManager;
use Casbin\Rbac\RoleManager as RoleManagerContract;
use Closure;

/**
 * Trait DomainManager.
 * Provides methods to manage roles in a domain.
 *
 * @author 1692898084@qq.com
 */
trait DomainManager
{
    use BaseManager;

    /**
     * Support use pattern in g.
     *
     * @param string $name
     * @param Closure $fn
     */
    public function addMatchingFunc(string $name, Closure $fn): void
    {
        $this->matchingFunc = $fn;
        foreach ($this->rmMap as $_ => &$rm) {
            $rm->addMatchingFunc($name, $fn);
        }
    }

    /**
     * Support use domain pattern in g.
     *
     * @param string $name
     * @param Closure $fn
     */
    public function addDomainMatchingFunc(string $name, Closure $fn): void
    {
        $this->domainMatchingFunc = $fn;
        foreach ($this->rmMap as $_ => &$rm) {
            $rm->addDomainMatchingFunc($name, $fn);
        }
        $this->rebuild();
    }

    /**
     * Clears the map of RoleManagers.
     */
    public function rebuild(): void
    {
        $rmMap = $this->rmMap;
        $this->clear();
        foreach ($rmMap as $domain => &$rm) {
            $rm->rangeSelfLinks(function ($name1, $name2, $_) use ($domain) {
                $this->addLink($name1, $name2, $domain);
            });
        }
    }

    /**
     * Clears all stored data and resets the role manager to the initial state.
     */
    public function clear(): void
    {
        $this->rmMap = [];
    }

    /**
     * Gets the domain from the given arguments.
     *
     * @param string|null $domain
     * @return string
     */
    public function getDomain(?string $domain = null): string
    {
        if (is_null($domain)) {
            return RoleManagerContract::DEFAULT_DOMAIN;
        }
        return $domain;
    }

    /**
     * Determines whether a string matches a pattern.
     *
     * @param string $str
     * @param string $pattern
     * @return bool
     */
    public function match(string $str, string $pattern): bool
    {
        if ($str === $pattern) {
            return true;
        }

        if (!is_null($this->domainMatchingFunc)) {
            return call_user_func($this->domainMatchingFunc, $str, $pattern) === true;
        } else {
            return false;
        }
    }

    /**
     * Applies a callback to all RoleManagers that match the given domain.
     *
     * @param string $domain
     * @param Closure $fn
     */
    public function rangeAffectedRoleManagers(string $domain, Closure $fn): void
    {
        if (!is_null($this->domainMatchingFunc)) {
            foreach ($this->rmMap as $domain2 => &$rm) {
                if ($domain !== $domain2 && $this->match($domain2, $domain)) {
                    $fn($rm);
                }
            }
        }
    }


    /**
     * Gets the RoleManager for the given domain.
     *
     * @param string $domain
     * @param bool $store
     * @return DefaultRoleManager
     */
    public function &getRoleManager(string $domain, bool $store): DefaultRoleManager
    {
        if (isset($this->rmMap[$domain])) {
            return $this->rmMap[$domain];
        }

        $rm = new DefaultRoleManager($this->maxHierarchyLevel, $this->matchingFunc);
        if ($store) {
            $this->rmMap[$domain] = $rm;
        }
        if (!is_null($this->domainMatchingFunc)) {
            foreach ($this->rmMap as $domain2 => &$rm2) {
                if ($domain !== $domain2 && $this->match($domain, $domain2)) {
                    $rm->copyFrom($rm2);
                }
            }
        }

        return $rm;
    }

    /**
     * Adds the inheritance link between role: name1 and role: name2.
     * aka role: name1 inherits role: name2.
     * domain is a prefix to the roles.
     *
     * @param string $name1
     * @param string $name2
     * @param string ...$domains
     */
    public function addLink(string $name1, string $name2, string ...$domains): void
    {
        $domain = $this->getDomain(...$domains);
        $rm = &$this->getRoleManager($domain, true);
        $rm->addLink($name1, $name2);
        
        $this->rangeAffectedRoleManagers($domain, function (&$rm) use ($name1, $name2) {
            $rm->addLink($name1, $name2);
        });
    }

    /**
     * Deletes the inheritance link between role: name1 and role: name2.
     * aka role: name1 does not inherit role: name2 any more.
     * domain is a prefix to the roles.
     *
     * @param string $name1
     * @param string $name2
     * @param string ...$domains
     */
    public function deleteLink(string $name1, string $name2, string ...$domains): void
    {
        $domain = $this->getDomain(...$domains);
        $rm = &$this->getRoleManager($domain, true);
        $rm->deleteLink($name1, $name2);

        $this->rangeAffectedRoleManagers($domain, function (&$rm) use ($name1, $name2) {
            $rm->deleteLink($name1, $name2);
        });
    }

    /**
     * Determines whether role: name1 inherits role: name2.
     * domain is a prefix to the roles.
     *
     * @param string $name1
     * @param string $name2
     * @param string ...$domains
     *
     * @return bool
     */
    public function hasLink(string $name1, string $name2, string ...$domains): bool
    {
        $domain = $this->getDomain(...$domains);
        $rm = &$this->getRoleManager($domain, false);
        return $rm->hasLink($name1, $name2, ...$domains);
    }

    /**
     * Gets the roles that a subject inherits.
     * domain is a prefix to the roles.
     *
     * @param string $name
     * @param string ...$domains
     *
     * @return string[]
     */
    public function getRoles(string $name, string ...$domains): array
    {
        $domain = $this->getDomain(...$domains);
        $rm = &$this->getRoleManager($domain, false);
        return $rm->getRoles($name, ...$domains);
    }

    /**
     * Gets the users that inherits a subject.
     * domain is an unreferenced parameter here, may be used in other implementations.
     *
     * @param string $name
     * @param string ...$domains
     *
     * @return string[]
     */
    public function getUsers(string $name, string ...$domains): array
    {
        $domain = $this->getDomain(...$domains);
        $rm = &$this->getRoleManager($domain, false);
        return $rm->getUsers($name, ...$domains);
    }


    /**
     * Converts the roles to a string array.
     *
     * @return string[]
     */
    public function toString(): array
    {
        $roles = [];

        foreach ($this->rmMap as $domain => &$rm) {
            $domainRoles = $rm->toString();
            $roles[] = sprintf('%s: %s', $domain, implode(', ', $domainRoles));
        }

        return $roles;
    }

    /**
     * Prints all the roles to log.
     */
    public function printRoles(): void
    {
        if (!$this->logger->isEnabled()) {
            return;
        }

        $roles = $this->toString();
        $this->logger->logRole($roles);
    }

    /**
     * Gets the domains that a subject inherits.
     *
     * @param string $name
     *
     * @return string[]
     */
    public function getDomains(string $name): array
    {
        $domains = [];
        foreach ($this->rmMap as $domain => &$rm) {
            $roleGet = $rm->getRole($name);
            $role = $roleGet[0];
            $roleCreated = $roleGet[1];

            if (count($role->getUsers()) > 0 || count($role->getRoles()) > 0) {
                $domains[] = $domain;
            }

            if ($roleCreated) {
                $this->removeRole($role->name);
            }
        }
        return $domains;
    }

    /**
     * Gets all the domains.
     *
     * @return string[]
     */
    public function getAllDomains(): array
    {
        $domains = [];
        foreach ($this->rmMap as $domain => $_) {
            $domains[] = $domain;
        }
        return $domains;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Casbin\Rbac\DefaultRoleManager\Traits;
6
7	use Casbin\Rbac\DefaultRoleManager\RoleManager as DefaultRoleManager;
8	use Casbin\Rbac\RoleManager as RoleManagerContract;
9	use Closure;
10
11	/**
12	* Trait DomainManager.
13	* Provides methods to manage roles in a domain.
14	*
15	* @author 1692898084@qq.com
16	*/
17	trait DomainManager
18	{
19	use BaseManager;
20
21	/**
22	* Support use pattern in g.
23	*
24	* @param string $name
25	* @param Closure $fn
26	*/
27	public function addMatchingFunc(string $name, Closure $fn): void
28	{
29	$this->matchingFunc = $fn;	6✔
30	foreach ($this->rmMap as $_ => &$rm) {	6✔
31	$rm->addMatchingFunc($name, $fn);	6✔
32	}
33	}
34
35	/**
36	* Support use domain pattern in g.
37	*
38	* @param string $name
39	* @param Closure $fn
40	*/
41	public function addDomainMatchingFunc(string $name, Closure $fn): void
42	{
43	$this->domainMatchingFunc = $fn;	48✔
44	foreach ($this->rmMap as $_ => &$rm) {	48✔
45	$rm->addDomainMatchingFunc($name, $fn);	12✔
46	}
47	$this->rebuild();	48✔
48	}
49
50	/**
51	* Clears the map of RoleManagers.
52	*/
53	public function rebuild(): void
54	{
55	$rmMap = $this->rmMap;	48✔
56	$this->clear();	48✔
57	foreach ($rmMap as $domain => &$rm) {	48✔
58	$rm->rangeSelfLinks(function ($name1, $name2, $_) use ($domain) {	12✔
59	$this->addLink($name1, $name2, $domain);	12✔
60	});	12✔
61	}
62	}
63
64	/**
65	* Clears all stored data and resets the role manager to the initial state.
66	*/
67	public function clear(): void
68	{
69	$this->rmMap = [];	210✔
70	}
71
72	/**
73	* Gets the domain from the given arguments.
74	*
75	* @param string\|null $domain
76	* @return string
77	*/
78	public function getDomain(?string $domain = null): string
79	{
80	if (is_null($domain)) {	204✔
NEW 81	return RoleManagerContract::DEFAULT_DOMAIN;	×
82	}
83	return $domain;	204✔
84	}
85
86	/**
87	* Determines whether a string matches a pattern.
88	*
89	* @param string $str
90	* @param string $pattern
91	* @return bool
92	*/
93	public function match(string $str, string $pattern): bool
94	{
95	if ($str === $pattern) {	48✔
96	return true;	6✔
97	}
98
99	if (!is_null($this->domainMatchingFunc)) {	48✔
100	return call_user_func($this->domainMatchingFunc, $str, $pattern) === true;	48✔
101	} else {
102	return false;	6✔
103	}
104	}
105
106	/**
107	* Applies a callback to all RoleManagers that match the given domain.
108	*
109	* @param string $domain
110	* @param Closure $fn
111	*/
112	public function rangeAffectedRoleManagers(string $domain, Closure $fn): void
113	{
114	if (!is_null($this->domainMatchingFunc)) {	204✔
115	foreach ($this->rmMap as $domain2 => &$rm) {	42✔
116	if ($domain !== $domain2 && $this->match($domain2, $domain)) {	42✔
117	$fn($rm);	12✔
118	}
119	}
120	}
121	}
122
123
124	/**
125	* Gets the RoleManager for the given domain.
126	*
127	* @param string $domain
128	* @param bool $store
129	* @return DefaultRoleManager
130	*/
131	public function &getRoleManager(string $domain, bool $store): DefaultRoleManager
132	{
133	if (isset($this->rmMap[$domain])) {	180✔
134	return $this->rmMap[$domain];	138✔
135	}
136
137	$rm = new DefaultRoleManager($this->maxHierarchyLevel, $this->matchingFunc);	180✔
138	if ($store) {	180✔
139	$this->rmMap[$domain] = $rm;	180✔
140	}
141	if (!is_null($this->domainMatchingFunc)) {	180✔
142	foreach ($this->rmMap as $domain2 => &$rm2) {	36✔
143	if ($domain !== $domain2 && $this->match($domain, $domain2)) {	36✔
144	$rm->copyFrom($rm2);	36✔
145	}
146	}
147	}
148
149	return $rm;	180✔
150	}
151
152	/**
153	* Adds the inheritance link between role: name1 and role: name2.
154	* aka role: name1 inherits role: name2.
155	* domain is a prefix to the roles.
156	*
157	* @param string $name1
158	* @param string $name2
159	* @param string ...$domains
160	*/
161	public function addLink(string $name1, string $name2, string ...$domains): void
162	{
163	$domain = $this->getDomain(...$domains);	180✔
164	$rm = &$this->getRoleManager($domain, true);	180✔
165	$rm->addLink($name1, $name2);	180✔
166
167	$this->rangeAffectedRoleManagers($domain, function (&$rm) use ($name1, $name2) {	180✔
168	$rm->addLink($name1, $name2);	6✔
169	});	180✔
170	}
171
172	/**
173	* Deletes the inheritance link between role: name1 and role: name2.
174	* aka role: name1 does not inherit role: name2 any more.
175	* domain is a prefix to the roles.
176	*
177	* @param string $name1
178	* @param string $name2
179	* @param string ...$domains
180	*/
181	public function deleteLink(string $name1, string $name2, string ...$domains): void
182	{
183	$domain = $this->getDomain(...$domains);	48✔
184	$rm = &$this->getRoleManager($domain, true);	48✔
185	$rm->deleteLink($name1, $name2);	48✔
186
187	$this->rangeAffectedRoleManagers($domain, function (&$rm) use ($name1, $name2) {	48✔
NEW 188	$rm->deleteLink($name1, $name2);	×
189	});	48✔
190	}
191
192	/**
193	* Determines whether role: name1 inherits role: name2.
194	* domain is a prefix to the roles.
195	*
196	* @param string $name1
197	* @param string $name2
198	* @param string ...$domains
199	*
200	* @return bool
201	*/
202	public function hasLink(string $name1, string $name2, string ...$domains): bool
203	{
204	$domain = $this->getDomain(...$domains);	54✔
205	$rm = &$this->getRoleManager($domain, false);	54✔
206	return $rm->hasLink($name1, $name2, ...$domains);	54✔
207	}
208
209	/**
210	* Gets the roles that a subject inherits.
211	* domain is a prefix to the roles.
212	*
213	* @param string $name
214	* @param string ...$domains
215	*
216	* @return string[]
217	*/
218	public function getRoles(string $name, string ...$domains): array
219	{
220	$domain = $this->getDomain(...$domains);	54✔
221	$rm = &$this->getRoleManager($domain, false);	54✔
222	return $rm->getRoles($name, ...$domains);	54✔
223	}
224
225	/**
226	* Gets the users that inherits a subject.
227	* domain is an unreferenced parameter here, may be used in other implementations.
228	*
229	* @param string $name
230	* @param string ...$domains
231	*
232	* @return string[]
233	*/
234	public function getUsers(string $name, string ...$domains): array
235	{
236	$domain = $this->getDomain(...$domains);	12✔
237	$rm = &$this->getRoleManager($domain, false);	12✔
238	return $rm->getUsers($name, ...$domains);	12✔
239	}
240
241
242	/**
243	* Converts the roles to a string array.
244	*
245	* @return string[]
246	*/
247	public function toString(): array
248	{
249	$roles = [];	6✔
250
251	foreach ($this->rmMap as $domain => &$rm) {	6✔
252	$domainRoles = $rm->toString();	6✔
253	$roles[] = sprintf('%s: %s', $domain, implode(', ', $domainRoles));	6✔
254	}
255
256	return $roles;	6✔
257	}
258
259	/**
260	* Prints all the roles to log.
261	*/
262	public function printRoles(): void
263	{
264	if (!$this->logger->isEnabled()) {	6✔
NEW 265	return;	×
266	}
267
268	$roles = $this->toString();	6✔
269	$this->logger->logRole($roles);	6✔
270	}
271
272	/**
273	* Gets the domains that a subject inherits.
274	*
275	* @param string $name
276	*
277	* @return string[]
278	*/
279	public function getDomains(string $name): array
280	{
281	$domains = [];	6✔
282	foreach ($this->rmMap as $domain => &$rm) {	6✔
283	$roleGet = $rm->getRole($name);	6✔
284	$role = $roleGet[0];	6✔
285	$roleCreated = $roleGet[1];	6✔
286
287	if (count($role->getUsers()) > 0 \|\| count($role->getRoles()) > 0) {	6✔
288	$domains[] = $domain;	6✔
289	}
290
291	if ($roleCreated) {	6✔
292	$this->removeRole($role->name);	6✔
293	}
294	}
295	return $domains;	6✔
296	}
297
298	/**
299	* Gets all the domains.
300	*
301	* @return string[]
302	*/
303	public function getAllDomains(): array
304	{
305	$domains = [];	6✔
306	foreach ($this->rmMap as $domain => $_) {	6✔
307	$domains[] = $domain;	6✔
308	}
309	return $domains;	6✔
310	}
311	}

php-casbin / php-casbin / 11444189732

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous