Jaxon\Request\Support\CallableRegistry

Complexity

Total Complexity

35

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	addDirectory()	0	10	2
B	addNamespace()	0	29	7
B	parseDirectories()	0	33	7
B	parseNamespaces()	0	43	7
A	getClassOptionsFromNamespaces()	0	22	4
A	getClassOptions()	0	15	2
A	getCallableObject()	0	26	4

<?php

/**
 * CallableRegistry.php - Jaxon callable object registrar
 *
 * This class is the entry point for class, directory and namespace registration.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright 2019 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Request\Support;

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

class CallableRegistry

Missing doc comment for class CallableRegistry

{
    /**
     * The callable repository
     *
     * @var CallableRepository
     */
    public $xRepository;

Expected 1 blank line(s) before first member var; 0 found

    /**
     * The registered directories
     *
     * These are directories registered without a namespace.
     *
     * @var array
     */
    protected $aDirectories = [];

    /**
     * Indicate if the registered directories are already parsed
     *
     * @var boolean
     */
    protected $bParsedDirectories = false;

    /**
     * The registered namespaces
     *
     * These are the namespaces specified when registering directories.
     *
     * @var array
     */
    protected $aNamespaces = [];

    /**
     * Indicate if the registered namespaces are already parsed
     *
     * @var boolean
     */
    protected $bParsedNamespaces = false;

    /**
     * If the underscore is used as separator in js class names.
     *
     * @var boolean
     */
    protected $bUsingUnderscore = false;

    /**
     * The Composer autoloader
     *
     * @var Autoloader
     */
    private $xAutoloader = null;

    /**
     * The class constructor
     *
     * @param CallableRepository        $xRepository

Missing parameter comment

Expected 1 spaces after parameter type; 8 found

     */
    public function __construct(CallableRepository $xRepository)
    {
        $this->xRepository = $xRepository;

        // Set the composer autoloader
        $sAutoloadFile = __DIR__ . '/../../../../../autoload.php';
        if(file_exists($sAutoloadFile))
        {
            $this->xAutoloader = require($sAutoloadFile);
        }
    }

    /**
     *
     * @param string        $sDirectory     The directory being registered

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 5 found

     * @param array         $aOptions       The associated options

Expected 2 spaces after parameter type; 9 found

Expected 3 spaces after parameter name; 7 found

     *
     * @return void
     */
    public function addDirectory($sDirectory, array $aOptions)
    {
        // Set the autoload option default value
        if(!key_exists('autoload', $aOptions))
        {
            $aOptions['autoload'] = true;
        }

        $this->aDirectories[$sDirectory] = $aOptions;
    }

    /**
     *
     * @param string        $sNamespace     The namespace of the directory being registered

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 5 found

     * @param array         $aOptions       The associated options

Expected 2 spaces after parameter type; 9 found

Expected 3 spaces after parameter name; 7 found

     *
     * @return void
     */
    public function addNamespace($sNamespace, array $aOptions)
    {
        // Separator default value
        if(!key_exists('separator', $aOptions))
        {
            $aOptions['separator'] = '.';
        }
        $aOptions['separator'] = trim($aOptions['separator']);
        if(!in_array($aOptions['separator'], ['.', '_']))
        {
            $aOptions['separator'] = '.';
        }
        if($aOptions['separator'] == '_')
        {
            $this->bUsingUnderscore = true;
        }
        // Set the autoload option default value
        if(!key_exists('autoload', $aOptions))
        {
            $aOptions['autoload'] = true;
        }
        // Register the dir with PSR4 autoloading
        if(($aOptions['autoload']) && $this->xAutoloader != null)
        {
            $this->xAutoloader->setPsr4($sNamespace . '\\', $aOptions['directory']);
        }

        $this->aNamespaces[$sNamespace] = $aOptions;
    }

    /**
     * Read classes from registered directories (without namespaces)
     *
     * @return void
     */
    public function parseDirectories()
    {
        // Browse directories without namespaces and read all the files.
        // This is to be done only once.
        if($this->bParsedDirectories)
        {
            return;
        }
        $this->bParsedDirectories = true;

        foreach($this->aDirectories as $sDirectory => $aOptions)
        {
            $itFile = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($sDirectory));
            // Iterate on dir content
            foreach($itFile as $xFile)
            {
                // skip everything except PHP files
                if(!$xFile->isFile() || $xFile->getExtension() != 'php')
                {
                    continue;
                }

                $sClassName = $xFile->getBasename('.php');

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

                $aClassOptions = [];
                // No more classmap autoloading. The file will be included when needed.
                if(($aOptions['autoload']))
                {
                    $aClassOptions['include'] = $xFile->getPathname();
                }
                $this->xRepository->addClass($sClassName, $aClassOptions, $aOptions);
            }
        }
    }

    /**
     * Read classes from registered directories (with namespaces)
     *
     * @return void
     */
    public function parseNamespaces()
    {
        // Browse directories with namespaces and read all the files.
        // This is to be done only once.
        if($this->bParsedNamespaces)
        {
            return;
        }
        $this->bParsedNamespaces = true;

        $sDS = DIRECTORY_SEPARATOR;
        foreach($this->aNamespaces as $sNamespace => $aOptions)
        {
            $this->xRepository->addNamespace($sNamespace, ['separator' => $aOptions['separator']]);

            // Iterate on dir content
            $sDirectory = $aOptions['directory'];
            $itFile = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($sDirectory));

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            foreach($itFile as $xFile)
            {
                // skip everything except PHP files
                if(!$xFile->isFile() || $xFile->getExtension() != 'php')
                {
                    continue;
                }

                // Find the class path (the same as the class namespace)
                $sClassPath = $sNamespace;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

                $sRelativePath = substr($xFile->getPath(), strlen($sDirectory));
                $sRelativePath = trim(str_replace($sDS, '\\', $sRelativePath), '\\');
                if($sRelativePath != '')
                {
                    $sClassPath .= '\\' . $sRelativePath;
                }

                $this->xRepository->addNamespace($sClassPath, ['separator' => $aOptions['separator']]);

                $sClassName = $sClassPath . '\\' . $xFile->getBasename('.php');

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

                $aClassOptions = ['namespace' => $sNamespace];
                $this->xRepository->addClass($sClassName, $aClassOptions, $aOptions);
            }
        }
    }

    /**
     * Find options for a class which is registered with namespace
     *
     * @param string        $sClassName            The class name

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return array|null
     */
    protected function getClassOptionsFromNamespaces($sClassName)
    {
        // Find the corresponding namespace
        $sNamespace = null;
        foreach(array_keys($this->aNamespaces) as $_sNamespace)
        {
            if(substr($sClassName, 0, strlen($_sNamespace) + 1) == $_sNamespace . '\\')
            {
                $sNamespace = $_sNamespace;
                break;
            }
        }
        if($sNamespace === null)
        {
            return null; // Class not registered
        }

        // Get the class options
        $aOptions = $this->aNamespaces[$sNamespace];

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        $aClassOptions = ['namespace' => $sNamespace];
        return $this->xRepository->makeClassOptions($sClassName, $aClassOptions, $aOptions);
    }

    /**
     * Find the options associated with a registered class name
     *
     * @param string        $sClassName            The class name

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return array|null
     */
    protected function getClassOptions($sClassName)
    {
        // Find options for a class registered with namespace.
        $aOptions = $this->getClassOptionsFromNamespaces($sClassName);
        if($aOptions !== null)
        {
            return $aOptions;
        }

        // Without a namespace, we need to parse all classes to be able to find one.
        $this->parseDirectories();

        // Find options for a class registered without namespace.
        return $this->xRepository->getClassOptions($sClassName);
    }

    /**
     * Find a callable object by class name
     *
     * @param string        $sClassName            The class name of the callable object

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return object
     */
    public function getCallableObject($sClassName)
    {
        // Replace all separators ('.' and '_') with antislashes, and remove the antislashes
        // at the beginning and the end of the class name.
        $sClassName = (string)$sClassName;

Consider using a different name than the parameter $sClassName. This often makes code more readable.

        $sClassName = trim(str_replace('.', '\\', $sClassName), '\\');

Consider using a different name than the parameter $sClassName. This often makes code more readable.

        if($this->bUsingUnderscore)
        {
            $sClassName = trim(str_replace('_', '\\', $sClassName), '\\');

Consider using a different name than the parameter $sClassName. This often makes code more readable.

        }

        // Check if the callable object was already created.
        $aCallableObjects = $this->xRepository->getCallableObjects();
        if(key_exists($sClassName, $aCallableObjects))
        {
            return $aCallableObjects[$sClassName];
        }

        $aOptions = $this->getClassOptions($sClassName);
        if($aOptions === null)
        {
            return null;
        }

        return $this->xRepository->createCallableObject($sClassName, $aOptions);
    }
}