appserver-io / doppelgaenger

src/AutoLoader.php

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 35 and the first side effect is on line 24.

/**
 * \AppserverIo\Doppelgaenger\AutoLoader
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Bernhard Wick <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */

namespace AppserverIo\Doppelgaenger;

// Load the placeholder constants if not already done
require_once __DIR__ . DIRECTORY_SEPARATOR . 'Dictionaries' . DIRECTORY_SEPARATOR . 'Placeholders.php';

/**
 * Will provide autoloader functionality as an entry point for parsing and code generation
 *
 * @author    Bernhard Wick <bw@appserver.io>
 * @copyright 2015 TechDivision GmbH - <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */
class AutoLoader
{
    /**
     * The register for any known aspects
     *
     * @var \AppserverIo\Doppelgaenger\AspectRegister $aspectRegister
     */
    protected $aspectRegister;

    /**
     * @var \AppserverIo\Doppelgaenger\Config $config The configuration we base our actions on
     */
    protected $config;

    /**
     * @var \AppserverIo\Doppelgaenger\CacheMap $cache Cache map to keep track of already processed files
     */
    protected $cache;

    /**
     * @var \AppserverIo\Doppelgaenger\Generator $generator Generator instance if we need to create a new definition
     */
    protected $generator;

    /**
     * In some cases the autoloader instance is not thrown away, saving the structure map might be a benefit here
     *
     * @var \AppserverIo\Doppelgaenger\StructureMap $structureMap
     */
    protected $structureMap;

    /**
     * @const string OUR_LOADER Name of our class loading method as we will register it
     */
    const OUR_LOADER = 'loadClass';

    /**
     * Default constructor
     *
     * @param \AppserverIo\Doppelgaenger\Config|null $config An already existing config instance
     */
    public function __construct(Config $config = null)
    {
        // If we got a config we can use it, if not we will get a context less config instance
        if (is_null($config)) {
            $this->config = new Config();

Blank line found at end of control structure

        } else {
            $this->config = $config;
        }

        // Now that we got the config we can create a structure map to load from
        $this->structureMap = new StructureMap(
            $this->config->getValue('autoloader/dirs'),
            $this->config->getValue('enforcement/dirs'),
            $this->config
        );

        $this->cache = null;
        $this->aspectRegister = new AspectRegister();
    }

    /**
     * Getter for the $aspectRegister property
     *
     * @return \AppserverIo\Doppelgaenger\AspectRegister
     */
    public function getAspectRegister()
    {
        return $this->aspectRegister;
    }

    /**
     * Getter for the config member
     *
     * @return \AppserverIo\Doppelgaenger\Config
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * Getter for the structureMap member
     *
     * @return \AppserverIo\Doppelgaenger\StructureMap
     */
    public function getStructureMap()
    {
        return $this->structureMap;
    }

    /**
     * Will inject an AspectRegister instance into the generator
     *
     * @param \AppserverIo\Doppelgaenger\AspectRegister $aspectRegister The AspectRegister instance to inject
     *
     * @return null
     */
    public function injectAspectRegister(AspectRegister $aspectRegister)
    {
        $this->aspectRegister = $aspectRegister;
    }

    /**
     * Will load any given structure based on it's availability in our structure map which depends on the configured
     * project directories.
     * If the structure cannot be found we will redirect to the composer autoloader which we registered as a fallback
     *
     * @param string $className The name of the structure we will try to load
     *
     * @return boolean
     */
    public function loadClass($className)
    {

        // Might the class be a omitted one? If so we can require the original.
        if ($this->config->hasValue('autoloader/omit')) {
            $omittedNamespaces = $this->config->getValue('autoloader/omit');

            foreach ($omittedNamespaces as $omitted) {
                // If our class name begins with the omitted part e.g. it's namespace
                if (strpos($className, str_replace('\\\\', '\\', $omitted)) === 0) {
                    return false;
                }
            }
        }

        // Do we have the file in our cache dir? If we are in development mode we have to ignore this.
        if ($this->config->getValue('environment') !== 'development') {
            $cachePath = $this->config->getValue('cache/dir') . DIRECTORY_SEPARATOR . str_replace('\\', '_', $className) . '.php';

            if (is_readable($cachePath)) {
                $res = fopen($cachePath, 'r');
                $str = fread($res, 384);

                $success = preg_match(
                    '/' . Dictionaries\Placeholders::ORIGINAL_PATH_HINT . '(.+)' .
                    Dictionaries\Placeholders::ORIGINAL_PATH_HINT . '/',
                    $str,
                    $tmp
                );

                if ($success > 0) {
                    $tmp = explode('#', $tmp[1]);

                    $path = $tmp[0];
                    $mTime = $tmp[1];

                    if (filemtime($path) == $mTime) {
                        // the cached file is recent, load it
                        require $cachePath;
                        return true;
                    }
                }
            }
        }

        // If we are loading something that the autoloader needs to function, then we have to skip to composer
        if ((strpos($className, 'AppserverIo\Doppelgaenger') === 0 && strpos($className, 'AppserverIo\Doppelgaenger\Tests') === false) ||
            strpos($className, 'PHP') === 0 || strpos($className, 'AppserverIo\Psr\MetaobjectProtocol') === 0 ||
            strpos($className, 'AppserverIo\Lang\\') === 0
        ) {
            return false;
        }

        // If the structure map did not get filled by now we will do so here
        if ($this->structureMap->isEmpty()) {
            $this->structureMap->fill();
        }

        // Get the file from the map
        $file = $this->structureMap->getEntry($className);

        // Did we get something? If not return false.
        if ($file === false) {
            return false;
        }

        // We are still here, so we know the class and it is not omitted. Does it contain annotations then?
        if (!$file->hasAnnotations() || !$file->isEnforced()) {
            // on un-enforced classes we will require the original
            require $file->getPath();

            return true;
        }

        // So we have to create a new class definition for this original class.
        // Get a current cache instance if we do not have one already.
        if ($this->cache === null) {
            // We also require the classes of our maps as we do not have proper autoloading in place
            $this->cache = new CacheMap($this->getConfig()->getValue('cache/dir'), array(), $this->config);
        }
        $this->generator = new Generator($this->structureMap, $this->cache, $this->config, $this->aspectRegister);

        // Create the new class definition
        if ($this->generator->create($file, $this->config->getValue('enforcement/contract-inheritance')) === true) {
            // Require the new class, it should have been created now
            $file = $this->generator->getFileName($className);

            if ($file !== false && is_readable($file) === true) {
                require $file;

                return true;
            }

Blank line found at end of control structure

        } else {
            return false;
        }

        // Still here? That sounds like bad news!
        return false;
    }

    /**
     * Will register our autoloading method at the beginning of the spl autoloader stack
     *
     * @param boolean $throw   Should we throw an exception on error?
     * @param boolean $prepend If you want to NOT prepend you might, but you should not
     *
     * @return null
     */
    public function register($throw = true, $prepend = true)
    {
        // Now we have a config no matter what, we can store any instance we might need
        $this->config->storeInstances();

        // We want to let our autoloader be the first in line so we can react on loads
        // and create/return our contracted definitions.
        // So lets use the prepend parameter here.
        spl_autoload_register(array($this, self::OUR_LOADER), $throw, $prepend);
    }

    /**
     * Uninstalls this class loader from the SPL autoloader stack.
     *
     * @return void
     */
    public function unregister()
    {
        spl_autoload_unregister(array($this, self::OUR_LOADER));
    }
}