Webmozart\Assert\Generator\Mixin

Complexity

Total Complexity

26

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	generate()	0	24	3
A	parseDocComment()	0	17	5
A	splitDocLine()	0	8	2
B	createWrapper()	0	47	9
A	createNullOr()	0	4	1
A	createAll()	0	4	1
A	getSupportedMethods()	0	32	1
A	createFile()	0	7	1
A	createNamespace()	0	7	1
A	createInterface()	0	4	1
A	isPublicMethod()	0	6	1

<?php
declare(strict_types=1);

namespace Webmozart\Assert\Generator;

use InvalidArgumentException;
use Nette\PhpGenerator\ClassType;
use Nette\PhpGenerator\PhpFile;
use Nette\PhpGenerator\PhpNamespace;
use Nette\PhpGenerator\PsrPrinter;
use ReflectionClass;
use ReflectionMethod;
use Webmozart\Assert\Assert;

final class Mixin
{
    public function generate(): string
    {
        $assert = new ReflectionClass(Assert::class);
        $staticMethods = $assert->getMethods(ReflectionMethod::IS_STATIC);

        $supportedMethods = $this->getSupportedMethods($assert);

        $file = $this->createFile();
        $namespace = $this->createNamespace($file, $assert);
        $mixin = $this->createInterface($namespace);

        foreach ($staticMethods as $method) {
            if (!$this->isPublicMethod($method)) {
                continue;
            }

            $this->createNullOr($method, $supportedMethods, $mixin);
            $this->createAll($method, $supportedMethods, $mixin);
        }

        $printer = new PsrPrinter();

        return $printer->printFile($file);
    }

    private function parseDocComment(string $comment): array
    {
        $lines = explode("\n", $comment);

        $result = [];

        foreach ($lines as $line) {
            if (preg_match('~^\*\s+@(\S+)(\s+.*)?$~', trim($line), $matches)) {
                if (count($matches) === 2 || $matches[2] === null) {
                    $matches[2] = '';
                }
                $result[$matches[1]][] = trim($matches[2]);
            }
        }

        return $result;
    }

    private function splitDocLine(string $line): array
    {
        if (!preg_match('~^(.*)\s+(\$\S+)$~', $line, $matches)) {
            return [$line];
        }

        return [trim($matches[1]), $matches[2]];
    }

    private function createWrapper(ReflectionMethod $method, array $supportedMethods, ClassType $mixin, $methodNameTemplate, $typeTemplate)
    {
        $newMethodName = sprintf($methodNameTemplate, ucfirst($method->name));

        if (!in_array($newMethodName, $supportedMethods, true)) {
            return;
        }

        $comment = $method->getDocComment();

        $parsedComment = $this->parseDocComment($comment);

        if (!in_array('psalm-assert', array_keys($parsedComment))) {
            return;
        }

        $mixinMethod = $mixin->addMethod($newMethodName)
            ->setStatic();

        $parameters = $method->getParameters();

        foreach ($parameters as $parameter) {
            $mixinParameter = $mixinMethod->addParameter($parameter->name);

            if ($parameter->isDefaultValueAvailable()) {
                $mixinParameter->setDefaultValue($parameter->getDefaultValue());
            }
        }

        foreach ($parsedComment as $key => $values) {
            foreach ($values as $value) {
                $parts = $this->splitDocLine($value);
                $type = $parts[0];

                if ($key === 'psalm-assert') {
                    $type = sprintf($typeTemplate, $type);
                }

                $comment = sprintf('@%s %s', $key, $type);
                if (count($parts) >= 2) {
                    $comment .= sprintf(' %s', implode(' ', array_slice($parts, 1)));
                }

                $mixinMethod->addComment($comment);
            }
        }
    }

    private function createNullOr(ReflectionMethod $method, array $supportedMethods, ClassType $mixin)
    {
        $this->createWrapper($method, $supportedMethods, $mixin, 'nullOr%s', 'null|%s');
    }

    private function createAll(ReflectionMethod $method, array $supportedMethods, ClassType $mixin)
    {
        $this->createWrapper($method, $supportedMethods, $mixin, 'all%s', 'array<array-key,%s>');
    }

    private function getSupportedMethods(ReflectionClass $class): array
    {
        $comment = $class->getDocComment();

        preg_match_all('~@method static void ([^(]+)~', $comment, $matches);

        $temporaryUnsupported = [
            'nullOrNotInstanceOf',
            'allNotInstanceOf',
            'nullOrNotEmpty',
            'allNotEmpty',
            'allNotNull',
            'nullOrSame',
            'allSame',
            'nullOrUnicodeLetters',
            'allUnicodeLetters',
            'nullOrStringNotEmpty',
            'allStringNotEmpty',
            'nullOrIsNotA',
            'allIsNotA',
            'nullOrNotFalse',
            'allNotFalse',
            'nullOrUpper',
            'allUpper',
            'nullOrIsNonEmptyList',
            'allIsNonEmptyList',
            'nullOrIsNonEmptyMap',
            'allIsNonEmptyMap',
        ];

        return array_diff($matches[1], $temporaryUnsupported);
    }

    private function createFile(): PhpFile
    {
        $file = new PhpFile();
        $file->addComment('Automatically generated');

        return $file;
    }

    private function createNamespace(PhpFile $file, ReflectionClass $class): PhpNamespace
    {
        $namespace = $file->addNamespace($class->getNamespaceName());
        $namespace->addUse(InvalidArgumentException::class);

        return $namespace;
    }

    private function createInterface(PhpNamespace $namespace): ClassType
    {
        return $namespace->addInterface('Mixin');
    }

    private function isPublicMethod(ReflectionMethod $method): bool
    {
        $modifiers = $method->getModifiers();

        return ($modifiers & ReflectionMethod::IS_PUBLIC) !== 0;
    }
}