ClassLoader::lookInAliases() - Code Metrics - imagecms/ImageCMS - Measure and Improve Code Quality continuously with Scrutinizer

ClassLoader::lookInAliases() A
last analyzed 2019-09-03 12:36 UTC

↳ Parent: ClassLoader

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
nc	3
nop	1
dl	0
loc	18
rs	9.6666
c	0
b	0
f	0

<?php

/**
 * require_once APPPATH . 'libraries' . DIRECTORY_SEPARATOR . 'ClassLoader.php';
 * ClassLoader::getInstance()
 *     ->registerNamespacedPath(APPPATH)
 *     ->registerNamespacedPath(APPPATH . 'modules');
 *
 * @author ailok <[email protected]>
 *
 */
class ClassLoader

{

    const EXT = '.php';
    const DS = DIRECTORY_SEPARATOR;

    private static $instance;

    private $namespacedPaths = [];

    private $aliases = [];

    private $classesPaths = [];

    private function __construct() {
        spl_autoload_register([$this, 'autoload'], false);
    }

    private function __clone() {

    }

    /**
     *
     * @return ClassLoader
     */
    public static function getInstance() {
        if (self::$instance == null) {
            self::$instance = new self;
        }
        return self::$instance;
    }

    /**
     *
     * @param array $array
     * @param string $path
     * @param string (optional) $key
     * @param string $key
     * @throws \Exception
     */
    private function addPath(array &$array, $path, $key = null) {
        if (!is_dir($path)) {
            throw new \Exception('Error registering [' . $path . '] - folder do not exist');
        }
        if (in_array($path, $array)) {
            return;
        }

        if ($key == null) {
            $array[] = $path;
        } else {
            $array[$key] = $path;
        }
    }

    /**
     *
     * @param string $path
     * @return \ClassLoader
     */
    public function registerNamespacedPath($path) {
        $this->addPath($this->namespacedPaths, $path);
        return $this;
    }

    /**
     *
     * @param string $path
     * @return \ClassLoader
     */
    public function registerClassesPath($path) {
        $this->addPath($this->classesPaths, $path);
        return $this;
    }

    /**
     *
     * @param string $path
     * @param string $name
     * @return \ClassLoader
     */
    public function registerAlias($path, $name) {
        $this->addPath($this->aliases, $path, $name);
        return $this;
    }

    /**
     * Function for registering in spl_autoload_register()
     * @param string $className
     */
    public function autoload($className) {
        $className = ltrim($className, '\\');
        if (strpos($className, '\\') > 0) {
            $this->loadNamespacedClass($className);
        } else {
            $this->loadClass($className);
        }
    }

    /**
     * @param string $className
     */
    private function lookInAliases($className) {
        // getting first element of namespace path and search it in namespaces
        list($namespace, $fileName) = $this->splitClassName($className);
        if (array_key_exists($namespace, $this->aliases) && strpos($namespace, '\\') > 0) {
            $classPath = $this->aliases[$namespace] . '/' . $fileName . self::EXT;
            $this->includeClass($classPath);
            return true;
        }

        $parts = explode('\\', $className);
        $alias = array_shift($parts);
        if (!array_key_exists($alias, $this->aliases)) {
            return false;
        }
        $pathToNamepace = rtrim($this->aliases[$alias], self::DS) . self::DS;
        $classPath = $pathToNamepace . implode(self::DS, $parts) . self::EXT;
        return $this->includeClass($classPath);
    }

    /**
     *
     * @param string $className
     * @return array [namespace, fileName]
     */
    private function splitClassName($className) {
        $parts = explode('\\', $className);
        $fileName = array_pop($parts);
        return [implode('\\', $parts), $fileName];
    }

    /**
     * @param string $className
     */
    private function loadNamespacedClass($className) {
        if (true == $this->lookInAliases($className)) {
            return;
        }
        $namespacedClassPath = str_replace('\\', self::DS, $className);
        $namespacedPathsCount = count($this->namespacedPaths);
        for ($i = 0; $i < $namespacedPathsCount; $i++) {
            $classPath = rtrim($this->namespacedPaths[$i], self::DS) . self::DS . $namespacedClassPath . self::EXT;
            if (true == $this->includeClass($classPath)) {
                return;
            }
        }
    }

    /**
     * @param string $className
     */
    private function loadClass($className) {
        $classesPathsCount = count($this->classesPaths);

        for ($i = 0; $i < $classesPathsCount; $i++) {
            $classPath = rtrim($this->classesPaths[$i], self::DS) . self::DS . $className . self::EXT;
            if (true == $this->includeClass($classPath)) {
                return;
            }
        }
    }

    /**
     * @param string $classPath
     */
    private function includeClass($classPath) {
        if (file_exists($classPath)) {
            include_once $classPath;
            return true;
        }
        return false;
    }

}

1		<?php
2
3		/**
4		* require_once APPPATH . 'libraries' . DIRECTORY_SEPARATOR . 'ClassLoader.php';
5		* ClassLoader::getInstance()
6		* ->registerNamespacedPath(APPPATH)
7		* ->registerNamespacedPath(APPPATH . 'modules');
8		*
9		* @author ailok <[email protected]>
10		*
11		*/
12		class ClassLoader
		0 ignored issues – show Coding Style introduced 2015-11-28 17:39 UTC by Report Bug Copy Issue Report Since you have declared the constructor as private, maybe you should also declare the class as final. Loading history...
