3 namespace CoreFramework\Loader;
5 // Import framework stuff
6 use CoreFramework\Configuration\FrameworkConfiguration;
7 use CoreFramework\Object\BaseFrameworkSystem;
10 use \InvalidArgumentException;
11 use \RecursiveDirectoryIterator;
12 use \RecursiveIteratorIterator;
15 * This class loads class include files with a specific prefix and suffix
17 * @author Roland Haeder <webmaster@shipsimu.org>
19 * @copyright Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Core Developer Team
20 * @license GNU GPL 3.0 or any newer version
21 * @link http://www.shipsimu.org
23 * This program is free software: you can redistribute it and/or modify
24 * it under the terms of the GNU General Public License as published by
25 * the Free Software Foundation, either version 3 of the License, or
26 * (at your option) any later version.
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU General Public License for more details.
33 * You should have received a copy of the GNU General Public License
34 * along with this program. If not, see <http://www.gnu.org/licenses/>.
36 * ----------------------------------
38 * - Namespace scheme Project\Package[\SubPackage...] is fully supported and
39 * throws an InvalidArgumentException if not present. The last part will be
40 * always the class' name.
42 * - Some comments improved, other minor improvements
44 * - Constructor is now empty and factory method 'createClassLoader' is created
45 * - renamed loadClasses to scanClassPath
46 * - Added initLoader()
48 * - ClassLoader rewritten to PHP SPL's own RecursiveIteratorIterator class
50 * - loadClasses rewritten to fix some notices
53 * ----------------------------------
57 * Instance of this class
59 private static $selfInstance = NULL;
62 * Array with all found classes
64 private $foundClasses = array();
67 * List of loaded classes
69 private $loadedClasses = array();
72 * Suffix with extension for all class files
74 private $prefix = 'class_';
77 * Suffix with extension for all class files
79 private $suffix = '.php';
82 * A list for directory names (no leading/trailing slashes!) which not be scanned by the path scanner
85 private $ignoreList = array();
88 * Debug this class loader? (TRUE = yes, FALSE = no)
90 private $debug = FALSE;
93 * Whether the file list is cached
95 private $listCached = FALSE;
98 * Wethe class content has been cached
100 private $classesCached = FALSE;
103 * Filename for the list cache
105 private $listCacheFQFN = '';
108 * Cache for class content
110 private $classCacheFQFN = '';
113 * Counter for loaded include files
118 * Framework/application paths for classes, etc.
120 private static $frameworkPaths = array(
121 'exceptions', // Exceptions
122 'interfaces', // Interfaces
123 'classes', // Classes
124 'middleware' // The middleware
129 * The protected constructor. Please use the factory method below, or use
130 * getSelfInstance() for singleton
134 protected function __construct () {
135 // Is currently empty
139 * The destructor makes it sure all caches got flushed
143 public function __destruct () {
144 // Skip here if dev-mode
145 if (defined('DEVELOPER')) {
149 // Skip here if already cached
150 if ($this->listCached === FALSE) {
151 // Writes the cache file of our list away
152 $cacheContent = json_encode($this->foundClasses);
153 file_put_contents($this->listCacheFQFN, $cacheContent);
156 // Skip here if already cached
157 if ($this->classesCached === FALSE) {
158 // Generate a full-cache of all classes
160 foreach (array_keys($this->loadedClasses) as $fqfn) {
162 $cacheContent .= file_get_contents($fqfn);
166 file_put_contents($this->classCacheFQFN, $cacheContent);
171 * Creates an instance of this class loader for given configuration instance
173 * @param $configInstance Configuration class instance
176 public static final function createClassLoader (FrameworkConfiguration $configInstance) {
177 // Get a new instance
178 $loaderInstance = new ClassLoader();
181 $loaderInstance->initLoader($configInstance);
183 // Return the prepared instance
184 return $loaderInstance;
188 * Scans for all framework classes, exceptions and interfaces.
192 public static function scanFrameworkClasses () {
194 //* NOISY-DEBUG: */ printf('[%s:%d]: CALLED!' . PHP_EOL, __METHOD__, __LINE__);
196 // Cache loader instance
197 $loaderInstance = self::getSelfInstance();
200 foreach (self::$frameworkPaths as $pathName) {
202 //* NOISY-DEBUG: */ printf('[%s:%d]: pathName=%s' . PHP_EOL, __METHOD__, __LINE__, $pathName);
204 // Try to load the framework classes
205 $loaderInstance->scanClassPath('inc/main/' . $pathName . '/');
210 * Scans for application's classes, etc.
214 public static function scanApplicationClasses () {
216 //* NOISY-DEBUG: */ printf('[%s:%d]: CALLED!' . PHP_EOL, __METHOD__, __LINE__);
218 // Get config instance
219 $cfg = FrameworkConfiguration::getSelfInstance();
221 // Load all classes for the application
222 foreach (self::$frameworkPaths as $class) {
224 $pathName = sprintf('%s/%s/%s', $cfg->getConfigEntry('application_path'), $cfg->getConfigEntry('app_name'), $class);
227 //* NOISY-DEBUG: */ printf('[%s:%d]: pathName=%s' . PHP_EOL, __METHOD__, __LINE__, $pathName);
229 // Is the path readable?
230 if (is_dir($pathName)) {
231 // Try to load the application classes
232 ClassLoader::getSelfInstance()->scanClassPath($pathName);
238 * Initializes our loader class
240 * @param $configInstance Configuration class instance
243 protected function initLoader (FrameworkConfiguration $configInstance) {
244 // Set configuration instance
245 $this->configInstance = $configInstance;
247 // Construct the FQFN for the cache
248 if (!defined('DEVELOPER')) {
249 $this->listCacheFQFN = $this->configInstance->getConfigEntry('local_db_path') . 'list-' . $this->configInstance->getConfigEntry('app_name') . '.cache';
250 $this->classCacheFQFN = $this->configInstance->getConfigEntry('local_db_path') . 'class-' . $this->configInstance->getConfigEntry('app_name') . '.cache';
253 // Set suffix and prefix from configuration
254 $this->suffix = $configInstance->getConfigEntry('class_suffix');
255 $this->prefix = $configInstance->getConfigEntry('class_prefix');
258 self::$selfInstance = $this;
260 // Skip here if no dev-mode
261 if (defined('DEVELOPER')) {
265 // IS the cache there?
266 if (BaseFrameworkSystem::isReadableFile($this->listCacheFQFN)) {
268 $cacheContent = file_get_contents($this->listCacheFQFN);
271 $this->foundClasses = json_decode($cacheContent);
273 // List has been restored from cache!
274 $this->listCached = TRUE;
277 // Does the class cache exist?
278 if (BaseFrameworkSystem::isReadableFile($this->listCacheFQFN)) {
280 require($this->classCacheFQFN);
282 // Mark the class cache as loaded
283 $this->classesCached = TRUE;
290 * @param $className Name of the class to load
293 public static function autoLoad ($className) {
294 // Try to include this class
295 self::getSelfInstance()->loadClassFile($className);
299 * Singleton getter for an instance of this class
301 * @return $selfInstance A singleton instance of this class
303 public static final function getSelfInstance () {
304 // Is the instance there?
305 if (is_null(self::$selfInstance)) {
307 self::$selfInstance = ClassLoader::createClassLoader(FrameworkConfiguration::getSelfInstance());
310 // Return the instance
311 return self::$selfInstance;
315 * Scans recursively a local path for class files which must have a prefix and a suffix as given by $this->suffix and $this->prefix
317 * @param $basePath The relative base path to 'base_path' constant for all classes
318 * @param $ignoreList An optional list (array forced) of directory and file names which shall be ignored
321 public function scanClassPath ($basePath, array $ignoreList = array() ) {
322 // Is a list has been restored from cache, don't read it again
323 if ($this->listCached === TRUE) {
328 // Keep it in class for later usage
329 $this->ignoreList = $ignoreList;
332 * Ignore .htaccess by default as it is for protection of directories
335 array_push($ignoreList, '.htaccess');
338 * Set base directory which holds all our classes, an absolute path
339 * should be used here so is_dir(), is_file() and so on will always
340 * find the correct files and dirs.
342 $basePath2 = realpath($basePath);
344 // If the basePath is FALSE it is invalid
345 if ($basePath2 === FALSE) {
346 /* @TODO: Do not exit here. */
347 exit(__METHOD__ . ': Cannot read ' . $basePath . ' !' . PHP_EOL);
350 $basePath = $basePath2;
353 // Get a new iterator
354 //* NOISY-DEBUG: */ printf('[%s:%d] basePath=%s' . PHP_EOL, __METHOD__, __LINE__, $basePath);
355 $iteratorInstance = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($basePath), RecursiveIteratorIterator::CHILD_FIRST);
358 while ($iteratorInstance->valid()) {
360 $currentEntry = $iteratorInstance->current();
362 // Get filename from iterator
363 $fileName = $currentEntry->getFileName();
365 // Get the "FQFN" (path and file name)
366 $fqfn = $currentEntry->getRealPath();
368 // Current entry must be a file, not smaller than 100 bytes and not on ignore list
369 if ((!$currentEntry->isFile()) || (in_array($fileName, $this->ignoreList)) || (filesize($fqfn) < 100)) {
370 // Advance to next entry
371 $iteratorInstance->next();
373 // Skip non-file entries
374 //* NOISY-DEBUG: */ printf('[%s:%d] SKIP: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
378 // Is this file wanted?
379 //* NOISY-DEBUG: */ printf('[%s:%d] FOUND: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
380 if ((substr($fileName, 0, strlen($this->prefix)) == $this->prefix) && (substr($fileName, -strlen($this->suffix), strlen($this->suffix)) == $this->suffix)) {
381 // Add it to the list
382 //* NOISY-DEBUG: */ printf('[%s:%d] ADD: %s,fqfn=%s' . PHP_EOL, __METHOD__, __LINE__, $fileName, $fqfn);
383 $this->foundClasses[$fileName] = $fqfn;
386 //* NOISY-DEBUG: */ printf('[%s:%d] NOT ADDED: %s,fqfn=%s' . PHP_EOL, __METHOD__, __LINE__, $fileName, $fqfn);
389 // Advance to next entry
390 //* NOISY-DEBUG: */ printf('[%s:%d] NEXT: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
391 $iteratorInstance->next();
396 * Load extra config files
400 public function loadExtraConfigs () {
402 $oldPrefix = $this->prefix;
404 // Set new prefix (temporary!)
405 $this->prefix = 'config-';
407 // Set base directory
408 $basePath = $this->configInstance->getConfigEntry('base_path') . 'inc/config/';
410 // Load all classes from the config directory
411 $this->scanClassPath($basePath);
413 // Include these extra configs now
414 $this->includeExtraConfigs();
416 // Set back the old prefix
417 $this->prefix = $oldPrefix;
421 * Tries to find the given class in our list. This method ignores silently
422 * missing classes or interfaces. So if you use class_exists() this method
423 * does not interrupt your program.
425 * @param $className The class that shall be loaded
428 private function loadClassFile ($className) {
430 //* NOISY-DEBUG: */ printf('[%s:%d] className=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $className);
432 // The class name should contain at least 2 back-slashes, so split at them
433 $classNameParts = explode("\\", $className);
435 // At least 3 parts should be there
436 if (count($classNameParts) < 3) {
437 // Namespace scheme is: Project\Package[\SubPackage...]
438 throw new InvalidArgumentException(sprintf('Class name "%s" is not conform to naming-convention: Project\Package[\SubPackage...]\SomeFooBar', $className));
442 $shortClassName = array_pop($classNameParts);
444 // Create a name with prefix and suffix
445 $fileName = $this->prefix . $shortClassName . $this->suffix;
447 // Now look it up in our index
448 //* NOISY-DEBUG: */ printf('[%s:%d] ISSET: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
449 if ((isset($this->foundClasses[$fileName])) && (!isset($this->loadedClasses[$this->foundClasses[$fileName]]))) {
450 // File is found and not loaded so load it only once
451 //* NOISY-DEBUG: */ printf('[%s:%d] LOAD: %s - START' . PHP_EOL, __METHOD__, __LINE__, $fileName);
452 require($this->foundClasses[$fileName]);
453 //* NOISY-DEBUG: */ printf('[%s:%d] LOAD: %s - END' . PHP_EOL, __METHOD__, __LINE__, $fileName);
455 // Count this loaded class/interface/exception
458 // Mark this class as loaded for other purposes than loading it.
459 $this->loadedClasses[$this->foundClasses[$fileName]] = TRUE;
461 // Remove it from classes list so it won't be found twice.
462 //* NOISY-DEBUG: */ printf('[%s:%d] UNSET: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
463 unset($this->foundClasses[$fileName]);
465 // Developer mode excludes caching (better debugging)
466 if (!defined('DEVELOPER')) {
468 //* NOISY-DEBUG: */ printf('[%s:%d] classesCached=FALSE' . PHP_EOL, __METHOD__, __LINE__);
469 $this->classesCached = FALSE;
473 //* NOISY-DEBUG: */ printf('[%s:%d] 404: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
478 * Includes all extra config files
482 private function includeExtraConfigs () {
483 // Run through all class names (should not be much)
484 foreach ($this->foundClasses as $fileName => $fqfn) {
486 if (substr($fileName, 0, strlen($this->prefix)) == $this->prefix) {
488 //* NOISY-DEBUG: */ printf('[%s:%d] LOAD: %s - START' . PHP_EOL, __METHOD__, __LINE__, $fileName);
490 //* NOISY-DEBUG: */ printf('[%s:%d] LOAD: %s - END' . PHP_EOL, __METHOD__, __LINE__, $fileName);
492 // Remove it from the list
493 //* NOISY-DEBUG: */ printf('[%s:%d] UNSET: %s' . PHP_EOL, __METHOD__, __LINE__, $fileName);
494 unset($this->foundClasses[$fileName]);
500 * Getter for total include counter
502 * @return $total Total loaded include files
504 public final function getTotal () {
509 * Getter for a printable list of included main/interfaces/exceptions
511 * @param $includeList A printable include list
513 public function getPrintableIncludeList () {
516 foreach ($this->loadedClasses as $classFile) {
517 $includeList .= basename($classFile) . '<br />' . PHP_EOL;