Jaxon\Container\Traits\CallableTrait

Complexity

Total Complexity

3

Size/Duplication

Total Lines	54
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getCodeGenerator()	0	3	1
A	registerCallables()	0	26	1
A	getCallableRegistry()	0	3	1

<?php

Missing file doc comment

namespace Jaxon\Container\Traits;

use Jaxon\Jaxon;
use Jaxon\Plugin\Code\Generator as CodeGenerator;
use Jaxon\Request\Handler\Handler as RequestHandler;
use Jaxon\Request\Plugin\CallableClass;
use Jaxon\Request\Plugin\CallableDir;
use Jaxon\Request\Plugin\CallableFunction;
use Jaxon\Request\Support\CallableRegistry;
use Jaxon\Request\Support\CallableRepository;
use Jaxon\Response\Manager as ResponseManager;
use Jaxon\Utils\Http\URI;
use Jaxon\Utils\Template\Engine as TemplateEngine;

trait CallableTrait

Missing doc comment for trait CallableTrait

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

Expected 2 blank lines before function; 0 found

    {
        // Callable objects repository
        $this->set(CallableRepository::class, function() {

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

            return new CallableRepository($this);
        });
        // Callable objects registry
        $this->set(CallableRegistry::class, function($c) {
            return new CallableRegistry($c->g(CallableRepository::class));
        });
        // Callable class plugin
        $this->set(CallableClass::class, function($c) {
            return new CallableClass($c->g(RequestHandler::class), $c->g(ResponseManager::class),
                $c->g(CallableRegistry::class), $c->g(CallableRepository::class));
        });
        // Callable dir plugin
        $this->set(CallableDir::class, function($c) {
            return new CallableDir($c->g(CallableRegistry::class));
        });
        // Callable function plugin
        $this->set(CallableFunction::class, function($c) {
            return new CallableFunction($this, $c->g(RequestHandler::class), $c->g(ResponseManager::class));
        });
        // Code Generator
        $this->set(CodeGenerator::class, function($c) {
            return new CodeGenerator($c->g(Jaxon::class), $c->g(URI::class), $c->g(TemplateEngine::class));
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the callable registry
     *
     * @return CallableRegistry
     */
    public function getCallableRegistry()
    {
        return $this->g(CallableRegistry::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()
    {
        return $this->g(CodeGenerator::class);
    }

Expected 2 blank lines after function; 0 found

}