13		{
14
15		const EXT = '.php';
16		const DS = DIRECTORY_SEPARATOR;
17
18		private static $instance;
19
20		private $namespacedPaths = [];
21
22		private $aliases = [];
23
24		private $classesPaths = [];
25
26		private function __construct() {
27		spl_autoload_register([$this, 'autoload'], false);
28		}
29
30		private function __clone() {
31
32		}
33
34		/**
35		*
36		* @return ClassLoader
37		*/
38		public static function getInstance() {
39		if (self::$instance == null) {
40		self::$instance = new self;
41		}
42		return self::$instance;
43		}
44
45		/**
46		*
47		* @param array $array
48		* @param string $path
49		* @param string (optional) $key
50		* @param string $key
51		* @throws \Exception
52		*/
53		private function addPath(array &$array, $path, $key = null) {
54		if (!is_dir($path)) {
55		throw new \Exception('Error registering [' . $path . '] - folder do not exist');
56		}
57		if (in_array($path, $array)) {
58		return;
59		}
60
61		if ($key == null) {
62		$array[] = $path;
63		} else {
64		$array[$key] = $path;
65		}
66		}
67
68		/**
69		*
70		* @param string $path
71		* @return \ClassLoader
72		*/
73		public function registerNamespacedPath($path) {
74		$this->addPath($this->namespacedPaths, $path);
75		return $this;
76		}
77
78		/**
79		*
80		* @param string $path
81		* @return \ClassLoader
82		*/
83		public function registerClassesPath($path) {
84		$this->addPath($this->classesPaths, $path);
85		return $this;
86		}
87
88		/**
89		*
90		* @param string $path
91		* @param string $name
92		* @return \ClassLoader
93		*/
94		public function registerAlias($path, $name) {
95		$this->addPath($this->aliases, $path, $name);
96		return $this;
97		}
98
99		/**
100		* Function for registering in spl_autoload_register()
101		* @param string $className
102		*/
103		public function autoload($className) {
104		$className = ltrim($className, '\\');
105		if (strpos($className, '\\') > 0) {
106		$this->loadNamespacedClass($className);
107		} else {
108		$this->loadClass($className);
109		}
110		}
111
112		/**
113		* @param string $className
114		*/
115		private function lookInAliases($className) {
116		// getting first element of namespace path and search it in namespaces
117		list($namespace, $fileName) = $this->splitClassName($className);
118		if (array_key_exists($namespace, $this->aliases) && strpos($namespace, '\\') > 0) {
119		$classPath = $this->aliases[$namespace] . '/' . $fileName . self::EXT;
120		$this->includeClass($classPath);
121		return true;
122		}
123
124		$parts = explode('\\', $className);
125		$alias = array_shift($parts);
126		if (!array_key_exists($alias, $this->aliases)) {
127		return false;
128		}
129		$pathToNamepace = rtrim($this->aliases[$alias], self::DS) . self::DS;
130		$classPath = $pathToNamepace . implode(self::DS, $parts) . self::EXT;
131		return $this->includeClass($classPath);
132		}
133
134		/**
135		*
136		* @param string $className
137		* @return array [namespace, fileName]
138		*/
139		private function splitClassName($className) {
140		$parts = explode('\\', $className);
141		$fileName = array_pop($parts);
142		return [implode('\\', $parts), $fileName];
143		}
144
145		/**
146		* @param string $className
147		*/
148		private function loadNamespacedClass($className) {
149		if (true == $this->lookInAliases($className)) {
150		return;
151		}
152		$namespacedClassPath = str_replace('\\', self::DS, $className);
153		$namespacedPathsCount = count($this->namespacedPaths);
154	View Code Duplication	for ($i = 0; $i < $namespacedPathsCount; $i++) {
155		$classPath = rtrim($this->namespacedPaths[$i], self::DS) . self::DS . $namespacedClassPath . self::EXT;
156		if (true == $this->includeClass($classPath)) {
157		return;
158		}
159		}
160		}
161
162		/**
163		* @param string $className
164		*/
165		private function loadClass($className) {
166		$classesPathsCount = count($this->classesPaths);
167
168	View Code Duplication	for ($i = 0; $i < $classesPathsCount; $i++) {
169		$classPath = rtrim($this->classesPaths[$i], self::DS) . self::DS . $className . self::EXT;
170		if (true == $this->includeClass($classPath)) {
171		return;
172		}
173		}
174		}
175
176		/**
177		* @param string $classPath
178		*/
179		private function includeClass($classPath) {
180		if (file_exists($classPath)) {
181		include_once $classPath;
182		return true;
183		}
184		return false;
185		}
186
187		}

imagecms / ImageCMS

ClassLoader::lookInAliases() A last analyzed 2019-09-03 12:36 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ClassLoader::lookInAliases() A
last analyzed 2019-09-03 12:36 UTC