Jaxon\Request\Handler\Handler

Complexity

Total Complexity

31

Size/Duplication

Total Lines	298
Duplicated Lines	5.7 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	getRequestMethod()	0	4	1
A	requestMethodIsGet()	0	4	1
A	processArguments()	0	4	1
A	getCallbackManager()	0	4	1
A	onBefore()	8	8	2
A	onAfter()	7	7	2
A	onInvalid()	0	7	2
A	onError()	0	11	2
A	canProcessRequest()	0	23	5
A	_processRequest()	0	31	4
A	_cleanOutputBuffers()	0	9	2
B	processRequest()	0	41	7

<?php

/**
 * Handler.php - Jaxon Request Handler
 *
 * This class processes an incoming jaxon request.
 *
 * @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\Request\Handler;

use Jaxon\Jaxon;
use Jaxon\Plugin\Manager as PluginManager;
use Jaxon\Response\Manager as ResponseManager;
use Jaxon\Request\Plugin\FileUpload;

use Exception;

class Handler

Missing doc comment for class Handler

{
    use \Jaxon\Features\Config;

    /**
     * The plugin manager.
     *
     * @var PluginManager
     */
    private $xPluginManager;

    /**
     * The response manager.
     *
     * @var ResponseManager
     */
    private $xResponseManager;

    /**
     * The arguments handler.
     *
     * @var \Jaxon\Request\Handler\Argument
     */
    private $xArgumentManager;

    /**
     * The callbacks to run while processing the request
     *
     * @var \Jaxon\Request\Handler\Callback
     */
    private $xCallbackManager;

    /**
     * The request plugin that is able to process the current request
     *
     * @var \Jaxon\Plugin\Request
     */
    private $xTargetRequestPlugin = null;

    /**
     * The file upload request plugin
     *
     * @var FileUpload
     */
    private $xUploadRequestPlugin = null;

    /**
     * The constructor
     *
     * @param PluginManager         $xPluginManager

Missing parameter comment

Expected 3 spaces after parameter type; 9 found

     * @param ResponseManager       $xResponseManager

Missing parameter comment

Expected 1 spaces after parameter type; 7 found

     * @param FileUpload            $xUploadRequestPlugin

Missing parameter comment

Expected 6 spaces after parameter type; 12 found

     */
    public function __construct(PluginManager $xPluginManager,
        ResponseManager $xResponseManager, FileUpload $xUploadRequestPlugin)
    {
        $this->xPluginManager = $xPluginManager;

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

        $this->xResponseManager = $xResponseManager;

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

        $this->xUploadRequestPlugin = $xUploadRequestPlugin;

        $this->xArgumentManager = new Argument();
        $this->xCallbackManager = new Callback();
    }

    /**
     * Return the method that was used to send the arguments from the client
     *
     * The method is one of: Argument::METHOD_UNKNOWN, Argument::METHOD_GET, Argument::METHOD_POST.
     *
     * @return integer
     */
    public function getRequestMethod()
    {
        return $this->xArgumentManager->getRequestMethod();
    }

    /**
     * Return true if the current request method is GET
     *
     * @return bool
     */
    public function requestMethodIsGet()
    {
        return ($this->xArgumentManager->getRequestMethod() == Argument::METHOD_GET);
    }

    /**
     * Return the array of arguments that were extracted and parsed from the GET or POST data
     *
     * @return array
     */
    public function processArguments()
    {
        return $this->xArgumentManager->process();
    }

    /**
     * Get the callback handler
     *
     * @return Callback
     */
    public function getCallbackManager()
    {
        return $this->xCallbackManager;
    }

    /**

Parameter $bEndRequest should have a doc-comment as per coding-style.

     * This is the pre-request processing callback passed to the Jaxon library.
     *
     * @param  boolean  &$bEndRequest if set to true, the request processing is interrupted.

Expected 1 spaces after parameter type; 2 found

Doc comment for parameter &$bEndRequest does not match actual variable name $bEndRequest

     *
     * @return Jaxon\Response\Response  the Jaxon response

Should the return type not be Jaxon\Response\Response|null?

     */
    public function onBefore(&$bEndRequest)
    {
        // Call the user defined callback
        if(($xCallback = $this->xCallbackManager->before()))

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

        {
            call_user_func_array($xCallback, [$this->xTargetRequestPlugin->getTarget(), &$bEndRequest]);
        }
    }

    /**

Parameter $bEndRequest should have a doc-comment as per coding-style.

     * This is the post-request processing callback passed to the Jaxon library.
     *
     * @return Jaxon\Response\Response  the Jaxon response

Should the return type not be Jaxon\Response\Response|null?

     */
    public function onAfter($bEndRequest)
    {
        if(($xCallback = $this->xCallbackManager->after()))

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

        {
            call_user_func_array($xCallback, [$this->xTargetRequestPlugin->getTarget(), $bEndRequest]);
        }
    }

    /**

Parameter $sMessage should have a doc-comment as per coding-style.

     * This callback is called whenever an invalid request is processed.
     *
     * @return Jaxon\Response\Response  the Jaxon response

Should the return type not be Jaxon\Response\Response|null?

     */
    public function onInvalid($sMessage)
    {
        if(($xCallback = $this->xCallbackManager->invalid()))

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

        {
            call_user_func_array($xCallback, [$sMessage]);
        }
    }

    /**

Parameter $xException should have a doc-comment as per coding-style.

     * This callback is called whenever an invalid request is processed.
     *
     * @return Jaxon\Response\Response  the Jaxon response

Should the return type not be Jaxon\Response\Response|null?

     */
    public function onError(Exception $xException)
    {
        if(($xCallback = $this->xCallbackManager->error()))

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

        {
            call_user_func_array($xCallback, [$xException]);
        }
        else
        {
            throw $xException;
        }
    }

    /**
     * Check if the current request can be processed
     *
     * Calls each of the request plugins and determines if the current request can be processed by one of them.
     *
     * @return boolean
     */
    public function canProcessRequest()
    {
        // Return true if the request plugin was already found
        if(($this->xTargetRequestPlugin))
        {
            return true;
        }

        // Find a plugin to process the request
        foreach($this->xPluginManager->getRequestPlugins() as $xPlugin)
        {
            if($xPlugin->getName() != Jaxon::FILE_UPLOAD && $xPlugin->canProcessRequest())
            {
                $this->xTargetRequestPlugin = $xPlugin;
                return true;
            }
        }

        // If no other plugin than the upload plugin can process the request,
        // then it is a HTTP (not ajax) upload request
        $this->xUploadRequestPlugin->noRequestPluginFound();
        return $this->xUploadRequestPlugin->canProcessRequest();
    }

    /**
     * Process the current request and handle errors and exceptions.
     *
     * @return void
     */
    private function _processRequest()
    {
        try
        {
            // Process uploaded files
            $this->xUploadRequestPlugin->processRequest();

            // Process the request
            if(($this->xTargetRequestPlugin))
            {
                $this->xTargetRequestPlugin->processRequest();
            }
        }
        catch(Exception $e)
        {
            // An exception was thrown while processing the request.
            // The request missed the corresponding handler function,
            // or an error occurred while attempting to execute the handler.

            $this->xResponseManager->error($e->getMessage());

            if($e instanceof \Jaxon\Exception\Error)
            {
                $this->onInvalid($e->getMessage());
            }
            else
            {
                $this->onError($e);
            }
        }
    }

    /**
     * Clean output buffers.
     *
     * @return void
     */
    private function _cleanOutputBuffers()
    {
        $er = error_reporting(0);
        while(ob_get_level() > 0)
        {
            ob_end_clean();
        }
        error_reporting($er);
    }

    /**
     * Process the current request.
     *
     * Calls each of the request plugins to request that they process the current request.
     * If any plugin processes the request, it will return true.
     *
     * @return void
     */
    public function processRequest()
    {
        // Check if there is a plugin to process this request
        if(!$this->canProcessRequest())
        {
            return;
        }

        $bEndRequest = false;

        // Handle before processing event
        if(($this->xTargetRequestPlugin))
        {
            $this->onBefore($bEndRequest);
        }

        if(!$bEndRequest)
        {
            $this->_processRequest();
        }

        // Clean the processing buffer
        if(($this->getOption('core.process.clean')))
        {
            $this->_cleanOutputBuffers();
        }

        if(($this->xTargetRequestPlugin))
        {
            // Handle after processing event
            $this->onAfter($bEndRequest);
        }

        // If the called function returned no response, take the the global response
        if(!$this->xResponseManager->getResponse())
        {
            $this->xResponseManager->append(jaxon()->getResponse());
        }

        $this->xResponseManager->printDebug();
    }
}