BernardoSecades\SplitBlue\Command\CompileCommand

Complexity

Total Complexity

30

Size/Duplication

Total Lines	264
Duplicated Lines	41.67 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	compileToMock()	0	4	1
A	compileToDoc()	0	4	1
B	executeAglio()	37	37	4
B	executeMarkdownPP()	37	37	4
A	getFilesToMock()	0	4	1
A	getFilesToDoc()	0	4	1
A	getFiles()	0	16	2
A	configure()	0	12	1
A	execute()	0	15	2
A	initialize()	0	4	1
A	createMockFiles()	18	18	3
A	createDocFiles()	18	18	3
B	renderFilesInfo()	0	23	4
A	hasGeneratedFiles()	0	4	2

<?php

/**
 * MIT License
 *
 * Copyright (c) 2017 Bernardo Secades
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

namespace BernardoSecades\SplitBlue\Command;

use BernardoSecades\SplitBlue\Exception\DocException;
use BernardoSecades\SplitBlue\Exception\MockException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Process\Process;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
use SplFileInfo;

class CompileCommand extends Command
{
    /** @var array */
    protected $compiledFiles = [];
    /** @var array */
    protected $docCreatedFiles = [];
    /** @var OutputInterface */
    protected $output;
    /** @var string */
    protected $mdPath;

    protected function configure()
    {
        $this
            ->setName('atrapalo:mocks-compile')
            ->setAliases(['c'])
            ->setDescription('Compile .apib files to generate documentation and unique files to load in mock server')
            ->addArgument(
                'path',
                InputArgument::REQUIRED,
                'Base folder to start to search files index.apib'
            );
    }
    /**
     * @param InputInterface  $input
     * @param OutputInterface $output
     * @return int
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        if (function_exists('xdebug_disable')) {
            xdebug_disable();
        }

        $this->mdPath = $input->getArgument('path');

        $this->createMockFiles();
        $output->writeln('');
        $this->createDocFiles();
        $output->writeln('');

        return $this->renderFilesInfo();
    }

    /**
     * @param InputInterface  $input
     * @param OutputInterface $output
     */
    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;
    }

    protected function createMockFiles()

This method seems to be duplicated in your project.

    {
        $files = $this->getFilesToMock();

        if ($files->count()) {
            $this->output->writeln('<info>Compiling "apib" files to mock</info>');
            $progress = new ProgressBar($this->output, count($files));
            $progress->setBarCharacter('<fg=magenta>=</>');
            $progress->setProgressCharacter("\xF0\x9F\x8D\xBA");

            foreach ($files as $file) {
                $this->compileToMock($file->getRealPath());
                $progress->advance();
            }

            $progress->finish();
        }
    }

    protected function createDocFiles()

This method seems to be duplicated in your project.

    {
        $files = $this->getFilesToDoc();

        if ($files->count()) {
            $this->output->writeln('<info>Creating documentation from mock files compiled</info>');
            $progress = new ProgressBar($this->output, count($files));
            $progress->setBarCharacter('<fg=magenta>=</>');
            $progress->setProgressCharacter("\xF0\x9F\x8D\xBA");

            foreach ($files as $file) {
                $this->compileToDoc($file->getRealPath());
                $progress->advance();
            }

            $progress->finish();
        }
    }

    /**
     * @param string $fileName
     */
    protected function compileToMock($fileName)
    {
        $this->executeMarkdownPP($fileName);
    }

    /**
     * @param string $fileName
     */
    protected function compileToDoc($fileName)
    {
        $this->executeAglio($fileName);
    }

    /**
     * @param string $fileName
     * @throws DocException
     */
    protected function executeAglio($fileName)

This method seems to be duplicated in your project.

    {
        $workingDirectory = dirname($fileName);

        if ('Build' != basename($workingDirectory)) {
            $pathBuild = $workingDirectory . DIRECTORY_SEPARATOR . 'Build';
            $fileSystem = new Filesystem();
            try {
                $fileSystem->mkdir($pathBuild);
            } catch (IOExceptionInterface $exception) {
                throw new DocException(
                    sprintf('Can not create folder %s', $pathBuild),
                    0,
                    $exception
                );
            }
        } else {
            $pathBuild = $workingDirectory;
        }

        $createdFile = sprintf('%s/out.html', $pathBuild);
        $commandLine = sprintf('aglio -i %s -o %s', $fileName, $createdFile);
        $process = new Process($commandLine);
        $process->setWorkingDirectory($workingDirectory);

        try {
            $process->mustRun();
            $this->docCreatedFiles[] = $createdFile;
        } catch (ProcessFailedException $e) {
            throw new DocException(
                sprintf(
                    'Error to generate mock file with markdown-pp: %s, maybe markdown-pp is not installed',
                    $e->getMessage()
                )
            );
        }
    }

    /**
     * @param string $fileName
     * @throws MockException
     */
    protected function executeMarkdownPP($fileName)

This method seems to be duplicated in your project.

    {
        $workingDirectory = dirname($fileName);

        if ('Build' != basename($workingDirectory)) {
            $pathBuild = $workingDirectory . DIRECTORY_SEPARATOR . 'Build';
            $fileSystem = new Filesystem();
            try {
                $fileSystem->mkdir($pathBuild);
            } catch (IOExceptionInterface $exception) {
                throw new MockException(
                    sprintf('Can not create folder %s', $pathBuild),
                    0,
                    $exception
                );
            }
        } else {
            $pathBuild = $workingDirectory;
        }

        $fileCreated = sprintf('%s/out.apib', $pathBuild);
        $commandLine = sprintf('markdown-pp %s -o %s', $fileName, $fileCreated);
        $process = new Process($commandLine);
        $process->setWorkingDirectory($workingDirectory);

        try {
            $process->mustRun();
            $this->compiledFiles[] = $fileCreated;
        } catch (ProcessFailedException $e) {
            throw new MockException(
                sprintf(
                    'Error to generate mock file with markdown-pp: %s, maybe markdown-pp is not installed',
                    $e->getMessage()
                )
            );
        }
    }

    /**
     * @return Finder
     */
    protected function getFilesToMock()
    {
        return $this->getFiles($this->mdPath, 'index.apib');
    }

    /**
     * @return Finder
     */
    protected function getFilesToDoc()
    {
        return $this->getFiles($this->mdPath, 'out.apib');
    }

    /**
     * @param string $path
     * @param string $filter
     * @return Finder
     */
    protected function getFiles($path, $filter)
    {
        $finder = new Finder();
        $files = $finder
            ->files()
            ->ignoreDotFiles(true)
            ->filter(function (SplFileInfo $file) use ($filter) {
                if ($file->getFilename() != $filter) {
                    return false;
                }
                return true;
            })
            ->in($path)->files();

        return $files;
    }

    /**
     * @return int
     */
    protected function renderFilesInfo()
    {
        if ($this->hasGeneratedFiles()) {

            $this->output->writeln('<info>Files generated:</info>');

            $this->output->writeln('<fg=black;bg=cyan>Mock Files:</>');
            foreach ($this->compiledFiles as $nameFile) {
                $this->output->writeln($nameFile);
            }

            $this->output->writeln('<fg=black;bg=cyan>Doc Files:</>');
            foreach ($this->docCreatedFiles as $nameFile) {
                $this->output->writeln($nameFile);
            }

            return 0;
        }

        $this->output->writeln('<fg=black;bg=red>There are not index files to generate mock or doc files</>');

        return 1;
    }

    /**
     * @return bool
     */
    protected function hasGeneratedFiles()
    {
        return !empty($this->docCreatedFiles) && !empty($this->compiledFiles);
    }
}