AbstractClassPrinter::finishClass() - Code Metrics - Inspection of "printers added for generating basic model boilerpl..." - spider-mane/leonidas - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a228a3...2f45dd )

by Chris

created 2022-06-22 04:18 UTC

AbstractClassPrinter::finishClass() A

↳ Parent: AbstractClassPrinter

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	0
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	2
ccs	0
cts	0
cp	0
crap	2
rs	10

<?php

namespace Leonidas\Console\Library\Abstracts;

use Leonidas\Console\Library\PsrPrinterFactory;
use Nette\PhpGenerator\ClassType;
use Nette\PhpGenerator\InterfaceType;
filter:
    dependency_paths: ["lib/*"]
use Nette\PhpGenerator\Method;
use Nette\PhpGenerator\PhpFile;
use Nette\PhpGenerator\PhpNamespace;
use Nette\PhpGenerator\Printer;
use Nette\PhpGenerator\TraitType;
filter:
    dependency_paths: ["lib/*"]

abstract class AbstractClassPrinter
{
    public const CORE = 'core';

    protected const SIGNATURES = [];

    protected string $namespace;

    protected string $class;

    public function __construct(string $namespace, string $class)
    {
        $this->namespace = $namespace;
        $this->class = $class;
    }

    public function printFile(): string
    {
        return $this->print($this->getDefaultSignatures());
    }

    protected function print(array $methods): string
    {
        $file = new PhpFile();
        $namespace = $file->addNamespace($this->namespace);
        $class = $this->setupClass($namespace);

        if (!$class->isInterface()) {
            $file->setStrictTypes(true);
        }

        $this->addMethods($class, $methods);
        $this->finishClass($class);

        return $this->getPrinter()->printFile($file);
    }

    protected function getPrinter(): Printer
    {
        return PsrPrinterFactory::create();
    }

    protected function getDefaultSignatures(): array
    {
        return static::SIGNATURES;
    }

    /**
     * @param ClassType|InterfaceType|TraitType $class
     * @param array<string,array<string,string>> $signatures
     */
    protected function addMethods($class, array $signatures): void
    {
        foreach ($signatures as $method => $signature) {
            $this->addMethod($class, $method, $signature);
        }
    }

    /**
     * @param ClassType|InterfaceType|TraitType $class
     */
    protected function addMethod($class, string $name, array $signature): void
    {
        $call = $signature['call'] ?? $name;

        $swap = $this->getMethodPassReplacements();
        $pass = str_replace($swap[0], $swap[1], $signature['pass'] ?? '');

        $swap = $this->getMethodGiveReplacements();
        $return = str_replace(
            [...$swap[0], ...$strip = ['?', '&'], '$this'],
            /** @scrutinizer ignore-type */ [...$swap[0], ...$strip = ['?', '&'], '$this'],
            [...$swap[1], ...$this->mapSymbols($strip), $this->getClassFqn()],
            /** @scrutinizer ignore-type */ [...$swap[1], ...$this->mapSymbols($strip), $this->getClassFqn()],
            $give = $signature['give'] ?? 'void'
        );

        $method = $class->addMethod($name)
            ->setReturnNullable(str_starts_with($give, '?'))
            ->setReturnReference(str_starts_with($give, '&'))
            ->setReturnType($return)
            ->setPublic();

        if (!$class->isInterface()) {
            $method->setBody($this->getMethodBody($call, $pass, $give));
        }

        $params = ($take = $signature['take'] ?? false)
            ? explode(', ', $take)
            : [];

        foreach ($params as $param) {
            $this->addParameter($method, $param);
        }

        if ('$this' === $give) {
            $method->addComment('@return ' . '$this');
        }
    }

    protected function getClassFqn(): string
    {
        return $this->namespace . '\\' . $this->class;
    }

    protected function getMethodPassReplacements(): array
    {
        return [[], []];
    }

    protected function getMethodGiveReplacements(): array
    {
        return [[], []];
    }

    protected function getMethodBody(string $call, string $pass, string $give): string
    {
        $action = sprintf('$this->%s->%s(%s);', static::CORE, $call, $pass);

        return ('void' === $give) ? $action : 'return ' . $action;
    }

    protected function addParameter(Method $method, string $param): void
    {
        $parts = explode(' ', $param);

        $swap = $this->getParameterTypeReplacements();
        $type = str_replace(
            [...$swap[0], ...$strip = ['*']],
            /** @scrutinizer ignore-type */ [...$swap[0], ...$strip = ['*']],
            [...$swap[1], ...$this->mapSymbols($strip)],
            /** @scrutinizer ignore-type */ [...$swap[1], ...$this->mapSymbols($strip)],
            $parts[0]
        );

        $swap = $this->getParameterNameReplacements();
        $name = str_replace(
            [...$swap[0], ...$strip = ['$', '?', '&', '...']],
            /** @scrutinizer ignore-type */ [...$swap[0], ...$strip = ['$', '?', '&', '...']],
            [...$swap[1], ...$this->mapSymbols($strip)],
            $parts[1]
        );

        $method->setVariadic(str_starts_with($parts[1], '...'));

        $parameter = $method->addParameter($name)
            ->setNullable(str_starts_with($parts[1], '?'))
            ->setReference(str_starts_with($parts[1], '&'))
            ->setType($type);

        if ($default = $parts[3] ?? false) {
            if ('null' === $default) {
                $default = null;
            } elseif ('true' === $default) {
                $default = true;
            } elseif ('false' === $default) {
                $default = false;
            } elseif (is_numeric($default)) {
                $default = (int) $default;
            } elseif (is_string($default)) {

                $default = trim($default, '\'"');
            }

            $parameter->setDefaultValue($default);
        }
    }

    protected function mapSymbols(array $symbols): array
    {
        return array_pad([], count($symbols), '');
    }

    protected function getParameterTypeReplacements(): array
    {
        return [[], []];
    }

    protected function getParameterNameReplacements(): array
    {
        return [[], []];
    }

    /**
     * @param ClassType|InterfaceType|TraitType $class
     */
    protected function finishClass($class): void
    {
        //
    }

    /**
     * @return ClassType|TraitType|InterfaceType
     */
    abstract protected function setupClass(PhpNamespace $namespace);
}


spider-mane / leonidas

Push — master ( a228a3...2f45dd )

AbstractClassPrinter::finishClass() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like