CallableRegistry::parseNamespaces() - Code Metrics - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

CallableRegistry::parseNamespaces() B
last analyzed 2025-01-08 16:45 UTC

↳ Parent: CallableRegistry

Complexity

Conditions	7
Paths	6

Size

Total Lines	40
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
eloc	20
dl	0
loc	40
rs	8.6666
c	3
b	0
f	0
cc	7
nc	6
nop	0

<?php

/**
 * CallableRegistry.php - Jaxon callable class registry
 *
 * This class is the entry point for class, directory and namespace registration.
 *
 * @package jaxon-core
 * @author Thierry Feuzeu <[email protected]>
 * @copyright 2019 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

namespace Jaxon\Plugin\Request\CallableClass;

use Composer\Autoload\ClassLoader;
use Jaxon\App\AbstractCallable;
use Jaxon\App\Component;
use Jaxon\Di\ClassContainer;
use Jaxon\Utils\Config\Config;
use ReflectionClass;
use ReflectionMethod;

use function array_merge;
use function file_exists;
use function in_array;
use function is_string;
use function is_subclass_of;
use function str_replace;
use function strlen;
use function strncmp;
use function substr;
use function trim;

class CallableRegistry
{
    /**
     * The namespace options
     *
     * These are the options of the registered namespaces.
     *
     * @var array
     */
    protected $aNamespaceOptions = [];

    /**
     * The directory options
     *
     * These are the options of the registered directories.
     *
     * @var array
     */
    protected $aDirectoryOptions = [];

    /**
     * The namespaces
     *
     * These are all the namespaces found in registered directories.
     *
     * @var array
     */
    protected $aNamespaces = [];

    /**
     * The package providing the class or directory being registered.
     *
     * @var Config|null
     */
    protected $xCurrentConfig = null;

    /**
     * The string that will be used to compute the js file hash
     *
     * @var string
     */
    protected $sHash = '';

    /**
     * @var array
     */
    private $aDefaultClassOptions = [
        'separator' => '.',
        'protected' => [],
        'functions' => [],
        'timestamp' => 0,
    ];

    /**
     * The methods that must not be exported to js
     *
     * @var array
     */
    private $aProtectedMethods = [];

    /**
     * @var bool
     */
    protected $bDirectoriesParsed = false;

    /**
     * @var bool
     */
    protected $bNamespacesParsed = false;

    /**
     * The Composer autoloader
     *
     * @var ClassLoader
     */
    private $xAutoloader = null;

    /**
     * The class constructor
     *
     * @param ClassContainer $cls
     */
    public function __construct(protected ClassContainer $cls)
    {
        // Set the composer autoloader
        if(file_exists(($sAutoloadFile = __DIR__ . '/../../../../../../autoload.php')) ||
            file_exists(($sAutoloadFile = __DIR__ . '/../../../../../vendor/autoload.php')) ||
            file_exists(($sAutoloadFile = __DIR__ . '/../../../../vendor/autoload.php')))
        {
            $this->xAutoloader = require($sAutoloadFile);
        }

        // The methods of the AbstractCallable class must not be exported
        $xAbstractCallable = new ReflectionClass(AbstractCallable::class);
        foreach($xAbstractCallable->getMethods(ReflectionMethod::IS_PUBLIC) as $xMethod)
        {
            $this->aProtectedMethods[] = $xMethod->getName();
        }
    }

    /**
     * @param Config|null $xConfig
     *
     * @return void
     */
    public function setCurrentConfig(Config $xConfig = null)
    {
        $this->xCurrentConfig = $xConfig;
    }

    /**
     * Get all registered namespaces
     *
     * @return array
     */
    public function getNamespaces(): array
    {
        return $this->aNamespaces;
    }

    /**
     * Get the hash
     *
     * @return string
     */
    public function getHash(): string
    {
        return $this->sHash;
    }

    /**
     * Get a given class options from specified directory options
     *
     * @param string $sClassName    The class name
     * @param array $aClassOptions    The default class options
     * @param array $aDirectoryOptions    The directory options
     *
     * @return array
     */
    private function makeClassOptions(string $sClassName, array $aClassOptions, array $aDirectoryOptions): array
    {
        foreach($this->aDefaultClassOptions as $sOption => $xValue)
        {
            if(!isset($aClassOptions[$sOption]))
            {
                $aClassOptions[$sOption] = $xValue;
            }
        }
        $aClassOptions['excluded'] = (bool)($aClassOptions['excluded'] ?? false); // Convert to bool.
        if(is_string($aClassOptions['protected']))
        {
            $aClassOptions['protected'] = [$aClassOptions['protected']]; // Convert to array.
        }

        $aDirectoryOptions['functions'] = []; // The 'functions' section is not allowed here.
        $aOptionGroups = [
            $aDirectoryOptions, // Options at directory level
            $aDirectoryOptions['classes']['*'] ?? [], // Options for all classes
            $aDirectoryOptions['classes'][$sClassName] ?? [], // Options for this specific class
        ];
        foreach($aOptionGroups as $aOptionGroup)
        {
            if(isset($aOptionGroup['separator']))
            {
                $aClassOptions['separator'] = (string)$aOptionGroup['separator'];
            }
            if(isset($aOptionGroup['excluded']))
            {
                $aClassOptions['excluded'] = (bool)$aOptionGroup['excluded'];
            }
            if(isset($aOptionGroup['protected']))
            {
                if(is_string($aOptionGroup['protected']))
                {
                    $aOptionGroup['protected'] = [$aOptionGroup['protected']]; // Convert to array.
                }
                $aClassOptions['protected'] = array_merge($aClassOptions['protected'], $aOptionGroup['protected']);
            }
            if(isset($aOptionGroup['functions']))
            {
                $aClassOptions['functions'] = array_merge($aClassOptions['functions'], $aOptionGroup['functions']);
            }
        }
        if(isset($aDirectoryOptions['config']) && !isset($aClassOptions['config']))
        {
            $aClassOptions['config'] = $aDirectoryOptions['config'];
        }

        return $aClassOptions;
    }

    /**
     *
     * @param string $sClassName        The class name
     * @param array $aClassOptions      The default class options
     * @param array $aDirectoryOptions  The directory options
     * @param bool $bAddToHash          Add the class name to the hash value
     *
     * @return void
     */
    private function _registerClass(string $sClassName, array $aClassOptions,
        array $aDirectoryOptions = [], bool $bAddToHash = true)
    {
        $aOptions = $this->makeClassOptions($sClassName, $aClassOptions, $aDirectoryOptions);
        $this->cls->registerClass($sClassName, $aOptions);
        if($bAddToHash)
        {
            $this->sHash .= $sClassName . $aOptions['timestamp'];
        }
    }

    /**
     *
     * @param string $sClassName    The class name
     * @param array $aClassOptions    The default class options
     *
     * @return void
     */
    public function registerClass(string $sClassName, array $aClassOptions)
    {
        if($this->xCurrentConfig !== null)
        {
            $aClassOptions['config'] = $this->xCurrentConfig;
        }
        $this->_registerClass($sClassName, $aClassOptions);
    }

    /**
     * Find options for a class which is registered with namespace
     *
     * @param string $sClassName    The class name
     *
     * @return void
     */
    public function registerClassFromNamespace(string $sClassName)
    {
        // Find the corresponding namespace
        foreach($this->aNamespaceOptions as $sNamespace => $aDirectoryOptions)
        {
            // Check if the namespace matches the class.
            if(strncmp($sClassName, $sNamespace . '\\', strlen($sNamespace) + 1) === 0)
            {
                // Save the class options
                $aClassOptions = ['namespace' => $sNamespace];
                $this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions, false);
                return;
            }
        }
    }

    /**
     * Find the options associated with a registered class name
     *
     * @param string $sClassName The class name
     *
     * @return array
     */
    public function getProtectedMethods(string $sClassName): array
    {
        // Don't export the item() and html() public methods for Component objects.
        return is_subclass_of($sClassName, Component::class) ?
            [...$this->aProtectedMethods, 'item', 'html'] :
            (is_subclass_of($sClassName, AbstractCallable::class) ?
                $this->aProtectedMethods : []);
    }

    /**
     *
     * @param string $sDirectory    The directory being registered
     * @param array $aOptions    The associated options
     *
     * @return void
     */
    public function registerDirectory(string $sDirectory, array $aOptions)
    {
        // Set the autoload option default value
        if(!isset($aOptions['autoload']))
        {
            $aOptions['autoload'] = true;
        }
        if($this->xCurrentConfig !== null)
        {
            $aOptions['config'] = $this->xCurrentConfig;
        }
        $this->aDirectoryOptions[$sDirectory] = $aOptions;
    }

    /**
     *
     * @param string $sNamespace    The namespace
     * @param array $aOptions    The associated options
     *
     * @return void
     */
    private function addNamespace(string $sNamespace, array $aOptions)
    {
        $this->aNamespaces[] = $sNamespace;
        $this->sHash .= $sNamespace . $aOptions['separator'];
    }

    /**
     *
     * @param string $sNamespace    The namespace of the directory being registered
     * @param array $aOptions    The associated options
     *
     * @return void
     */
    public function registerNamespace(string $sNamespace, array $aOptions)
    {
        // Separator default value
        if(!isset($aOptions['separator']))
        {
            $aOptions['separator'] = '.';
        }
        $aOptions['separator'] = trim($aOptions['separator']);
        if(!in_array($aOptions['separator'], ['.', '_']))
        {
            $aOptions['separator'] = '.';
        }
        if($aOptions['separator'] === '_')
        {
            $this->cls->useUnderscore();
        }
        // Set the autoload option default value
        if(!isset($aOptions['autoload']))
        {
            $aOptions['autoload'] = true;
        }
        if($this->xCurrentConfig !== null)
        {
            $aOptions['config'] = $this->xCurrentConfig;
        }
        // Register the dir with PSR4 autoloading
        if(($aOptions['autoload']) && $this->xAutoloader != null)
        {
            $this->xAutoloader->setPsr4($sNamespace . '\\', $aOptions['directory']);
        }

        $this->aNamespaceOptions[$sNamespace] = $aOptions;
    }

    /**
     * Read classes from directories registered without namespaces
     *
     * @return void
     */
    public function parseDirectories()
    {
        // This is to be done only once.
        if($this->bDirectoriesParsed)
        {
            return;
        }
        $this->bDirectoriesParsed = true;

        // Browse directories without namespaces and read all the files.
        $aClassMap = [];

        foreach($this->aDirectoryOptions as $sDirectory => $aDirectoryOptions)
        {
            $itFile = new SortedFileIterator($sDirectory);
            // Iterate on dir content
            foreach($itFile as $xFile)
            {
                // Skip everything except PHP files
                if(!$xFile->isFile() || $xFile->getExtension() !== 'php')
                {
                    continue;
                }

                $sClassName = $xFile->getBasename('.php');
                $aClassOptions = ['timestamp' => $xFile->getMTime()];
                if(($aDirectoryOptions['autoload']) && $this->xAutoloader !== null)
                {
                    // Set classmap autoloading. Must be done before registering the class.
                    $this->xAutoloader->addClassMap([$sClassName => $xFile->getPathname()]);
                }
                $this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions);
            }
        }
    }

    /**
     * Read classes from directories registered with namespaces
     *
     * @return void
     */
    public function parseNamespaces()
    {
        // This is to be done only once.
        if($this->bNamespacesParsed)
        {
            return;
        }
        $this->bNamespacesParsed = true;

        // Browse directories with namespaces and read all the files.
        $sDS = DIRECTORY_SEPARATOR;
        foreach($this->aNamespaceOptions as $sNamespace => $aDirectoryOptions)
        {
            $this->addNamespace($sNamespace, ['separator' => $aDirectoryOptions['separator']]);

            // Iterate on dir content
            $sDirectory = $aDirectoryOptions['directory'];
            $itFile = new SortedFileIterator($sDirectory);
            foreach($itFile as $xFile)
            {
                // skip everything except PHP files
                if(!$xFile->isFile() || $xFile->getExtension() !== 'php')
                {
                    continue;
                }

                // Find the class path (the same as the class namespace)
                $sClassPath = $sNamespace;
                $sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
                $sRelativePath = trim(str_replace($sDS, '\\', $sRelativePath), '\\');
                if($sRelativePath !== '')
                {
                    $sClassPath .= '\\' . $sRelativePath;
                }

                $this->addNamespace($sClassPath, ['separator' => $aDirectoryOptions['separator']]);

                $sClassName = $sClassPath . '\\' . $xFile->getBasename('.php');
                $aClassOptions = ['namespace' => $sNamespace, 'timestamp' => $xFile->getMTime()];
                $this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions);
            }
        }
    }

    /**
     * Register all the callable classes
     *
     * @return void
     */
    public function parseCallableClasses()
    {
        $this->parseDirectories();
        $this->parseNamespaces();
    }
}


