4270677071

Build Type

push

github

Committed by Olivier Laviale

Commit Message

Tidy

Run Details

2 of 2 new or added lines in 2 files covered. (100.0%)

73 of 415 relevant lines covered (17.59%)

0.68 hits per line

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

38.71

/lib/Module/ModuleCollection.php

<?php

/*
 * This file is part of the ICanBoogie package.
 *
 * (c) Olivier Laviale <olivier.laviale@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ICanBoogie\Module;

use ArrayAccess;
use BadMethodCallException;
use ICanBoogie\Binding\Module\Config;
use ICanBoogie\Module;
use IteratorAggregate;
use Traversable;

use function substr;

/**
 * @implements ArrayAccess<string, Module>
 * @implements IteratorAggregate<string, (callable(): Module)>
 */
class ModuleCollection implements ArrayAccess, IteratorAggregate
{
    /**
     * @var array<string, Descriptor>
     *     Where _key_ is a module identifier.
     */
    public readonly array $descriptors;

    public function __construct(
        private readonly Config $config,
        private readonly ModuleProvider $provider
    ) {
        $this->descriptors = $this->config->descriptors;
    }

    public function offsetExists(mixed $offset): bool
    {
        return isset($this->descriptors[$offset]);
    }

    public function offsetGet(mixed $offset): mixed
    {
        return $this->provider->module_for_id($offset);
    }

    public function offsetSet(mixed $offset, mixed $value): void
    {
        throw new BadMethodCallException();
    }

    public function offsetUnset(mixed $offset): void
    {
        throw new BadMethodCallException();
    }

    public function getIterator(): Traversable
    {
        return $this->provider->getIterator();
    }

    /**
     * @param (callable(Descriptor): bool) $filter
     *
     * @return array<string, Descriptor>
     */
    public function filter_descriptors(callable $filter): array
    {
        return array_filter($this->descriptors, $filter);
    }

    /**
     * @return array<string, Descriptor>
     */
    public function filter_descriptors_by_users(string $module_id): array
    {
        $users = [];
        $descriptors = $this->descriptors;

        foreach ($descriptors as $user_id => $descriptor) {
            if ($descriptor->parent == $module_id || in_array($module_id, $descriptor->required)) {
                $users[$user_id] = $descriptor;
            }
        }

        return $users;
    }

    /**
     * Returns the usage of a module by other modules.
     */
    public function usage(string $module_id): int
    {
        return count($this->filter_descriptors_by_users($module_id));
    }

    /**
     * Checks if a module inherits from another.
     *
     * @param string $module_id Module identifier.
     * @param string $parent_id Identifier of the parent module.
     */
    public function is_inheriting(string $module_id, string $parent_id): bool
    {
        while ($module_id) {
            if ($module_id === $parent_id) {
                return true;
            }

            $descriptor = $this->descriptors[$module_id];
            $module_id = $descriptor->parent;
        }

        return false;
    }

    /**
     * Resolves a class name using module inheritance.
     *
     * To resolve a given class name, the method checks in each module namespace—starting from the
     * specified module—if the class exists. If it does, it returns its fully qualified name.
     *
     * @param string[] $tried
     */
    public function resolve_classname(
        string $unqualified_classname,
        string $module_id,
        array &$tried = []
    ): string|false {
        while ($module_id) {
            $descriptor = $this->descriptors[$module_id];
            $class = $descriptor->class;
            $pos = strrpos($class, '\\');
            assert($pos !== false);
            $namespace = substr($class, 0, $pos);

            $fully_qualified_classname = $namespace . '\\' . $unqualified_classname;
            $tried[] = $fully_qualified_classname;

            if (class_exists($fully_qualified_classname)) {
                return $fully_qualified_classname;
            }

            $module_id = $descriptor->parent;
        }

        return false;
    }
}

