SoliDry\Controllers\GeneratorTrait

Complexity

Total Complexity

16

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	solveFormRequest()	0	11	3
A	solveEntities()	0	12	3
A	outputEntity()	0	5	1
A	createMigrations()	0	6	2
A	solveControllers()	0	13	3
A	mergeResources()	0	14	1
A	generateResources()	0	30	3

<?php

namespace SoliDry\Controllers;

use SoliDry\Blocks\Controllers;
use SoliDry\Blocks\Entities;
use SoliDry\Blocks\FileManager;
use SoliDry\Blocks\FormRequest;
use SoliDry\Blocks\Migrations;
use SoliDry\Blocks\Routes;
use SoliDry\Blocks\Tests;
use SoliDry\Exceptions\DirectoryException;
use SoliDry\Helpers\Console;
use SoliDry\Types\ConsoleInterface;
use SoliDry\Types\DefaultInterface;
use SoliDry\Types\DirsInterface;
use SoliDry\Types\PhpInterface;

/**
 * Trait GeneratorTrait
 *
 * @package SoliDry\Controllers
 */
trait GeneratorTrait
{
    use HistoryTrait;

    // all generated entities/resources
    private $forms;
    private $routes;

    // gen dir found in history
    private $genDir;

    /**
     * Standard generation
     */
    private function generateResources(): void
    {
        $this->outputEntity();

        // create controller
        $this->solveControllers();

        // create FormRequest
        $this->solveFormRequest();

        // create entities/models
        $this->solveEntities();

        // create routes
        $this->routes = new Routes($this);
        $this->routes->create();

        // create tests
        if (empty($this->options[ConsoleInterface::OPTION_TESTS]) === false) {
            try {
                FileManager::createPath($this->formatFuncTestsPath());

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

            } catch (DirectoryException $e) {
                $this->error($e->getTraceAsString());

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

            }

            $tests = new Tests($this);
            $tests->createEntity($this->formatFuncTestsPath(), DefaultInterface::FUNCTIONAL_POSTFIX);
        }

        $this->createMigrations();
    }

    /**
     *  Generation with merge option
     */
    private function mergeResources(): void
    {
        $this->outputEntity();
        $this->solveControllers();

        $this->solveFormRequest();

        $this->solveEntities();

        // create routes
        $this->routes = new Routes($this);
        $this->routes->create();

        $this->createMigrations();
    }

    /**
     *  Creates Controllers and leaves those generated in case of merge
     */
    private function solveControllers(): void
    {
        $controllers = new Controllers($this);
        $controllerPath = $this->formatControllersPath();

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

        if (empty($this->options[ConsoleInterface::OPTION_REGENERATE]) === false
            && file_exists($controllers->getEntityFile($controllerPath,
                DefaultInterface::CONTROLLER_POSTFIX)) === true) {

            $controllers->recreateEntity($controllerPath, DefaultInterface::CONTROLLER_POSTFIX);
        } else {
            $controllers->createDefault();
            $controllers->createEntity($controllerPath, DefaultInterface::CONTROLLER_POSTFIX);
        }
    }

    private function solveFormRequest(): void
    {
        $this->forms = new FormRequest($this);
        $formRequestPath = $this->formatRequestsPath();

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

        if (empty($this->options[ConsoleInterface::OPTION_REGENERATE]) === false
            && file_exists($this->forms->getEntityFile($formRequestPath,
                DefaultInterface::FORM_REQUEST_POSTFIX)) === true) {
            $this->forms->recreateEntity($formRequestPath, DefaultInterface::FORM_REQUEST_POSTFIX);
        } else {
            $this->forms->createEntity($formRequestPath, DefaultInterface::FORM_REQUEST_POSTFIX);
        }
    }

    /**
     *  Decide whether to generate new Entities or mutate existing
     */
    private function solveEntities(): void
    {
        // create entities/models
        $mappers = new Entities($this);
        $mappers->createPivot();
        $entitiesPath = $this->formatEntitiesPath();

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

        if (empty($this->options[ConsoleInterface::OPTION_MERGE]) === false
            && file_exists($this->forms->getEntityFile($entitiesPath)) === true) {
            $mappers->recreateEntity($entitiesPath);
        } else {
            $mappers->createEntity($entitiesPath);
        }
    }

    private function outputEntity(): void
    {
        Console::out(
            '===============' . PhpInterface::SPACE . $this->objectName
            . PhpInterface::SPACE . DirsInterface::ENTITIES_DIR
        );
    }

    /**
     *  Creates migrations for every entity if there is merge option - adds additional
     */
    private function createMigrations(): void
    {
        if (empty($this->options[ConsoleInterface::OPTION_MIGRATIONS]) === false) {
            $migrations = new Migrations($this);
            $migrations->create();
            $migrations->createPivot();
        }
    }
}