Diff::compareArchives() - Code Metrics - Inspection of "Implement a new diff which lists the different fil..." - humbug/box - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#375)

by Théo
created 2019-03-17 22:59 UTC
Diff::compareArchives() A

↳ Parent: Diff
Complexity

Conditions	2
Paths	2
Size

Total Lines	28
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	16
dl	0
loc	28
rs	9.7333
c	0
b	0
f	0
cc	2
nc	2
nop	2
<?php

declare(strict_types=1);

/*
 * This file is part of the box project.
 *
 * (c) Kevin Herrera <[email protected]>
 *     Théo Fidry <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace KevinGH\Box\Console\Command;

use Assert\Assertion;
use function count;
use function is_string;
use KevinGH\Box\Console\PharInfoRenderer;
use KevinGH\Box\PharInfo\PharDiff;
use KevinGH\Box\PharInfo\PharInfo;
use KevinGH\Box\PhpSettingsHandler;
use function sprintf;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Logger\ConsoleLogger;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Throwable;

/**
 * @private
 */
final class Diff extends Command
{
    use CreateTemporaryPharFile;

    private const FIRST_PHAR_ARG = 'pharA';
    private const SECOND_PHAR_ARG = 'pharB';

    private const LIST_FILES_DIFF_OPTION = 'list-diff';
    private const GIT_DIFF_OPTION = 'git-diff';
    private const GNU_DIFF_OPTION = 'gnu-diff';
    private const CHECK_OPTION = 'check';

    /**
     * {@inheritdoc}
     */
    protected function configure(): void
    {
        parent::configure();

        $this->setName('diff');
        $this->setDescription('🕵  Displays the differences between all of the files in two PHARs');

        $this->addArgument(
            self::FIRST_PHAR_ARG,
            InputArgument::REQUIRED,
            'The first PHAR'
        );
        $this->addArgument(
            self::SECOND_PHAR_ARG,
            InputArgument::REQUIRED,
            'The second PHAR'
        );

        $this->addOption(
            self::GNU_DIFF_OPTION,
            null,
            InputOption::VALUE_NONE,
            'Displays a GNU diff'
        );
        $this->addOption(
            self::GIT_DIFF_OPTION,
            null,
            InputOption::VALUE_NONE,
            'Displays a Git diff'
        );
        $this->addOption(
            self::LIST_FILES_DIFF_OPTION,
            null,
            InputOption::VALUE_NONE,
            'Displays a list of file names diff (default)'
        );
        $this->addOption(
            self::CHECK_OPTION,
            'c',
            InputOption::VALUE_OPTIONAL,
            'Verify the authenticity of the contents between the two PHARs with the given hash function.',
            'sha384'
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);

        (new PhpSettingsHandler(new ConsoleLogger($output)))->check();

        $paths = [
            $input->getArgument(self::FIRST_PHAR_ARG),
            $input->getArgument(self::SECOND_PHAR_ARG),
        ];

        Assertion::allFile($paths);
        Assertion::allFile(/** @scrutinizer ignore-type */ $paths);

        try {
            $diff = new PharDiff(...$paths);
        } catch (Throwable $throwable) {
            if ($output->isDebug()) {
                throw $throwable;
            }

            $io->writeln(
                sprintf(
                    '<error>Could not check the PHARs: %s</error>',
                    $throwable->getMessage()
                )
            );

            return 1;
        }

        $result1 = $this->compareArchives($diff, $io);
        $result2 = $this->compareContents($input, $diff, $io);

        return $result1 + $result2;
        if ($input->hasParameterOption(['-c', '--check'])) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            return $diff->listChecksums($input->getOption(self::CHECK_OPTION) ?? 'sha384');
        }

        if ($input->getOption(self::GNU_DIFF_OPTION)) {
            $diffResult = $diff->gnuDiff();
        } elseif ($input->getOption(self::GIT_DIFF_OPTION)) {
            $diffResult = $diff->gitDiff();
        } else {
            return $this->renderListDiff($diff, $io);
        }

        if (null === $diffResult) {
            $io->success('No differences encountered.');

            return 0;
        }

        $io->writeln($diffResult);

        return 1;
    }

    private function compareArchives(PharDiff $diff, SymfonyStyle $io): int
    {
        $io->comment('<info>Comparing the two archives... (do not check the signatures)</info>');

        $pharInfoA = new PharInfo($diff->getPharA()->phar->getPath());
        $pharInfoB = new PharInfo($diff->getPharB()->phar->getPath());

        if ($pharInfoA->equals($pharInfoB)) {
            $io->success('The two archives are identical');

            return 0;
        }

        $this->renderArchive(
            $diff->getPharA()->getFileName(),
            $pharInfoA,
            $io
        );

        $io->newLine();

        $this->renderArchive(
            $diff->getPharB()->getFileName(),
            $pharInfoA,
            $io
        );

        return 1;
    }

    private function compareContents(InputInterface $input, PharDiff $diff, SymfonyStyle $io): int
    {
        $io->comment('<info>Comparing the two archives contents...</info>');

        if ($input->hasParameterOption(['-c', '--check'])) {
            return $diff->listChecksums($input->getOption(self::CHECK_OPTION) ?? 'sha384');
        }

        if ($input->getOption(self::GNU_DIFF_OPTION)) {
            $diffResult = $diff->gnuDiff();
        } elseif ($input->getOption(self::GIT_DIFF_OPTION)) {
            $diffResult = $diff->gitDiff();
        } else {
            $diffResult = $diff->listDiff($diff, $io);
            $diffResult = $diff->listDiff($diff, $io);
        }

        if (null === $diffResult || [[], []] === $diffResult) {
            $io->success('The contents are identical');

            return 0;
        }

        if (is_string($diffResult)) {
            // Git or GNU diff: we don't have much control on the format
            $io->writeln($diffResult);

            return 1;
        }

        $io->writeln(sprintf(
            '--- Files present in "%s" but not in "%s"',
            $diff->getPharA()->getFileName(),
            $diff->getPharB()->getFileName()
        ));
        $io->writeln(sprintf(
            '+++ Files present in "%s" but not in "%s"',
            $diff->getPharB()->getFileName(),
            $diff->getPharA()->getFileName()
        ));

        $io->newLine();

        $renderPaths = static function (string $symbol, array $paths, SymfonyStyle $io): void {
            foreach ($paths as $path) {
                $io->writeln(sprintf(
                    '%s %s',
                    $symbol,
                    $path
                ));
            }
        };

        $renderPaths('-', $diffResult[0], $io);
        $renderPaths('+', $diffResult[1], $io);

        $io->error(sprintf(
            '%d file(s) difference',
            count($diffResult[0]) + count($diffResult[1])
        ));

        return 1;
    }

    private function renderArchive(string $fileName, PharInfo $pharInfo, SymfonyStyle $io): void
    {
        $io->writeln(
            sprintf(
                '<comment>Archive: </comment><fg=cyan;options=bold>%s</>',
                $fileName
            )
        );

        PharInfoRenderer::renderCompression($pharInfo, $io);
        // Omit the signature
        PharInfoRenderer::renderMetadata($pharInfo, $io);
        PharInfoRenderer::renderContentsSummary($pharInfo, $io);
    }
}

humbug / box

Pull Request — master (#375)

Diff::compareArchives() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
