AlecRabbit\Tools\Reports\Formatters\BenchmarkReportFormatter

Complexity

Total Complexity

17

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	benchmarkedAny()	0	3	1
A	countersStatistics()	0	20	2
A	checkReturns()	0	4	1
A	benchmarked()	0	5	1
A	allReturnsAreEqual()	0	13	2
A	process()	0	30	5
A	functionsReturns()	0	8	2
A	added()	0	4	1
A	countedExceptions()	0	12	2

<?php declare(strict_types=1);

namespace AlecRabbit\Tools\Reports\Formatters;

use AlecRabbit\Tools\Internal\BenchmarkFunction;
use AlecRabbit\Tools\Reports\BenchmarkReport;
use AlecRabbit\Tools\Reports\Contracts\BenchmarkReportInterface;
use AlecRabbit\Tools\Reports\Contracts\ReportInterface;
use AlecRabbit\Tools\Reports\Factory;
use AlecRabbit\Tools\Reports\Formatters\Contracts\BenchmarkReportFormatterInterface;
use function AlecRabbit\array_is_homogeneous;

class BenchmarkReportFormatter extends ReportFormatter implements BenchmarkReportFormatterInterface
{
    /** @var BenchmarkReport */
    protected $report;

    /** @var mixed */
    protected $lastReturn;

    /** {@inheritdoc} */
    public function process(ReportInterface $report): string
    {
        if ($report instanceof BenchmarkReport) {
            $this->report = $report;
            $str = 'Results:' . PHP_EOL;
            $added = $this->added();
            $benchmarked = $this->benchmarked();
            $benchmarkedAny = $this->benchmarkedAny($added, $benchmarked);
            if ($benchmarkedAny) {
                $str .= self::BENCHMARK . PHP_EOL;
            }
            $equalReturns = $this->checkReturns();
            /** @var BenchmarkFunction $function */
            foreach ($this->report->getFunctions() as $name => $function) {
                $str .=
                    Factory::getBenchmarkFunctionFormatter()
                        ->noReturnIf($equalReturns)
                        ->process($function);
            }
            return
                sprintf(
                    '%s%s%s%s%s',
                    $str,
                    $benchmarkedAny ? $this->allReturnsAreEqual($equalReturns) : '',
                    $this->countersStatistics($added, $benchmarked),
                    $this->report->getMemoryUsageReport(),
                    PHP_EOL
                );
        }
        return '';
    }

    /**
     * @return int
     */
    private function added(): int
    {
        return
            $this->report->getAdded()->getValue();
    }

    /**
     * @return int
     */
    private function benchmarked(): int
    {
        // todo use dedicated counter 'BENCHMARKED'
        return
            $this->report->getBenchmarked()->getValue();
    }

    /**
     * @param int $added
     * @param int $benchmarked
     * @return bool
     */
    private function benchmarkedAny(int $added, int $benchmarked): bool
    {
        return $added !== $added - $benchmarked;
    }

    /**
     * @return bool
     */
    protected function checkReturns(): bool
    {
        return
            array_is_homogeneous($this->functionsReturns());
    }

    /**
     * @return array
     */
    private function functionsReturns(): array
    {
        $returns = [];
        /** @var BenchmarkFunction $function */
        foreach ($this->report->getFunctions() as $name => $function) {
            $returns[] = $this->lastReturn = $function->getReturn();
        }
        return $returns;
    }

    private function allReturnsAreEqual(bool $equalReturns): string
    {
        if ($equalReturns) {
            return
                sprintf(
                    '%s %s%s %s',
                    'All returns are equal:',
                    PHP_EOL,
                    BenchmarkFunctionFormatter::returnToString($this->lastReturn),
                    PHP_EOL
                );
        }
        return '';
    }

    /**
     * @param int $added
     * @param int $benchmarked
     * @return string
     */
    private function countersStatistics(int $added, int $benchmarked): string
    {
        if ($added === $benchmarked) {
            return sprintf(
                '%s: %s %s',
                static::BENCHMARKED,
                $benchmarked,
                PHP_EOL
            );
        }

        return
            sprintf(
                '%s: %s %s: %s %s %s',
                static::ADDED,
                $added,
                static::BENCHMARKED,
                $benchmarked,
                $this->countedExceptions($added, $benchmarked),
                PHP_EOL
            );
    }

    /**
     * @param int $added
     * @param int $benchmarked
     * @return string
     */
    private function countedExceptions(int $added, int $benchmarked): string
    {
        if (0 !== $exceptions = $added - $benchmarked) {
            return
                sprintf(
                    '%s %s',
                    static::EXCEPTIONS,
                    $exceptions
                );
        }
        // @codeCoverageIgnoreStart
        return '';
        // @codeCoverageIgnoreEnd
    }
}