Jaxon\Plugin\Request\CallableClass\CallableRegistry

Complexity

Total Complexity

33

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
B	addNamespace()	0	27	7
A	__construct()	0	11	3
B	parseNamespaces()	0	40	7
B	parseDirectories()	0	37	9
A	addDirectory()	0	8	2
A	parseCallableClasses()	0	4	1
A	checkCallableObject()	0	12	2
A	getCallableObject()	0	3	1
A	getJsCallFactory()	0	3	1

<?php

/**
 * CallableRegistry.php - Jaxon callable class registry
 *
 * 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\Plugin\Request\CallableClass;

use Jaxon\App\I18n\Translator;
use Jaxon\Di\Container;
use Jaxon\Exception\SetupException;
use Jaxon\Request\Factory\JsCallFactory;

use Composer\Autoload\ClassLoader;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

use function file_exists;
use function in_array;
use function str_replace;
use function strlen;
use function substr;
use function trim;

class CallableRegistry

Missing doc comment for class CallableRegistry

{
    /**
     * The DI container
     *
     * @var Container
     */
    protected $di;

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

    /**
     * The callable repository
     *
     * @var CallableRepository
     */
    protected $xRepository;

    /**
     * @var Translator
     */
    protected $xTranslator;

    /**
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    protected $bDirectoriesParsed = false;

    /**
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    protected $bNamespacesParsed = false;

    /**
     * If the underscore is used as separator in js class names.
     *
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    protected $bUsingUnderscore = false;

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

    /**
     * The class constructor
     *
     * @param Container $di

Missing parameter comment

Expected 10 spaces after parameter type; 1 found

     * @param CallableRepository $xRepository

Missing parameter comment

     * @param Translator $xTranslator

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     */
    public function __construct(Container $di, CallableRepository $xRepository, Translator $xTranslator)

Expected 2 blank lines before function; 1 found

    {
        $this->di = $di;

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

        $this->xTranslator = $xTranslator;
        $this->xRepository = $xRepository;

        // Set the composer autoloader
        if(file_exists(($sAutoloadFile = __DIR__ . '/../../../../../../autoload.php')) ||

Variable assignment found within a condition. Did you mean to do a comparison ?

            file_exists(($sAutoloadFile = __DIR__ . '/../../../../vendor/autoload.php')))

Variable assignment found within a condition. Did you mean to do a comparison ?

        {
            $this->xAutoloader = require($sAutoloadFile);
        }
    }

Expected 2 blank lines after function; 1 found

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

Expected 1 spaces after parameter name; 4 found

     * @param array $aOptions    The associated options

Expected 2 spaces after parameter type; 1 found

Expected 3 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function addDirectory(string $sDirectory, array $aOptions)
    {
        // Set the autoload option default value
        if(!isset($aOptions['autoload']))
        {
            $aOptions['autoload'] = true;
        }
        $this->xRepository->setDirectoryOptions($sDirectory, $aOptions);
    }

Expected 2 blank lines after function; 1 found

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

Expected 1 spaces after parameter name; 4 found

     * @param array $aOptions    The associated options

Expected 2 spaces after parameter type; 1 found

Expected 3 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function addNamespace(string $sNamespace, array $aOptions)
    {
        // Separator default value
        if(!isset($aOptions['separator']))
        {
            $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(!isset($aOptions['autoload']))
        {
            $aOptions['autoload'] = true;
        }
        // Register the dir with PSR4 autoloading
        if(($aOptions['autoload']) && $this->xAutoloader != null)
        {
            $this->xAutoloader->setPsr4($sNamespace . '\\', $aOptions['directory']);
        }
        $this->xRepository->setNamespaceOptions($sNamespace, $aOptions);
    }

Expected 2 blank lines after function; 1 found

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

        // Browse directories without namespaces and read all the files.
        $aClassMap = [];
        foreach($this->xRepository->getDirectoryOptions() 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 = ['timestamp' => $xFile->getMTime()];
                // No more custom classmap autoloading. The file will be included when needed.
                if(($aOptions['autoload']))
                {
                    $aClassMap[$sClassName] = $xFile->getPathname();
                }
                $this->xRepository->addClass($sClassName, $aClassOptions, $aOptions);
            }
        }
        // Set classmap autoloading
        if(($aClassMap) && $this->xAutoloader !== null)
        {
            $this->xAutoloader->addClassMap($aClassMap);
        }
    }

Expected 2 blank lines after function; 1 found

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

        // Browse directories with namespaces and read all the files.
        $sDS = DIRECTORY_SEPARATOR;
        foreach($this->xRepository->getNamespaceOptions() 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, 'timestamp' => $xFile->getMTime()];
                $this->xRepository->addClass($sClassName, $aClassOptions, $aOptions);
            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Check if a callable object is already in the DI, and register if not
     *
     * @param string $sClassName The class name of the callable object
     *
     * @return string
     * @throws SetupException
     */
    private function checkCallableObject(string $sClassName): string
    {
        // Replace all separators ('.' and '_') with antislashes, and remove the antislashes
        // at the beginning and the end of the class name.
        $sClassName = trim(str_replace('.', '\\', $sClassName), '\\');
        if($this->bUsingUnderscore)
        {
            $sClassName = trim(str_replace('_', '\\', $sClassName), '\\');
        }
        // Register the class.
        $this->di->registerCallableClass($sClassName, $this->xRepository->getClassOptions($sClassName));
        return $sClassName;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the callable object for a given class
     *
     * @param string $sClassName The class name of the callable object
     *
     * @return CallableObject|null
     * @throws SetupException
     */
    public function getCallableObject(string $sClassName): ?CallableObject
    {
        return $this->di->getCallableObject($this->checkCallableObject($sClassName));
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the js call factory for a given class
     *
     * @param string $sClassName The class name of the callable object
     *
     * @return JsCallFactory|null
     * @throws SetupException
     */
    public function getJsCallFactory(string $sClassName): ?JsCallFactory
    {
        return $this->di->getJsCallFactory($this->checkCallableObject($sClassName));
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register all the callable classes
     *
     * @return void
     */
    public function parseCallableClasses()
    {
        $this->parseDirectories();
        $this->parseNamespaces();
    }

Expected 2 blank lines after function; 0 found

}