Jaxon\Jaxon

Complexity

Total Complexity

40

Size/Duplication

Total Lines	466
Duplicated Lines	0 %

Importance

Changes	23
Bugs	1	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	plugin()	0	3	1
A	getVersion()	0	3	1
A	di()	0	3	1
A	session()	0	3	1
A	getJs()	0	3	1
A	package()	0	3	1
A	app()	0	3	1
A	callback()	0	3	1
A	canProcessRequest()	0	3	1
A	getInstance()	0	7	2
A	config()	0	3	1
A	register()	0	25	6
A	getResponse()	0	3	1
A	getDefaultOptions()	0	33	1
A	getScript()	0	3	1
A	template()	0	3	1
A	newResponse()	0	3	1
A	request()	0	4	2
A	__construct()	0	13	2
A	instance()	0	4	2
A	registerPlugin()	0	3	1
A	printScript()	0	3	1
A	view()	0	3	1
A	dialog()	0	3	1
A	processRequest()	0	20	4
A	getCss()	0	3	1
A	logger()	0	3	1
A	upload()	0	3	1

<?php

/**
 * Jaxon.php - Jaxon class
 *
 * The Jaxon class uses a modular plug-in system to facilitate the processing
 * of special Ajax requests made by a PHP page.
 * It generates Javascript that the page must include in order to make requests.
 * It handles the output of response commands (see <Jaxon\Response\Response>).
 * Many flags and settings can be adjusted to effect the behavior of the Jaxon class
 * as well as the client-side javascript.
 *
 * @package jaxon-core

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

 * @author Jared White

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author J. Max Wilson

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Joseph Woolley

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Steffen Konerow

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright 2016 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;

use Jaxon\Plugin\Plugin;
use Jaxon\Plugin\Package;
use Jaxon\Utils\DI\Container;
use Jaxon\Utils\Config\Reader as ConfigReader;

use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerAwareInterface;

class Jaxon implements LoggerAwareInterface

Missing doc comment for class Jaxon

{
    use Features\Config;
    use Features\Translator;
    use LoggerAwareTrait;

    /**
     * Package version number
     *
     * @var string
     */
    private $sVersion = 'Jaxon 3.2.0';

    /*
     * Plugin types
     */

Empty line required after block comment

    // Response plugin
    const PLUGIN_RESPONSE = 'ResponsePlugin';
    // Request plugin
    const PLUGIN_REQUEST = 'RequestPlugin';
    // Package plugin
    const PLUGIN_PACKAGE = 'PackagePlugin';

    /*
     * Request plugins
     */

Empty line required after block comment

    const CALLABLE_CLASS = 'CallableClass';

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

    const CALLABLE_DIR = 'CallableDir';

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

    const CALLABLE_FUNCTION = 'CallableFunction';
    // For uploaded files.
    const FILE_UPLOAD = 'FileUpload';
    // For compatibility with previous versions
    const CALLABLE_OBJECT = 'CallableClass'; // Same as CALLABLE_CLASS
    const USER_FUNCTION = 'CallableFunction'; // Same as CALLABLE_FUNCTION

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

    /**
     * A static instance on this class
     *
     * @var Jaxon
     */
    private static $xInstance = null;

    /**
     * The DI container
     *
     * @var Container
     */
    private static $xContainer = null;

    /**
     * Get the static instance
     *
     * @return Jaxon
     */
    public static function getInstance()

Expected 2 blank lines before function; 1 found

    {
        if(self::$xInstance == null)
        {
            self::$xInstance = new Jaxon();
        }
        return self::$xInstance;
    }