1			<?php
2
3			/**
4			* CallableRegistry.php - Jaxon callable class registry
5			*
6			* This class is the entry point for class, directory and namespace registration.
7			*
8			* @package jaxon-core
9			* @author Thierry Feuzeu <[email protected]>
10			* @copyright 2019 Thierry Feuzeu <[email protected]>
11			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
12			* @link https://github.com/jaxon-php/jaxon-core
13			*/
14
15			namespace Jaxon\Plugin\Request\CallableClass;
16
17			use Composer\Autoload\ClassLoader;
18			use Jaxon\App\AbstractCallable;
19			use Jaxon\App\Component;
20			use Jaxon\Di\ClassContainer;
21			use Jaxon\Utils\Config\Config;
22			use ReflectionClass;
23			use ReflectionMethod;
24
25			use function array_merge;
26			use function file_exists;
27			use function in_array;
28			use function is_string;
29			use function is_subclass_of;
30			use function str_replace;
31			use function strlen;
32			use function strncmp;
33			use function substr;
34			use function trim;
35
36			class CallableRegistry
37			{
38			/**
39			* The namespace options
40			*
41			* These are the options of the registered namespaces.
42			*
43			* @var array
44			*/
45			protected $aNamespaceOptions = [];
46
47			/**
48			* The directory options
49			*
50			* These are the options of the registered directories.
51			*
52			* @var array
53			*/
54			protected $aDirectoryOptions = [];
55
56			/**
57			* The namespaces
58			*
59			* These are all the namespaces found in registered directories.
60			*
61			* @var array
62			*/
63			protected $aNamespaces = [];
64
65			/**
66			* The package providing the class or directory being registered.
67			*
68			* @var Config\|null
69			*/
70			protected $xCurrentConfig = null;
71
72			/**
73			* The string that will be used to compute the js file hash
74			*
75			* @var string
76			*/
77			protected $sHash = '';
78
79			/**
80			* @var array
81			*/
82			private $aDefaultClassOptions = [
83			'separator' => '.',
84			'protected' => [],
85			'functions' => [],
86			'timestamp' => 0,
87			];
88
89			/**
90			* The methods that must not be exported to js
91			*
92			* @var array
93			*/
94			private $aProtectedMethods = [];
95
96			/**
97			* @var bool
98			*/
99			protected $bDirectoriesParsed = false;
100
101			/**
102			* @var bool
103			*/
104			protected $bNamespacesParsed = false;
105
106			/**
107			* The Composer autoloader
108			*
109			* @var ClassLoader
110			*/
111			private $xAutoloader = null;
112
113			/**
114			* The class constructor
115			*
116			* @param ClassContainer $cls
117			*/
118			public function __construct(protected ClassContainer $cls)
119			{
120			// Set the composer autoloader
121			if(file_exists(($sAutoloadFile = __DIR__ . '/../../../../../../autoload.php')) \|\|
122			file_exists(($sAutoloadFile = __DIR__ . '/../../../../../vendor/autoload.php')) \|\|
123			file_exists(($sAutoloadFile = __DIR__ . '/../../../../vendor/autoload.php')))
124			{
125			$this->xAutoloader = require($sAutoloadFile);
126			}
127
128			// The methods of the AbstractCallable class must not be exported
129			$xAbstractCallable = new ReflectionClass(AbstractCallable::class);
130			foreach($xAbstractCallable->getMethods(ReflectionMethod::IS_PUBLIC) as $xMethod)
131			{
132			$this->aProtectedMethods[] = $xMethod->getName();
133			}
134			}
135
136			/**
137			* @param Config\|null $xConfig
138			*
139			* @return void
140			*/
141			public function setCurrentConfig(Config $xConfig = null)
142			{
143			$this->xCurrentConfig = $xConfig;
144			}
145
146			/**
147			* Get all registered namespaces
148			*
149			* @return array
150			*/
151			public function getNamespaces(): array
152			{
153			return $this->aNamespaces;
154			}
155
156			/**
157			* Get the hash
158			*
159			* @return string
160			*/
161			public function getHash(): string
162			{
163			return $this->sHash;
164			}
165
166			/**
167			* Get a given class options from specified directory options
168			*
169			* @param string $sClassName The class name
170			* @param array $aClassOptions The default class options
171			* @param array $aDirectoryOptions The directory options
172			*
173			* @return array
174			*/
175			private function makeClassOptions(string $sClassName, array $aClassOptions, array $aDirectoryOptions): array
176			{
177			foreach($this->aDefaultClassOptions as $sOption => $xValue)
178			{
179			if(!isset($aClassOptions[$sOption]))
180			{
181			$aClassOptions[$sOption] = $xValue;
182			}
183			}
184			$aClassOptions['excluded'] = (bool)($aClassOptions['excluded'] ?? false); // Convert to bool.
185			if(is_string($aClassOptions['protected']))
186			{
187			$aClassOptions['protected'] = [$aClassOptions['protected']]; // Convert to array.
188			}
189
190			$aDirectoryOptions['functions'] = []; // The 'functions' section is not allowed here.
191			$aOptionGroups = [
192			$aDirectoryOptions, // Options at directory level
193			$aDirectoryOptions['classes']['*'] ?? [], // Options for all classes
194			$aDirectoryOptions['classes'][$sClassName] ?? [], // Options for this specific class
195			];
196			foreach($aOptionGroups as $aOptionGroup)
197			{
198			if(isset($aOptionGroup['separator']))
199			{
200			$aClassOptions['separator'] = (string)$aOptionGroup['separator'];
201			}
202			if(isset($aOptionGroup['excluded']))
203			{
204			$aClassOptions['excluded'] = (bool)$aOptionGroup['excluded'];
205			}
206			if(isset($aOptionGroup['protected']))
207			{
208			if(is_string($aOptionGroup['protected']))
209			{
210			$aOptionGroup['protected'] = [$aOptionGroup['protected']]; // Convert to array.
211			}
212			$aClassOptions['protected'] = array_merge($aClassOptions['protected'], $aOptionGroup['protected']);
213			}
214			if(isset($aOptionGroup['functions']))
215			{
216			$aClassOptions['functions'] = array_merge($aClassOptions['functions'], $aOptionGroup['functions']);
217			}
218			}
219			if(isset($aDirectoryOptions['config']) && !isset($aClassOptions['config']))
220			{
221			$aClassOptions['config'] = $aDirectoryOptions['config'];
222			}
223
224			return $aClassOptions;
225			}
226
227			/**
228			*
229			* @param string $sClassName The class name
230			* @param array $aClassOptions The default class options
231			* @param array $aDirectoryOptions The directory options
232			* @param bool $bAddToHash Add the class name to the hash value
233			*
234			* @return void
235			*/
236			private function _registerClass(string $sClassName, array $aClassOptions,
237			array $aDirectoryOptions = [], bool $bAddToHash = true)
238			{
239			$aOptions = $this->makeClassOptions($sClassName, $aClassOptions, $aDirectoryOptions);
240			$this->cls->registerClass($sClassName, $aOptions);
241			if($bAddToHash)
242			{
243			$this->sHash .= $sClassName . $aOptions['timestamp'];
244			}
245			}
246
247			/**
248			*
249			* @param string $sClassName The class name
250			* @param array $aClassOptions The default class options
251			*
252			* @return void
253			*/
254			public function registerClass(string $sClassName, array $aClassOptions)
255			{
256			if($this->xCurrentConfig !== null)
257			{
258			$aClassOptions['config'] = $this->xCurrentConfig;
259			}
260			$this->_registerClass($sClassName, $aClassOptions);
261			}
262
263			/**
264			* Find options for a class which is registered with namespace
265			*
266			* @param string $sClassName The class name
267			*
268			* @return void
269			*/
270			public function registerClassFromNamespace(string $sClassName)
271			{
272			// Find the corresponding namespace
273			foreach($this->aNamespaceOptions as $sNamespace => $aDirectoryOptions)
274			{
275			// Check if the namespace matches the class.
276			if(strncmp($sClassName, $sNamespace . '\\', strlen($sNamespace) + 1) === 0)
277			{
278			// Save the class options
279			$aClassOptions = ['namespace' => $sNamespace];
280			$this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions, false);
281			return;
282			}
283			}
284			}
285
286			/**
287			* Find the options associated with a registered class name
288			*
289			* @param string $sClassName The class name
290			*
291			* @return array
292			*/
293			public function getProtectedMethods(string $sClassName): array
294			{
295			// Don't export the item() and html() public methods for Component objects.
296			return is_subclass_of($sClassName, Component::class) ?
297			[...$this->aProtectedMethods, 'item', 'html'] :
298			(is_subclass_of($sClassName, AbstractCallable::class) ?
299			$this->aProtectedMethods : []);
300			}
301
302			/**
303			*
304			* @param string $sDirectory The directory being registered
305			* @param array $aOptions The associated options
306			*
307			* @return void
308			*/
309			public function registerDirectory(string $sDirectory, array $aOptions)
310			{
311			// Set the autoload option default value
312			if(!isset($aOptions['autoload']))
313			{
314			$aOptions['autoload'] = true;
315			}
316			if($this->xCurrentConfig !== null)
317			{
318			$aOptions['config'] = $this->xCurrentConfig;
319			}
320			$this->aDirectoryOptions[$sDirectory] = $aOptions;
321			}
322
323			/**
324			*
325			* @param string $sNamespace The namespace
326			* @param array $aOptions The associated options
327			*
328			* @return void
329			*/
330			private function addNamespace(string $sNamespace, array $aOptions)
331			{
332			$this->aNamespaces[] = $sNamespace;
333			$this->sHash .= $sNamespace . $aOptions['separator'];
334			}
335
336			/**
337			*
338			* @param string $sNamespace The namespace of the directory being registered
339			* @param array $aOptions The associated options
340			*
341			* @return void
342			*/
343			public function registerNamespace(string $sNamespace, array $aOptions)
344			{
345			// Separator default value
346			if(!isset($aOptions['separator']))
347			{
348			$aOptions['separator'] = '.';
349			}
350			$aOptions['separator'] = trim($aOptions['separator']);
351			if(!in_array($aOptions['separator'], ['.', '_']))
352			{
353			$aOptions['separator'] = '.';
354			}
355			if($aOptions['separator'] === '_')
356			{
357			$this->cls->useUnderscore();
358			}
359			// Set the autoload option default value
360			if(!isset($aOptions['autoload']))
361			{
362			$aOptions['autoload'] = true;
363			}
364			if($this->xCurrentConfig !== null)
365			{
366			$aOptions['config'] = $this->xCurrentConfig;
367			}
368			// Register the dir with PSR4 autoloading
369			if(($aOptions['autoload']) && $this->xAutoloader != null)
370			{
371			$this->xAutoloader->setPsr4($sNamespace . '\\', $aOptions['directory']);
372			}
373
374			$this->aNamespaceOptions[$sNamespace] = $aOptions;
375			}
376
377			/**
378			* Read classes from directories registered without namespaces
379			*
380			* @return void
381			*/
382			public function parseDirectories()
383			{
384			// This is to be done only once.
385			if($this->bDirectoriesParsed)
386			{
387			return;
388			}
389			$this->bDirectoriesParsed = true;
390
391			// Browse directories without namespaces and read all the files.
392			$aClassMap = [];
			0 ignored issues – show Unused Code introduced 2025-01-08 16:22 UTC by Report Bug Copy Issue Report The assignment to `$aClassMap` is dead and can be removed. Loading history...
393			foreach($this->aDirectoryOptions as $sDirectory => $aDirectoryOptions)
394			{
395			$itFile = new SortedFileIterator($sDirectory);
396			// Iterate on dir content
397			foreach($itFile as $xFile)
398			{
399			// Skip everything except PHP files
400			if(!$xFile->isFile() \|\| $xFile->getExtension() !== 'php')
401			{
402			continue;
403			}
404
405			$sClassName = $xFile->getBasename('.php');
406			$aClassOptions = ['timestamp' => $xFile->getMTime()];
407			if(($aDirectoryOptions['autoload']) && $this->xAutoloader !== null)
408			{
409			// Set classmap autoloading. Must be done before registering the class.
410			$this->xAutoloader->addClassMap([$sClassName => $xFile->getPathname()]);
411			}
412			$this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions);
413			}
414			}
415			}
416
417			/**
418			* Read classes from directories registered with namespaces
419			*
420			* @return void
421			*/
422			public function parseNamespaces()
423			{
424			// This is to be done only once.
425			if($this->bNamespacesParsed)
426			{
427			return;
428			}
429			$this->bNamespacesParsed = true;
430
431			// Browse directories with namespaces and read all the files.
432			$sDS = DIRECTORY_SEPARATOR;
433			foreach($this->aNamespaceOptions as $sNamespace => $aDirectoryOptions)
434			{
435			$this->addNamespace($sNamespace, ['separator' => $aDirectoryOptions['separator']]);
436
437			// Iterate on dir content
438			$sDirectory = $aDirectoryOptions['directory'];
439			$itFile = new SortedFileIterator($sDirectory);
440			foreach($itFile as $xFile)
441			{
442			// skip everything except PHP files
443			if(!$xFile->isFile() \|\| $xFile->getExtension() !== 'php')
444			{
445			continue;
446			}
447
448			// Find the class path (the same as the class namespace)
449			$sClassPath = $sNamespace;
450			$sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
451			$sRelativePath = trim(str_replace($sDS, '\\', $sRelativePath), '\\');
452			if($sRelativePath !== '')
453			{
454			$sClassPath .= '\\' . $sRelativePath;
455			}
456
457			$this->addNamespace($sClassPath, ['separator' => $aDirectoryOptions['separator']]);
458
459			$sClassName = $sClassPath . '\\' . $xFile->getBasename('.php');
460			$aClassOptions = ['namespace' => $sNamespace, 'timestamp' => $xFile->getMTime()];
461			$this->_registerClass($sClassName, $aClassOptions, $aDirectoryOptions);
462			}
463			}
464			}
465
466			/**
467			* Register all the callable classes
468			*
469			* @return void
470			*/
471			public function parseCallableClasses()
472			{
473			$this->parseDirectories();
474			$this->parseNamespaces();
475			}
476			}
477

jaxon-php / jaxon-core

CallableRegistry::parseNamespaces() B last analyzed 2025-01-08 16:45 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CallableRegistry::parseNamespaces() B
last analyzed 2025-01-08 16:45 UTC