Jaxon\Di\Traits\PluginTrait

Complexity

Total Complexity

7

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	registerPlugins()	0	33	3
A	getPluginManager()	0	3	1
A	getCodeGenerator()	0	3	1
A	getUploadHandler()	0	3	1
A	getJQueryPlugin()	0	3	1

<?php

Missing file doc comment

namespace Jaxon\Di\Traits;

use Jaxon\Jaxon;
use Jaxon\Config\ConfigManager;
use Jaxon\Di\Container;
use Jaxon\Plugin\Code\AssetManager;
use Jaxon\Plugin\Code\CodeGenerator;
use Jaxon\Plugin\Manager\PluginManager;
use Jaxon\Request\Handler\UploadHandler;
use Jaxon\Request\Upload\UploadManager;
use Jaxon\Request\Validator;
use Jaxon\Response\Plugin\DataBag\DataBagPlugin;
use Jaxon\Response\Plugin\JQuery\JQueryPlugin;
use Jaxon\Response\ResponseManager;
use Jaxon\Ui\View\ViewManager;
use Jaxon\Utils\File\FileMinifier;

The type Jaxon\Utils\File\FileMinifier was not found. Maybe you did not declare it correctly or list all dependencies?

use Jaxon\Utils\Http\UriDetector;
use Jaxon\Utils\Template\TemplateEngine;

The type Jaxon\Utils\Template\TemplateEngine was not found. Maybe you did not declare it correctly or list all dependencies?

use Jaxon\Utils\Translation\Translator;

trait PluginTrait

Missing doc comment for trait PluginTrait

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

Expected 2 blank lines before function; 0 found

    {
        // Plugin manager
        $this->set(PluginManager::class, function($c) {

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

            return new PluginManager($c->g(Container::class), $c->g(ConfigManager::class),
                $c->g(ViewManager::class), $c->g(CodeGenerator::class), $c->g(Translator::class));
        });
        // Code Generation
        $this->set(AssetManager::class, function($c) {
            return new AssetManager($c->g(ConfigManager::class), $c->g(UriDetector::class), $c->g(FileMinifier::class));
        });
        $this->set(CodeGenerator::class, function($c) {
            $sVersion = $c->g(Jaxon::class)->getVersion();
            return new CodeGenerator($sVersion, $c->g(Container::class),
                $c->g(TemplateEngine::class), $c->g(AssetManager::class));
        });
        // File upload manager
        $this->set(UploadManager::class, function($c) {
            return new UploadManager($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(UploadManager::class), $c->g(ResponseManager::class), $c->g(Translator::class));
        });
        // JQuery response plugin
        $this->set(JQueryPlugin::class, function($c) {
            $jQueryNs = $c->g(ConfigManager::class)->getOption('core.jquery.no_conflict', false) ? 'jQuery' : '$';
            return new JQueryPlugin($jQueryNs);
        });
        // DataBagPlugin response plugin
        $this->set(DataBagPlugin::class, function() {
            return new DataBagPlugin();
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the plugin manager
     *
     * @return PluginManager
     */
    public function getPluginManager(): PluginManager
    {
        return $this->g(PluginManager::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 code generator
     *
     * @return CodeGenerator
     */
    public function getCodeGenerator(): CodeGenerator
    {
        return $this->g(CodeGenerator::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 jQuery plugin
     *
     * @return JQueryPlugin
     */
    public function getJQueryPlugin(): JQueryPlugin

This method is not in camel caps format.

    {
        return $this->g(JQueryPlugin::class);
    }

Expected 2 blank lines after function; 0 found

}