Graviton\GeneratorV2Bundle\Command\GenerateCommand

Complexity

Total Complexity

21

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	configure()	0	7	1
A	execute()	0	47	2
D	getDefinitions()	0	44	10
A	buildDynBundle()	0	22	1
B	buildDocument()	0	32	5
A	buildServiceAndRoutes()	0	9	1

<?php
/**
 * Generates the versions.yml file
 */

namespace Graviton\GeneratorV2Bundle\Command;

use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Finder\Finder;
use Symfony\Bundle\TwigBundle\TwigEngine;
use Symfony\Component\Yaml\Yaml;

/**
 * Reads out the used versions with composer and git and writes them in a file 'versions.yml'
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class GenerateCommand extends Command
{
    const NAME = 'generate-v2:generate';

    /** @var String wrapper or core */
    private $contextMode;

    /** @var String location for dynamic directory */
    private $dynamicDir;

    /** @var String location for dynamic directory */
    private $skeletonDir;

    /** @var array Service routes */
    private $routes = [];

    /** @var OutputInterface */
    private $output;

    /** @var Filesystem */
    private $filesystem;

    /** @var TwigEngine */
    private $templating;

    public function __construct(Filesystem $filesystem, $templating)
    {
        $this->filesystem = $filesystem;
        $this->templating = $templating;

        parent::__construct();
    }

    protected function configure()
    {
        $this->setName(self::NAME)
            ->setDescription(
                'Generates the versions.yml file according to definition in app/config/version_service.yml'
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;
        /** @var Application $application */
        $application = $this->getApplication();
        /** @var ContainerInterface $container */
        $container = $application->getKernel()->getContainer();
        $rootDir = $container->getParameter('kernel.root_dir');

        if (strpos($rootDir, 'vendor')) {
            $this->output->writeln('Generating content for Wrapper mode');
            $this->contextMode = 'wrapper';
            $realDir = realpath($rootDir . '/../../../../');
            $this->skeletonDir = $realDir.'/vendor/graviton/graviton/src/Graviton/GeneratorV2Bundle/Resources/Skeleton';
        } else {
            $this->output->writeln('Generating content for Graviton core mode');
            $this->contextMode = 'core';
            $realDir = realpath($rootDir . '/../');
            $this->skeletonDir = $realDir . '/src/Graviton/GeneratorV2Bundle/Resources/Skeleton';
        }
        // Dynamic Dir, Will always be in vendor/graviton folder
        $this->dynamicDir = $realDir . '/vendor/graviton/graviton-dyn/src/GravitonDyn';

        // Is GravitonDyn Exists, remove it
        $this->output->writeln('Removing old Dynamic Dir');
        $this->filesystem->remove($this->dynamicDir);

        // Find the Definitions
        $this->output->writeln('Scanning for definitions');
        $definitions = $this->getDefinitions($realDir);
        $this->output->writeln('Definitions Found: '.count($definitions));

        // Build the basic bundle structure
        $this->buildDynBundle();

        // TODO Build the Documents
        $this->buildDocument($definitions);

        // TODO Build service and routing
        $this->buildServiceAndRoutes();

        // Register bundle

        // Build document getters and setter
        // php app/console doctrine:mongodb:generate:documents GravitonDynBundle

    }

    /**
     * Check project for files to be generated
     *
     * @param $realDir
     * @return array
     */
    private function getDefinitions($realDir)
    {
        $files = [];
        if ('wrapper' == $this->contextMode) {
            $directories = [
                $realDir . '/vendor/graviton',
                $realDir . '/vendor/grv',
            ];
        } else {
            $directories = [
                $realDir . '/src'
            ];
            if (is_dir($realDir . '/vendor/grv')) {
                $directories[] = $realDir . '/vendor/grv';
            }
            if (is_dir($realDir . '/vendor/graviton')) {
                $directories[] = $realDir . '/vendor/graviton';
            }
        }
        $finder = new Finder();
        $finder->files()->in($directories)->name('*.json');
        foreach ($finder as $file) {
            $path = $file->getRealPath();
            if (strpos($path, '/Resources/')) {
                $json = json_decode($file->getContents());
                if (json_last_error()) {
                    throw new InvalidConfigurationException($path.': '.json_last_error_msg());
                }
                if (isset($json->service, $json->service->routerBase)) {
                    if (!isset($json->id)) {
                        throw new InvalidConfigurationException($path.': This definition do not have required "id"');
                    }
                    if (array_key_exists($json->service->routerBase, $this->routes)) {
                        throw new InvalidConfigurationException(
                            $path.': '.$json->service->routerBase.': Route already exists!! '.$json->id
                        );
                    }
                    $this->routes[$json->service->routerBase] = $json->id;
                }
                $files[] = $json;
            }
        }
        return $files;
    }

    /**
     * Create the basic structure
     */
    private function buildDynBundle()
    {
        // Base directories
        $this->output->writeln('Creating Directories');
        $this->filesystem->mkdir($this->dynamicDir);
        $this->filesystem->mkdir($this->dynamicDir.'/Resources');
        $this->filesystem->mkdir($this->dynamicDir.'/Resources/config');
        $this->filesystem->mkdir($this->dynamicDir.'/Resources/schema');
        $this->filesystem->mkdir($this->dynamicDir.'/DependencyInjection');
        $this->filesystem->mkdir($this->dynamicDir.'/Document');

        // Base files
        $this->output->writeln('Creating Base files');
        $this->filesystem->dumpFile(
            $this->dynamicDir.'/GravitonDynBundle.php',
            $this->templating->render($this->skeletonDir.'/GravitonDynBundle.php.twig', [])
        );
        $this->filesystem->dumpFile(
            $this->dynamicDir.'/DependencyInjection/GravitonDynExtension.php',
            $this->templating->render($this->skeletonDir.'/DependencyInjection/GravitonDynExtension.php.twig', [])
        );
    }

    /**
     * Building Db Documents
     *
     * @param $definitions
     */
    private function buildDocument($definitions)
    {
        $progress = new ProgressBar($this->output, count($definitions));
        $progress->setMessage('Building documents');

        foreach ($definitions as $def)
        {
            $build = [
                'document'    => $def->id,
                'title'       => isset($def->title) ? $def->title : $def->id,
                'description' => isset($def->description) ? $def->description : $def->id,
                'fields'      => isset($def->target->fields) ? (array) $def->target->fields : (array) $def->properties
            ];

            // Schema
            $this->filesystem->dumpFile(
                $this->dynamicDir.'/Resources/schema/'.$def->id.'.json',
                json_encode($build, JSON_PRETTY_PRINT)
            );
            // Doctrine Document mapping
            $this->filesystem->dumpFile(
                $this->dynamicDir.'/Document/'.$def->id.'.php',
                $this->templating->render($this->skeletonDir.'/Document/Document.php.twig', $build)
            );
            $progress->setMessage('Task in progress...');
            $progress->advance();
            break;
        }
        $progress->setMessage('Task is finished');
        $progress->finish();
        $this->output->writeln("\n");
    }

    private function buildServiceAndRoutes()
    {
        // Build parameters Routes to be Used in RestService
        $string = Yaml::dump(['parameters'=> ['routes' => $this->routes]]);
        $this->filesystem->dumpFile(
            $this->dynamicDir.'/Resources/config/parameters.yml',
            $string
        );
    }
}