AutoloadManager.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Traits\Cacheable;

class AutoloadManager {

    use Cacheable;

    const FILENAME = 'autoload_data.php';
    const KEY_CLASSES = 'classes';
    const KEY_SCANNED_DIRS = 'scannedDirs';

    protected $loader;

    protected $scannedDirs = [];

    protected $altered = false;

    public function __construct(\Elgg\ClassLoader $loader, \Elgg\Config $config, \Elgg\Cache\BaseCache $cache) {
        $this->loader = $loader;
        
        if (!$config->AutoloaderManager_skip_storage) {
            $this->setCache($cache);
            $this->loadCache();
        }
    }

    public function addClasses($dir) {
        if (!in_array($dir, $this->scannedDirs)) {
            $map = $this->loader->getClassMap();
            $map->mergeMap($this->scanClassesDir($dir));
            $this->scannedDirs[] = $dir;
            $this->altered = true;
        }
        
        $this->loader->addFallback($dir);
        return $this;
    }

    protected function scanClassesDir($dir) {
        if (!is_dir($dir)) {
            return [];
        }
        
        $dir = new \DirectoryIterator($dir);
        $map = [];

        foreach ($dir as $file) {
            /* @var \SplFileInfo $file */
            if (!$file->isFile() || !$file->isReadable()) {
                continue;
            }

            $path = $file->getRealPath();

            if (pathinfo($path, PATHINFO_EXTENSION) !== 'php') {
                continue;
            }

            $class = $file->getBasename('.php');
            $map[$class] = $path;
        }
        
        return $map;
    }

    public function saveCache() {
        if (!$this->cache) {
            return $this;
        }
        
        $map = $this->loader->getClassMap();
        
        if ($this->altered || $map->getAltered()) {
            $classes = $map->getMap();
            $scanned_dirs = $this->scannedDirs;
            
            if (empty($classes) && empty($scanned_dirs)) {
                // if there is nothing to cache do not save it
                return $this;
            }
            
            $this->cache->save(self::FILENAME, [
                self::KEY_CLASSES => $classes,
                self::KEY_SCANNED_DIRS => $scanned_dirs,
            ]);
        }
        
        return $this;
    }

    public function loadCache() {
        $cache = $this->getCacheFileContents();
        if ($cache) {
            // the cached class map will have the full scanned core classes, so
            // don't consider the earlier mappings as "altering" the map
            $this->loader->getClassMap()
                ->setMap($cache[self::KEY_CLASSES])
                ->setAltered(false);
            $this->scannedDirs = $cache[self::KEY_SCANNED_DIRS];
            return true;
        }
        
        $this->altered = true;
        return false;
    }

    protected function getCacheFileContents() {
        if (!$this->cache) {
            return false;
        }
        
        $spec = $this->cache->load(self::FILENAME);
        if (isset($spec[self::KEY_CLASSES])) {
            return $spec;
        }
        
        return false;
    }

    public function deleteCache() {
        $this->cache?->delete(self::FILENAME);
        $this->loader->getClassMap()->setMap([])->setAltered(true);
        $this->scannedDirs = [];
        $this->altered = true;

        return $this;
    }

    public function getLoader() {
        return $this->loader;
    }
}