AutoloadManager.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Cache\AutoloadCache;
 
class AutoloadManager {
 
    const FILENAME = 'autoload_data.php';
    const KEY_CLASSES = 'classes';
    const KEY_SCANNED_DIRS = 'scannedDirs';
 
    protected array $scannedDirs = [];
 
    protected bool $altered = false;
 
    public function __construct(protected ClassLoader $loader, protected AutoloadCache $cache) {
        $this->loadCache();
    }
 
    public function addClasses(string $dir): static {
        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(string $dir): array {
        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(): static {
        $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(): bool {
        $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(): ?array {
        $spec = $this->cache->load(self::FILENAME);
        
        return isset($spec[self::KEY_CLASSES]) ? $spec : null;
    }
 
    public function deleteCache(): static {
        $this->cache->delete(self::FILENAME);
        $this->loader->getClassMap()->setMap([])->setAltered(true);
        $this->scannedDirs = [];
        $this->altered = true;
 
        return $this;
    }
}