Expected 2 blank lines after function; 1 found

    /**
     * The constructor
     */
    public function __construct()
    {
        // Set the default logger
        $this->setLogger(new NullLogger());

        if(self::$xContainer == null)
        {
            self::$xContainer = new Container($this->getDefaultOptions());
            /*

Empty line required before block comment

            * Register the Jaxon request and response plugins

First line of comment not aligned correctly; expected 13 spaces but found 12

            */

Last line of comment aligned incorrectly; expected 13 spaces but found 12

Empty line required after block comment

            $this->di()->getPluginManager()->registerRequestPlugins();
            $this->di()->getPluginManager()->registerResponsePlugins();
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the DI container
     *
     * @return Container
     */
    public function di()
    {
        return self::$xContainer;
    }

Expected 2 blank lines after function; 1 found

    /**
     * The current Jaxon version
     *
     * @return string
     */
    public function getVersion()
    {
        return $this->sVersion;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the logger
     *
     * @return LoggerInterface
     */
    public function logger()
    {
        return $this->logger;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the config reader
     *
     * @return ConfigReader
     */
    public function config()
    {
        return $this->di()->get(ConfigReader::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the default options of all components of the library
     *
     * @return array<string,string|boolean|integer>
     */
    private function getDefaultOptions()
    {
        // The default configuration settings.
        return [
            'core.version'                      => $this->getVersion(),
            'core.language'                     => 'en',
            'core.encoding'                     => 'utf-8',
            'core.decode_utf8'                  => false,
            'core.prefix.function'              => 'jaxon_',
            'core.prefix.class'                 => 'Jaxon',
            // 'core.request.uri'               => '',
            'core.request.mode'                 => 'asynchronous',
            'core.request.method'               => 'POST', // W3C: Method is case sensitive
            'core.response.send'                => true,
            'core.response.merge.ap'            => true,
            'core.response.merge.js'            => true,
            'core.debug.on'                     => false,
            'core.debug.verbose'                => false,
            'core.process.exit'                 => true,
            'core.process.clean'                => false,
            'core.process.timeout'              => 6000,
            'core.error.handle'                 => false,
            'core.error.log_file'               => '',
            'core.jquery.no_conflict'           => false,
            'core.upload.enabled'               => true,
            'js.lib.output_id'                  => 0,
            'js.lib.queue_size'                 => 0,
            'js.lib.load_timeout'               => 2000,
            'js.lib.show_status'                => false,
            'js.lib.show_cursor'                => true,
            'js.app.dir'                        => '',
            'js.app.minify'                     => true,
            'js.app.options'                    => '',
        ];
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the Global Response object
     *
     * @return \Jaxon\Response\Response
     */
    public function getResponse()
    {
        return $this->di()->getResponse();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Create a new Jaxon response object
     *
     * @return \Jaxon\Response\Response
     */
    public function newResponse()
    {
        return $this->di()->newResponse();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register a plugin
     *
     * Below is a table for priorities and their description:
     * - 0 thru 999: Plugins that are part of or extensions to the jaxon core
     * - 1000 thru 8999: User created plugins, typically, these plugins don't care about order
     * - 9000 thru 9999: Plugins that generally need to be last or near the end of the plugin list
     *
     * @param Plugin    $xPlugin        An instance of a plugin

Expected 2 spaces after parameter type; 4 found

Expected 3 spaces after parameter name; 8 found

     * @param integer   $nPriority      The plugin priority, used to order the plugins

Expected 1 spaces after parameter name; 6 found

Expected 1 spaces after parameter type; 3 found

     *
     * @return void
     */
    public function registerPlugin(Plugin $xPlugin, $nPriority = 1000)
    {
        $this->di()->getPluginManager()->registerPlugin($xPlugin, $nPriority);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register request handlers, including functions, callable classes and directories.
     *
     * @param string        $sType            The type of request handler being registered

Expected 7 spaces after parameter type; 8 found

Expected 4 spaces after parameter name; 12 found

     *        Options include:

Parameter comment not aligned correctly; expected 40 spaces but found 8

     *        - Jaxon::CALLABLE_FUNCTION: a function declared at global scope

Parameter comment not aligned correctly; expected 40 spaces but found 8

     *        - Jaxon::CALLABLE_CLASS: a class who's methods are to be registered

Parameter comment not aligned correctly; expected 40 spaces but found 8

     *        - Jaxon::CALLABLE_DIR: a directory containing classes to be registered

Parameter comment not aligned correctly; expected 40 spaces but found 8

     *        - Jaxon::PACKAGE: a package

Parameter comment not aligned correctly; expected 40 spaces but found 8

     * @param string        $sName

Expected 7 spaces after parameter type; 8 found

Missing parameter comment

     *        When registering a function, this is the name of the function
     *        When registering a callable class, this is the class name
     *        When registering a callable directory, this is the full path to the directory
     *        When registering a package or a plugin, this is the corresponding class name
     * @param array|string  $xOptions   The related options

Expected 1 spaces after parameter type; 2 found

Expected 1 spaces after parameter name; 3 found

     *
     * @return void
     */
    public function register($sType, $sName, $xOptions = [])
    {
        if($sType == self::CALLABLE_DIR ||
            $sType == self::CALLABLE_CLASS ||
            $sType == self::CALLABLE_FUNCTION)
        {
            $this->di()->getPluginManager()->registerCallable($sType, $sName, $xOptions);
            return;
        }
        /*

Empty line required before block comment

        if($sType == self::PLUGIN_RESPONSE)

First line of comment not aligned correctly; expected 12 spaces but found 8

Block comments must start with a capital letter

        {

Comment line indented incorrectly; expected at least 12 spaces but found 8

            $this->di()->getPluginManager()->registerRequestPlugin($sName, $xOptions);
            return;
        }

Comment line indented incorrectly; expected at least 12 spaces but found 8

        if($sType == self::PLUGIN_REQUEST)

Comment line indented incorrectly; expected at least 12 spaces but found 8

        {

Comment line indented incorrectly; expected at least 12 spaces but found 8

            $this->di()->getPluginManager()->registerResponsePlugin($sName, $xOptions);
            return;
        }

Comment line indented incorrectly; expected at least 12 spaces but found 8

        */

Empty line required after block comment

        if($sType == self::PLUGIN_PACKAGE && is_array($xOptions))
        {
            $this->di()->getPluginManager()->registerPackage($sName, $xOptions);
            return;
        }
        // Todo: throw an error
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get an instance of a registered class
     *
     * @param string        $sClassName         The class name

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 9 found

     *
     * @return mixed
     */
    public function instance($sClassName)
    {
        $xCallable = $this->di()->getCallableRegistry()->getCallableObject($sClassName);
        return ($xCallable) ? $xCallable->getRegisteredObject() : null;

$xCallable is of type Jaxon\Request\Support\CallableObject, thus it always evaluated to true.

    }

Expected 2 blank lines after function; 1 found

    /**
     * Get a request to a registered class
     *
     * @param string        $sClassName         The class name

Expected 1 spaces after parameter name; 9 found

Expected 1 spaces after parameter type; 8 found

     *
     * @return \Jaxon\Request\Factory\CallableClass\Request
     */
    public function request($sClassName)
    {
        $xInstance = $this->instance($sClassName);
        return ($xInstance) ? $xInstance->rq() : null;

$xInstance is of type object, thus it always evaluated to true.

    }

Expected 2 blank lines after function; 1 found

    /**
     * Returns the Jaxon Javascript header and wrapper code to be printed into the page
     *
     * The javascript code returned by this function is dependent on the plugins
     * that are included and the functions and classes that are registered.
     *
     * @param boolean        $bIncludeJs            Also get the JS files

Expected 1 spaces after parameter type; 8 found

Expected 2 spaces after parameter name; 12 found

     * @param boolean        $bIncludeCss        Also get the CSS files

Expected 1 spaces after parameter name; 8 found

Expected 1 spaces after parameter type; 8 found

     *
     * @return string
     */
    public function getScript($bIncludeJs = false, $bIncludeCss = false)
    {
        return $this->di()->getCodeGenerator()->getScript($bIncludeJs, $bIncludeCss);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Print the jaxon Javascript header and wrapper code into your page
     *
     * The javascript code returned by this function is dependent on the plugins
     * that are included and the functions and classes that are registered.
     *
     * @param boolean        $bIncludeJs            Also print the JS files

Expected 1 spaces after parameter type; 8 found

Expected 2 spaces after parameter name; 12 found

     * @param boolean        $bIncludeCss        Also print the CSS files

Expected 1 spaces after parameter name; 8 found

Expected 1 spaces after parameter type; 8 found

     *
     * @return void
     */
    public function printScript($bIncludeJs = false, $bIncludeCss = false)
    {
        print $this->getScript($bIncludeJs, $bIncludeCss);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the javascript header code and file includes
     *
     * @return string
     */
    public function getJs()
    {
        return $this->di()->getCodeGenerator()->getJs();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the CSS header code and file includes
     *
     * @return string
     */
    public function getCss()
    {
        return $this->di()->getCodeGenerator()->getCss();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Determine if a call is a jaxon request or a page load request
     *
     * @return boolean
     */
    public function canProcessRequest()
    {
        return $this->di()->getRequestHandler()->canProcessRequest();
    }

Expected 2 blank lines after function; 1 found

    /**
     * If this is a jaxon request, call the requested PHP function, build the response and send it back to the browser
     *
     * This is the main server side engine for Jaxon.
     * It handles all the incoming requests, including the firing of events and handling of the response.
     * If your RequestURI is the same as your web page, then this function should be called before ANY
     * headers or HTML is output from your script.
     *
     * This function may exit after the request is processed, if the 'core.process.exit' option is set to true.
     *
     * @return void
     *
     * @see <Jaxon\Jaxon->canProcessRequest>
     */
    public function processRequest()
    {
        // Check to see if headers have already been sent out, in which case we can't do our job
        if(headers_sent($filename, $linenumber))
        {
            echo $this->trans('errors.output.already-sent', [
                'location' => $filename . ':' . $linenumber
            ]), "\n", $this->trans('errors.output.advice');
            exit();

Using exit here is not recommended.

        }

        $this->di()->getRequestHandler()->processRequest();

        if(($this->getOption('core.response.send')))
        {
            $this->di()->getResponseManager()->sendOutput();

            if(($this->getOption('core.process.exit')))
            {
                exit();

Using exit here is not recommended.

            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get a registered response plugin
     *
     * @param string        $sName                The name of the plugin

Expected 1 spaces after parameter name; 16 found

Expected 1 spaces after parameter type; 8 found

     *
     * @return \Jaxon\Plugin\Response
     */
    public function plugin($sName)
    {
        return $this->di()->getPluginManager()->getResponsePlugin($sName);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get a package instance
     *
     * @param string        $sClassName           The package class name

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 11 found

     *
     * @return \Jaxon\Plugin\Package
     */
    public function package($sClassName)
    {
        return $this->di()->getPluginManager()->getPackage($sClassName);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the upload plugin
     *
     * @return \Jaxon\Request\Plugin\FileUpload
     */
    public function upload()
    {
        return $this->di()->getPluginManager()->getRequestPlugin(self::FILE_UPLOAD);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the request callback manager
     *
     * @return \Jaxon\Request\Handler\Callback
     */
    public function callback()
    {
        return $this->di()->getRequestHandler()->getCallbackManager();

The expression return $this->di()->getRequestHandler()->getCallbackManager() returns the type callable which is incompatible with the documented return type Jaxon\Request\Handler\Callback.

    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the dialog wrapper
     *
     * @return \Jaxon\Utils\Dialogs\Dialog
     */
    public function dialog()
    {
        return $this->di()->getDialog();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the template engine
     *
     * @return \Jaxon\Utils\Template\Engine
     */
    public function template()
    {
        return $this->di()->getTemplateEngine();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the App instance
     *
     * @return \Jaxon\App\App
     */
    public function app()
    {
        return $this->di()->getApp();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the view renderer
     *
     * @return \Jaxon\Utils\View\Renderer
     */
    public function view()
    {
        return $this->di()->getViewRenderer();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the session manager
     *
     * @return \Jaxon\Contracts\Session
     */
    public function session()
    {
        return $this->di()->getSessionManager();
    }

Expected 2 blank lines after function; 0 found

}