BuildR\ClassLoader\Modules\PSR0\PSR0ClassLoaderModule

Complexity

Total Complexity

17

Size/Duplication

Total Lines	121
Duplicated Lines	13.22 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	2	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getPriority()	0	3	1
A	onRegistered()	0	1	1
A	getName()	0	3	1
B	load()	0	36	6
A	registerNamespace()	0	10	2
A	unRegisterNamespace()	7	7	3
A	namespaceIsRegistered()	9	9	3

<?php namespace BuildR\ClassLoader\Modules\PSR0;

use BuildR\ClassLoader\Modules\AbstractClassLoaderModule;
use BuildR\ClassLoader\Modules\PSR0\PSR0ModuleException;

/**
 * PSR-0 compatible class loader module
 *
 * BuildR PHP Framework
 *
 * @author Zoltán Borsos <zolli07@gmail.com>
 * @package ClassLoader
 * @subpackage Modules\PSR0
 *
 * @copyright    Copyright 2015, Zoltán Borsos.
 * @license      https://github.com/Zolli/BuildR/blob/master/LICENSE.md
 * @link         https://github.com/Zolli/BuildR
 */
class PSR0ClassLoaderModule extends AbstractClassLoaderModule {

    /**
     * @type int
     */
    protected $priority = 40;

    /**
     * @type array
     */
    protected $registeredNamespaces = [];

    /**
     * @inheritDoc
     * @codeCoverageIgnore
     */
    public function getPriority() {
        return $this->priority;
    }

    /**
     * @inheritDoc
     * @codeCoverageIgnore
     */
    public function onRegistered() {}

    /**
     * @inheritDoc
     * @codeCoverageIgnore
     */
    public static function getName() {
        return 'PSR0ClassLoaderModule';
    }

    /**
     * @inheritDoc
     */
    public function load($className) {
        if(count($this->registeredNamespaces) < 1) {
            return FALSE;
        }

        //Detect namespace and class name from the FQCN
        $pos = strrpos($className, '\\');
        $namespace = substr($className, 0, $pos);
        $className = substr($className, $pos + 1);

        //Create the normalized class name
        $normalizedClass = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
        $normalizedClass .= str_replace('_', DIRECTORY_SEPARATOR, $className);

        //Loop through registered namespaces
        foreach($this->registeredNamespaces as $singleNamespace) {
            $prefix = str_replace('\\', DIRECTORY_SEPARATOR, $singleNamespace[0]);
            $basePath = $singleNamespace[1];

            $pos = stripos($normalizedClass, $prefix);
            if($pos === FALSE || $pos > 1) {
                continue;
            }

            // build the full path
            $file = rtrim($basePath, '/') . DIRECTORY_SEPARATOR . ltrim($normalizedClass, '/') . '.php';

            if(file_exists($file)) {
                include_once $file;

                return TRUE;
            }
        }

        return FALSE;
    }

    /**
     * @inheritDoc
     *
     * @throws \BuildR\ClassLoader\Modules\PSR0\PSR0ModuleException
     */
    public function registerNamespace($namespace, $basePath) {
        if($this->namespaceIsRegistered($namespace)) {
            throw PSR0ModuleException::namespaceOccupied($namespace);
        }

        $this->registeredNamespaces[] = [
            $namespace,
            realpath($basePath)
        ];
    }

    /**
     * Remove a registered namespace from the module
     *
     * @param string $namespace The namespace name
     */
    public function unRegisterNamespace($namespace) {

This method seems to be duplicated in your project.

        foreach($this->registeredNamespaces as $key => $registeredNamespace) {
            if($registeredNamespace[0] == $namespace) {
                unset($this->registeredNamespaces[$key]);
            }
        }
    }

    /**
     * Determines that the given namespace nem is registered in this module
     *
     * @param string $namespace The namespace name
     *
     * @return bool
     */
    public function namespaceIsRegistered($namespace) {

This method seems to be duplicated in your project.

        foreach($this->registeredNamespaces as $key => $registeredNamespace) {
            if($registeredNamespace[0] == $namespace) {
                return TRUE;
            }
        }

        return FALSE;
    }

}