Jaxon\Di\Traits\RequestTrait::registerRequests()

Size

Total Lines	71
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	RequestTrait.php$0 ➔ random()	0	3	1

<?php

Missing file doc comment

namespace Jaxon\Di\Traits;

use Jaxon\Config\ConfigManager;
use Jaxon\Di\Container;
use Jaxon\Plugin\Manager\PluginManager;
use Jaxon\Request\Factory;
use Jaxon\Request\Factory\ParameterFactory;
use Jaxon\Request\Factory\RequestFactory;
use Jaxon\Request\Handler\CallbackManager;
use Jaxon\Request\Handler\ParameterReader;
use Jaxon\Request\Handler\RequestHandler;
use Jaxon\Request\Handler\UploadHandler;
use Jaxon\Request\Plugin\CallableClass\CallableRegistry;
use Jaxon\Request\Upload\NameGeneratorInterface;
use Jaxon\Request\Upload\UploadManager;
use Jaxon\Request\Validator;
use Jaxon\Response\Manager\ResponseManager;
use Jaxon\Response\Plugin\DataBag\DataBagPlugin;
use Jaxon\Ui\Dialogs\DialogFacade;
use Jaxon\Ui\Pagination\Paginator;
use Jaxon\Utils\Http\UriDetector;
use Jaxon\Utils\Translation\Translator;
use Nyholm\Psr7\Factory\Psr17Factory;
use Nyholm\Psr7Server\ServerRequestCreator;
use Psr\Http\Message\ServerRequestInterface;

use function bin2hex;
use function random_bytes;

trait RequestTrait

Missing doc comment for trait RequestTrait

{
    /**
     * Register the values into the container
     *
     * @return void
     */
    private function registerRequests()

Expected 2 blank lines before function; 0 found

    {
        // The server request
        $this->set(ServerRequestCreator::class, function() {

It seems like set() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $xRequestFactory = new Psr17Factory();
            return new ServerRequestCreator(
                $xRequestFactory, // ServerRequestFactory
                $xRequestFactory, // UriFactory
                $xRequestFactory, // UploadedFileFactory
                $xRequestFactory  // StreamFactory
            );
        });
        $this->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)->fromGlobals();
        });
        // The parameter reader
        $this->set(ParameterReader::class, function($c) {
            return new ParameterReader($c->g(Container::class), $c->g(ConfigManager::class),
                $c->g(Translator::class), $c->g(UriDetector::class));
        });
        // Callback Manager
        $this->set(CallbackManager::class, function() {
            return new CallbackManager();
        });
        // Request Handler
        $this->set(RequestHandler::class, function($c) {
            return new RequestHandler($c->g(Container::class), $c->g(PluginManager::class),
                $c->g(ResponseManager::class), $c->g(CallbackManager::class),
                $c->g(UploadHandler::class), $c->g(DataBagPlugin::class));
        });
        // Upload file and dir name generator
        $this->set(NameGeneratorInterface::class, function() {
            return new class implements NameGeneratorInterface
            {
                public function random(int $nLength): string

Missing doc comment for function random()

Expected 2 blank lines before function; 0 found

                {
                    return bin2hex(random_bytes((int)($nLength / 2)));
                    /*try

Block comment text must start on a new line

                    {
                        return bin2hex(random_bytes((int)($nLength / 2)));
                    }
                    catch(Exception $e){}
                    // Generate the name
                    $sChars = '0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz';
                    return substr(str_shuffle($sChars), 0, $nLength);*/
                }

Expected 2 blank lines after function; 0 found

            };
        });
        // File upload manager
        $this->set(UploadManager::class, function($c) {
            return new UploadManager($c->g(NameGeneratorInterface::class), $c->g(ConfigManager::class),
                $c->g(Validator::class), $c->g(Translator::class));
        });
        // File upload plugin
        $this->set(UploadHandler::class, function($c) {
            return !$c->g(ConfigManager::class)->getOption('core.upload.enabled') ? null :

Expected 1 space after ":"; newline found

                new UploadHandler($c->g(Container::class), $c->g(ResponseManager::class), $c->g(Translator::class));
        });
        // Request Factory
        $this->set(Factory::class, function($c) {
            return new Factory($c->g(CallableRegistry::class), $c->g(RequestFactory::class),
                $c->g(ParameterFactory::class));
        });
        // Factory for requests to functions
        $this->set(RequestFactory::class, function($c) {
            $sPrefix = $c->g(ConfigManager::class)->getOption('core.prefix.function');
            return new RequestFactory($sPrefix, $c->g(DialogFacade::class), $c->g(Paginator::class));
        });
        // Parameter Factory
        $this->set(ParameterFactory::class, function() {
            return new ParameterFactory();
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the request
     *
     * @return ServerRequestInterface
     */
    public function getRequest(): ServerRequestInterface
    {
        return $this->g(ServerRequestInterface::class);

It seems like g() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the request handler
     *
     * @return RequestHandler
     */
    public function getRequestHandler(): RequestHandler
    {
        return $this->g(RequestHandler::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the upload handler
     *
     * @return UploadHandler|null
     */
    public function getUploadHandler(): ?UploadHandler
    {
        return $this->g(UploadHandler::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the upload manager
     *
     * @return UploadManager
     */
    public function getUploadManager(): UploadManager
    {
        return $this->g(UploadManager::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the callback manager
     *
     * @return CallbackManager
     */
    public function getCallbackManager(): CallbackManager
    {
        return $this->g(CallbackManager::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the parameter reader
     *
     * @return ParameterReader
     */
    public function getParameterReader(): ParameterReader
    {
        return $this->g(ParameterReader::class);
    }

Expected 2 blank lines after function; 0 found

}