AlecRabbit\Tools\Formatters\BenchmarkFunctionFormatter

Complexity

Total Complexity

21

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	returnToString()	0	11	2
A	extractArgumentsTypes()	0	9	3
A	preformatFunction()	0	14	1
A	resetEqualReturns()	0	4	1
A	formatException()	0	19	2
A	noReturnIf()	0	4	1
A	getExporter()	0	6	2
A	process()	0	12	3
A	formatBenchmarkRelative()	0	18	4
A	average()	0	8	1
A	relativePercent()	0	8	1

<?php declare(strict_types=1);

namespace AlecRabbit\Tools\Formatters;

use AlecRabbit\Accessories\Pretty;
use AlecRabbit\Tools\Formattable;
use AlecRabbit\Tools\Formatters\Contracts\BenchmarkFunctionFormatterInterface;
use AlecRabbit\Tools\Formatters\Core\Formatter;
use AlecRabbit\Tools\Internal\BenchmarkFunction;
use AlecRabbit\Tools\Internal\BenchmarkRelative;
use SebastianBergmann\Exporter\Exporter;
use function AlecRabbit\typeOf;

class BenchmarkFunctionFormatter extends Formatter implements BenchmarkFunctionFormatterInterface
{
    /** @var null|Exporter */
    protected static $exporter;

    /** @var bool */
    protected $equalReturns = false;

    /** {@inheritdoc} */
    public function resetEqualReturns(): BenchmarkFunctionFormatter
    {
        return
            $this->noReturnIf();
    }

    /** {@inheritdoc} */
    public function noReturnIf(bool $equalReturns = false): BenchmarkFunctionFormatter
    {
        $this->equalReturns = $equalReturns;
        return $this;
    }

    /** {@inheritdoc} */
    public function process(Formattable $function): string
    {
        if ($function instanceof BenchmarkFunction) {
            return
                $this->formatBenchmarkRelative($function) .
                (empty($exception = $this->formatException($function)) ?
                    PHP_EOL :
                    /*static::EXCEPTIONS .*/ $exception . PHP_EOL);
        }
        $this->wrongFormattableType(BenchmarkFunction::class, $function);
        // @codeCoverageIgnoreStart
        return ''; // never executes
        // @codeCoverageIgnoreEnd
    }

    /**
     * @param BenchmarkFunction $function
     * @return string
     */
    protected function formatBenchmarkRelative(BenchmarkFunction $function): string
    {
        if ($br = $function->getBenchmarkRelative()) {
            $argumentsTypes = $this->extractArgumentsTypes($function->getArgs());
            $executionReturn = $function->getReturn();
            if ($this->equalReturns || $function->isNotShowReturns()) {
                return $this->preformatFunction($br, $function, $argumentsTypes);
            }
            return
                sprintf(
                    '%s %s %s %s',
                    $this->preformatFunction($br, $function, $argumentsTypes),
                    PHP_EOL,
                    $this->returnToString($executionReturn),
                    PHP_EOL
                );
        }
        return '';
    }

    /**
     * @param array $arguments
     * @return array
     */
    protected function extractArgumentsTypes(array $arguments): array
    {
        $types = [];
        if (!empty($arguments)) {
            foreach ($arguments as $argument) {
                $types[] = typeOf($argument);
            }
        }
        return $types;
    }

    /**
     * @param BenchmarkRelative $br
     * @param BenchmarkFunction $function
     * @param array $argumentsTypes
     *
     * @return string
     */
    protected function preformatFunction(
        BenchmarkRelative $br,
        BenchmarkFunction $function,
        array $argumentsTypes
    ): string {
        return
            sprintf(
                '%s. %s (%s) %s(%s) %s',
                (string)$br->getRank(),
                $this->average($br->getAverage()),
                $this->relativePercent($br->getRelative()),
                $function->humanReadableName(),
                implode(', ', $argumentsTypes),
                $function->comment()
            );
    }

    /**
     * @param float $average
     * @return string
     */
    protected function average(float $average): string
    {
        return
            str_pad(
                Pretty::time($average),
                8,
                ' ',
                STR_PAD_LEFT
            );
    }

    /**
     * @param float $relative
     * @param string $prefix
     * @return string
     */
    protected function relativePercent(float $relative, string $prefix = ' '): string
    {
        return
            str_pad(
                $prefix . Pretty::percent($relative),
                9,
                ' ',
                STR_PAD_LEFT
            );
    }

    /** {@inheritdoc} */
    public function returnToString($executionReturn): string
    {
        $type = typeOf($executionReturn);
        $str = static::getExporter()->export($executionReturn);
        return
            'array' === $type ?
                $str :
                sprintf(
                    '%s(%s)',
                    $type,
                    $str
                );
    }

    /**
     * @return Exporter
     */
    protected static function getExporter(): Exporter
    {
        if (null === static::$exporter) {
            static::$exporter = new Exporter();
        }
        return static::$exporter;
    }

    /**
     * @param BenchmarkFunction $function
     * @return string
     */
    protected function formatException(BenchmarkFunction $function): string
    {

        if ($e = $function->getException()) {
            $argumentsTypes = $this->extractArgumentsTypes($function->getArgs());

            return
                sprintf(
                    '%s(%s) %s [%s: %s] %s',
                    $function->humanReadableName(),
                    implode(', ', $argumentsTypes),
                    $function->comment(),
                    typeOf($e),
                    $e->getMessage(),
                    PHP_EOL
                );
        }

        return '';
    }
}