Subreality\Dilmun\Nabu\Autoloader

Complexity

Total Complexity

19

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	4	1
A	registerPackages()	0	18	2
A	getRegisteredPackages()	0	4	1
A	includeClass()	0	21	3
A	loadPackageStack()	0	21	3
A	loadPackage()	0	17	2
A	packageRegistered()	0	12	2
A	registrationExists()	0	18	3
A	requireFile()	0	17	2

<?php
namespace Subreality\Dilmun\Nabu;

use Subreality\Dilmun\LoggedClassTrait;

/**
 * PSR-4 compliant autoloading class
 *
 * @author derek
 */
class Autoloader
{
    use LoggedClassTrait;

    protected $packages = array();

    /**
     * Registers the includeClass function as an autoloader.
     *
     * @see Autoloader::includeClass
     *
     * @return void
     */
    public function register()
    {
        spl_autoload_register(array($this,"includeClass"));
    }

    /**
     * Registers a given package with an associated path.
     *
     * Duplicate package/path combinations will not be re-registered.
     *
     * @param string $package   The name of the package to be registered
     * @param string $path      The path to be associated with the registered package
     *
     * @return void
     */
    public function registerPackages($package, $path)
    {
        $this->updateLog("info", "Preparing package {$package} for registration with path {$path}.");

        $package = trim($package, "\\");
        $package = $package . "\\";

        $path = rtrim($path, DIRECTORY_SEPARATOR);
        $path = $path . "/";

        $path_registered = $this->registrationExists($package, $path);

        if (!$path_registered) {
            $this->packages[$package][] = $path;

            $this->updateLog("info", "Registered index {$package} as {$path}");
        }
    }

    /**
     * Returns an array of registered packages.
     *
     * @return array
     */
    public function getRegisteredPackages()
    {
        return $this->packages;
    }

    /**
     * Includes the file corresponding with the class name to be autoloaded
     *
     * @param string $class Class name as defined by PHP autoloading
     *
     * @return void
     */
    protected function includeClass($class)
    {
        $this->updateLog("info", "Setting up {$class} class for inclusion.");

        $class_bits = explode("\\", $class);

        $package       = "";
        $package_stack = array();

        foreach ($class_bits as $bit) {
            $package = $package . $bit . "\\";

            $package_registered = $this->packageRegistered($package);

            if ($package_registered) {
                $package_stack[] = $package;
            }
        }

        $this->loadPackageStack($class, $package_stack);
    }

    /**
     * Attempts to load a class from a stack of packages
     *
     * @param string $class         The fully-qualified class name
     * @param array $package_stack  A stack of packages for loading
     *
     * @return bool                 Returns true if the class was successfully loaded from the package stack
     *                              Returns false if the class could not be loaded from the package stack
     */
    protected function loadPackageStack($class, array $package_stack)
    {
        foreach ($package_stack as $package) {
            $package_length = strlen($package);

            $class_path = substr($class, $package_length);

            $this->updateLog("debug", "Found class path {$class_path} in {$class} given {$package}");

            $package_loaded = $this->loadPackage($package, $class_path);

            if ($package_loaded) {
                $this->updateLog("info", "Loaded {$class_path} using package {$package}");
                return true;
            }
        }

        $this->updateLog("alert", "No files found for {$class} in registered packages!");

        return false;
    }

    /**
     * Loads a package based on registered paths associated with the package.
     *
     * @param string $package_name  The name of the package in Vendor\Package format
     * @param string $class_name    The full, relative name of the class with the vendor and package names stripped
     *
     * @return bool                 The path to the class on success; otherwise false
     */
    protected function loadPackage($package_name, $class_name)
    {
        $this->updateLog("info", "Working on loading {$class_name} from {$package_name}");

        $file_required = false;

        foreach ($this->packages[$package_name] as $path) {
            $converted_class = str_replace('\\', DIRECTORY_SEPARATOR, $class_name);
            $class_path      = $path . $converted_class . ".php";

            $this->updateLog("debug", "Class file path is {$class_path}");

            $file_required = $this->requireFile($class_path);
        }

        return $file_required;
    }

    /**
     * Determines whether a given package is registered with the Autoloader
     *
     * @param string $package   The package to check
     *
     * @return bool             Returns true if the given package is registered
     *                          Returns false if the given package is not registered
     */
    private function packageRegistered($package)
    {
        $package_registered = array_key_exists($package, $this->packages);

        if ($package_registered) {
            $this->updateLog("info", "Package {$package} is registered");
        } else {
            $this->updateLog("info", "Package {$package} is not registered");
        }

        return $package_registered;
    }

    /**
     * Determines whether a given package/path combination has already been registered with the Autoloader
     *
     * @param string $package   The package to check
     * @param string $path      The path to check
     *
     * @return bool             Returns true if the given path has been registered with the given package
     *                          Returns false if the given path has not been registered with the given package
     */
    private function registrationExists($package, $path)
    {
        $package_registered = $this->packageRegistered($package);

        if ($package_registered) {
            $path_registered = array_search($path, $this->packages[$package]);

            if ($path_registered !== false) {
                $path_registered = true;

                $this->updateLog("info", "Path {$path} already registered for package {$package}");
            }
        } else {
            $path_registered = false;
        }

        return $path_registered;
    }

    /**
     * Requires a file only if it existss
     *
     * @param string $path  The path to the file for requiring
     *
     * @return bool         Returns true if the file at the given path exists
     *                      Returns false if the file at the given path does not exist
     */
    private function requireFile($path)
    {
        if (file_exists($path)) {
            $this->updateLog("debug", "File {$path} exists; requiring file");

            /** @noinspection PhpIncludeInspection */
            require $path;

            $this->updateLog("info", "Completed loading {$path}");

            return true;
        } else {
            $this->updateLog("debug", "File {$path} does not exist");

            return false;
        }
    }
}