webmozart / assert

generate.php

<?php

use Nette\PhpGenerator\ClassType;
use Nette\PhpGenerator\PsrPrinter;
use Psalm\DocComment;
use Psalm\Internal\Analyzer\CommentAnalyzer;
use Webmozart\Assert\Assert;

require_once __DIR__ . '/vendor/autoload.php';

$g = new ExtraGenerator();
$g->generate();

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

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

        $file = $this->createFile();
        $namespace = $this->createNamespace($file, $class);
        $newClass = $this->createClass($namespace);

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

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

        $printer = new PsrPrinter();

        $fp = fopen(__DIR__ . '/src/Extra.php', 'wb');

        fwrite($fp, $printer->printFile($file));

        fclose($fp);
    }

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

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

        $comment = $method->getDocComment();

        $p = DocComment::parse($comment);

        if (!in_array('psalm-assert', array_keys($p['specials']))) {
            return;
        }

        $newMethod = $newClass->addMethod($newMethodName)
            ->setStatic()
        ;

        $parameters = $method->getParameters();

        $parametersCall = [];
        foreach ($parameters as $parameter) {
            $newParameter = $newMethod->addParameter($parameter->name);

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

            $parametersCall[] = sprintf('$%s', $parameter->name);
        }

        $newMethod->addBody(sprintf('parent::%s(%s);', $newMethodName, implode(', ', $parametersCall)));

        foreach ($p['specials'] as $key => $values) {
            foreach ($values as $value) {
                $parts = CommentAnalyzer::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)));
                }

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

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

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

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

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

        $temporaryUnsupported = [
            'nullOrNotInstanceOf',
            'allNotInstanceOf',
            'nullOrNotEmpty',
            'allNotEmpty',
            'allNotNull',
            'nullOrSame',
            'allSame',
            'nullOrUnicodeLetters',
            'allUnicodeLetters',
        ];

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

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

        return $file;
    }

    private function createNamespace(\Nette\PhpGenerator\PhpFile $file, ReflectionClass $class)
    {
        return $file->addNamespace($class->getNamespaceName());
    }

    private function createClass(\Nette\PhpGenerator\PhpNamespace $namespace)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $namespace->addClass('Extra')
            ->setExtends(Assert::class);
    }

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

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