Jaxon\Request\Support\CallableRepository

Complexity

Total Complexity

20

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	3

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	makeClassOptions()	0	22	5
A	addClass()	0	4	1
A	addNamespace()	0	4	1
A	getClassOptions()	0	9	2
B	createCallableObject()	0	34	7
A	getClasses()	0	4	1
A	getNamespaces()	0	4	1
A	getCallableObjects()	0	4	1
A	getCallableOptions()	0	4	1

<?php

/**
 * CallableRepository.php - Jaxon callable object repository
 *
 * This class stores all the callable object already created.
 *
 * @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 Jaxon\Request\Factory\CallableClass\Request as RequestFactory;

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

class CallableRepository

Missing doc comment for class CallableRepository

{
    /**
     * The classes
     *
     * These are all the registered classes.
     *
     * @var array
     */
    protected $aClasses = [];

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

    /**
     * The namespaces
     *
     * These are all the namespaces found in registered directories.
     *
     * @var array
     */
    protected $aNamespaces = [];

    /**
     * The created callable objects.
     *
     * @var array
     */
    protected $aCallableObjects = [];

    /**
     * The options to be applied to callable objects.
     *
     * @var array
     */
    protected $aCallableOptions = [];

    /**
     * Get a given class options from specified directory options
     *
     * @param string        $sClassName         The class name

Expected 1 spaces after parameter type; 8 found

Expected 8 spaces after parameter name; 9 found

     * @param array         $aClassOptions      The default class options

Expected 2 spaces after parameter type; 9 found

Expected 5 spaces after parameter name; 6 found

     * @param array         $aDirectoryOptions  The directory options

Expected 2 spaces after parameter type; 9 found

Expected 1 spaces after parameter name; 2 found

     *
     * @return array
     */
    public function makeClassOptions($sClassName, array $aClassOptions, array $aDirectoryOptions)
    {
        $aOptions = $aClassOptions;
        if(key_exists('separator', $aDirectoryOptions))
        {
            $aOptions['separator'] = $aDirectoryOptions['separator'];
        }
        if(key_exists('protected', $aDirectoryOptions))
        {
            $aOptions['protected'] = $aDirectoryOptions['protected'];
        }
        if(key_exists('*', $aDirectoryOptions))
        {
            $aOptions = array_merge($aOptions, $aDirectoryOptions['*']);
        }
        if(key_exists($sClassName, $aDirectoryOptions))
        {
            $aOptions = array_merge($aOptions, $aDirectoryOptions[$sClassName]);
        }

        return $aOptions;
    }

    /**
     *
     * @param string        $sClassName         The class name

Expected 1 spaces after parameter type; 8 found

Expected 8 spaces after parameter name; 9 found

     * @param array         $aClassOptions      The default class options

Expected 2 spaces after parameter type; 9 found

Expected 5 spaces after parameter name; 6 found

     * @param array         $aDirectoryOptions  The directory options

Expected 2 spaces after parameter type; 9 found

Expected 1 spaces after parameter name; 2 found

     *
     * @return void
     */
    public function addClass($sClassName, array $aClassOptions, array $aDirectoryOptions = [])
    {
        $this->aClasses[$sClassName] = $this->makeClassOptions($sClassName, $aClassOptions, $aDirectoryOptions);
    }

    /**
     *
     * @param string        $sNamespace     The namespace

Expected 7 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 5 found

     * @param array|string  $aOptions       The associated options

Expected 1 spaces after parameter type; 2 found

Expected 3 spaces after parameter name; 7 found

     *
     * @return void
     */
    public function addNamespace($sNamespace, $aOptions)
    {
        $this->aNamespaces[$sNamespace] = $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
     */
    public function getClassOptions($sClassName)
    {
        if(!key_exists($sClassName, $this->aClasses))
        {
            // Class not found
            return null;
        }
        return $this->aClasses[$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

     * @param array         $aOptions              The callable object options

Expected 2 spaces after parameter type; 9 found

Expected 3 spaces after parameter name; 14 found

     *
     * @return CallableObject|null
     */
    public function createCallableObject($sClassName, array $aOptions)
    {
        // Make sure the registered class exists
        if(key_exists('include', $aOptions))
        {
            require_once($aOptions['include']);
        }
        if(!class_exists($sClassName))
        {
            return null;
        }

        // Create the callable object
        $xCallableObject = new CallableObject($sClassName);

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

        $this->aCallableOptions[$sClassName] = [];
        foreach($aOptions as $sName => $xValue)
        {
            if(in_array($sName, ['separator', 'namespace', 'protected']))
            {
                $xCallableObject->configure($sName, $xValue);
            }
            elseif(is_array($xValue) && $sName != 'include')
            {
                // These options are to be included in javascript code.
                $this->aCallableOptions[$sClassName][$sName] = $xValue;
            }
        }
        $this->aCallableObjects[$sClassName] = $xCallableObject;

        // Register the request factory for this callable object
        jaxon()->di()->setCallableClassRequestFactory($sClassName, $xCallableObject);

        return $xCallableObject;
    }

    /**
     * Get all registered classes
     *
     * @return array
     */
    public function getClasses()
    {
        return $this->aClasses;
    }

    /**
     * Get all registered namespaces
     *
     * @return array
     */
    public function getNamespaces()
    {
        return $this->aNamespaces;
    }

    /**
     * Get all registered callable objects
     *
     * @return array
     */
    public function getCallableObjects()
    {
        return $this->aCallableObjects;
    }

    /**
     * Get all registered callable objects options
     *
     * @return array
     */
    public function getCallableOptions()
    {
        return $this->aCallableOptions;
    }
}