1	<?php
2
3	/*
4	* This file is part of the ICanBoogie package.
5	*
6	* (c) Olivier Laviale <olivier.laviale@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	namespace ICanBoogie\Module;
13
14	use ArrayAccess;
15	use BadMethodCallException;
16	use ICanBoogie\Binding\Module\Config;
17	use ICanBoogie\Module;
18	use IteratorAggregate;
19	use Traversable;
20
21	use function substr;
22
23	/**
24	* @implements ArrayAccess<string, Module>
25	* @implements IteratorAggregate<string, (callable(): Module)>
26	*/
27	class ModuleCollection implements ArrayAccess, IteratorAggregate
28	{
29	/**
30	* @var array<string, Descriptor>
31	* Where _key_ is a module identifier.
32	*/
33	public readonly array $descriptors;
34
35	public function __construct(
36	private readonly Config $config,
37	private readonly ModuleProvider $provider
38	) {
39	$this->descriptors = $this->config->descriptors;	1✔
40	}
41
42	public function offsetExists(mixed $offset): bool
43	{
44	return isset($this->descriptors[$offset]);	×
45	}
46
47	public function offsetGet(mixed $offset): mixed
48	{
49	return $this->provider->module_for_id($offset);	×
50	}
51
52	public function offsetSet(mixed $offset, mixed $value): void
53	{
54	throw new BadMethodCallException();	×
55	}
56
57	public function offsetUnset(mixed $offset): void
58	{
59	throw new BadMethodCallException();	×
60	}
61
62	public function getIterator(): Traversable
63	{
64	return $this->provider->getIterator();	×
65	}
66
67	/**
68	* @param (callable(Descriptor): bool) $filter
69	*
70	* @return array<string, Descriptor>
71	*/
72	public function filter_descriptors(callable $filter): array
73	{
74	return array_filter($this->descriptors, $filter);	×
75	}
76
77	/**
78	* @return array<string, Descriptor>
79	*/
80	public function filter_descriptors_by_users(string $module_id): array
81	{
82	$users = [];	×
83	$descriptors = $this->descriptors;	×
84
85	foreach ($descriptors as $user_id => $descriptor) {	×
86	if ($descriptor->parent == $module_id \|\| in_array($module_id, $descriptor->required)) {	×
87	$users[$user_id] = $descriptor;	×
88	}
89	}
90
91	return $users;	×
92	}
93
94	/**
95	* Returns the usage of a module by other modules.
96	*/
97	public function usage(string $module_id): int
98	{
99	return count($this->filter_descriptors_by_users($module_id));	×
100	}
101
102	/**
103	* Checks if a module inherits from another.
104	*
105	* @param string $module_id Module identifier.
106	* @param string $parent_id Identifier of the parent module.
107	*/
108	public function is_inheriting(string $module_id, string $parent_id): bool
109	{
110	while ($module_id) {	×
111	if ($module_id === $parent_id) {	×
112	return true;	×
113	}
114
115	$descriptor = $this->descriptors[$module_id];	×
116	$module_id = $descriptor->parent;	×
117	}
118
119	return false;	×
120	}
121
122	/**
123	* Resolves a class name using module inheritance.
124	*
125	* To resolve a given class name, the method checks in each module namespace—starting from the
126	* specified module—if the class exists. If it does, it returns its fully qualified name.
127	*
128	* @param string[] $tried
129	*/
130	public function resolve_classname(
131	string $unqualified_classname,
132	string $module_id,
133	array &$tried = []
134	): string\|false {
135	while ($module_id) {	18✔
136	$descriptor = $this->descriptors[$module_id];	18✔
137	$class = $descriptor->class;	18✔
138	$pos = strrpos($class, '\\');	18✔
139	assert($pos !== false);
140	$namespace = substr($class, 0, $pos);	18✔
141
142	$fully_qualified_classname = $namespace . '\\' . $unqualified_classname;	18✔
143	$tried[] = $fully_qualified_classname;	18✔
144
145	if (class_exists($fully_qualified_classname)) {	18✔
146	return $fully_qualified_classname;	12✔
147	}
148
149	$module_id = $descriptor->parent;	10✔
150	}
151
152	return false;	6✔
153	}
154	}

ICanBoogie / Module / 4270677071

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