Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
96.08% covered (success)
96.08%
49 / 51
81.82% covered (warning)
81.82%
9 / 11
 CRAP
0.00% covered (danger)
0.00%
0 / 1
DiscoveredSymbols
96.08% covered (success)
96.08%
49 / 51
81.82% covered (warning)
81.82%
9 / 11
 19
0.00% covered (danger)
0.00%
0 / 1
 __construct
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
 1
 add
90.91% covered (success)
90.91%
10 / 11
0.00% covered (danger)
0.00%
0 / 1
 6.03
 getSymbols
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
 1
 getConstants
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
 getNamespaces
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
 getNamespace
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
 getClasses
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
 getDiscoveredNamespaces
85.71% covered (warning)
85.71%
6 / 7
0.00% covered (danger)
0.00%
0 / 1
 2.01
 getDiscoveredClasses
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
 2
 getDiscoveredConstants
100.00% covered (success)
100.00%
8 / 8
100.00% covered (success)
100.00%
1 / 1
 2
 getDiscoveredFunctions
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
1<?php
2/**
3 * @see \BrianHenryIE\Strauss\Pipeline\FileSymbolScanner
4 */
5
6namespace BrianHenryIE\Strauss\Types;
7
8class DiscoveredSymbols
9{
10    /**
11     * All discovered symbols, grouped by type, indexed by original name.
12     *
13     * @var array{T_NAME_QUALIFIED:array<string,NamespaceSymbol>, T_CONST:array<string,ConstantSymbol>, T_CLASS:array<string,ClassSymbol>}
14     */
15    protected array $types = [];
16
17    public function __construct()
18    {
19        $this->types = [
20            T_CLASS => [],
21            T_CONST => [],
22            T_NAMESPACE => [],
23            T_FUNCTION => [],
24        ];
25    }
26
27    /**
28     * @param DiscoveredSymbol $symbol
29     */
30    public function add(DiscoveredSymbol $symbol): void
31    {
32        switch (get_class($symbol)) {
33            case NamespaceSymbol::class:
34                $type = T_NAMESPACE;
35                break;
36            case ConstantSymbol::class:
37                $type = T_CONST;
38                break;
39            case ClassSymbol::class:
40                $type = T_CLASS;
41                break;
42            case FunctionSymbol::class:
43                $type = T_FUNCTION;
44                break;
45            default:
46                throw new \InvalidArgumentException('Unknown symbol type: ' . get_class($symbol));
47        }
48        $this->types[$type][$symbol->getOriginalSymbol()] = $symbol;
49    }
50
51    /**
52     * @return DiscoveredSymbol[]
53     */
54    public function getSymbols(): array
55    {
56        return array_merge(
57            array_values($this->getNamespaces()),
58            array_values($this->getClasses()),
59            array_values($this->getConstants()),
60            array_values($this->getDiscoveredFunctions()),
61        );
62    }
63
64    /**
65     * @return array<string, ConstantSymbol>
66     */
67    public function getConstants()
68    {
69        return $this->types[T_CONST];
70    }
71
72    /**
73     * @return array<string, NamespaceSymbol>
74     */
75    public function getNamespaces(): array
76    {
77        return $this->types[T_NAMESPACE];
78    }
79
80    public function getNamespace(string $namespace): ?NamespaceSymbol
81    {
82        return $this->types[T_NAMESPACE][$namespace] ?? null;
83    }
84
85    /**
86     * @return array<string, ClassSymbol>
87     */
88    public function getClasses(): array
89    {
90        return $this->types[T_CLASS];
91    }
92
93    /**
94     * TODO: Order by longest string first. (or instead, record classnames with their namespaces)
95     *
96     * @return array<string, NamespaceSymbol>
97     */
98    public function getDiscoveredNamespaces(?string $namespacePrefix = ''): array
99    {
100        $discoveredNamespaceReplacements = [];
101
102        // When running subsequent times, try to discover the original namespaces.
103        // This is naive: it will not work where namespace replacement patterns have been used.
104        foreach ($this->getNamespaces() as $key => $value) {
105            $discoveredNamespaceReplacements[ $value->getOriginalSymbol() ] = $value;
106        }
107
108        uksort($discoveredNamespaceReplacements, function ($a, $b) {
109            return strlen($a) <=> strlen($b);
110        });
111
112        return $discoveredNamespaceReplacements;
113    }
114
115    /**
116     * TODO: should be called getGlobalClasses?
117     *
118     * @return string[]
119     */
120    public function getDiscoveredClasses(?string $classmapPrefix = ''): array
121    {
122        $discoveredClasses = $this->getClasses();
123
124        $discoveredClasses = array_filter(
125            array_keys($discoveredClasses),
126            function (string $replacement) use ($classmapPrefix) {
127                return empty($classmapPrefix) || ! str_starts_with($replacement, $classmapPrefix);
128            }
129        );
130
131        return $discoveredClasses;
132    }
133
134    /**
135     * @return string[]
136     */
137    public function getDiscoveredConstants(?string $constantsPrefix = ''): array
138    {
139        $discoveredConstants = $this->getConstants();
140        $discoveredConstants = array_filter(
141            array_keys($discoveredConstants),
142            function (string $replacement) use ($constantsPrefix) {
143                return empty($constantsPrefix) || ! str_starts_with($replacement, $constantsPrefix);
144            }
145        );
146
147        return $discoveredConstants;
148    }
149
150    public function getDiscoveredFunctions()
151    {
152        return $this->types[T_FUNCTION];
153    }
154}