Leaditin\Code\Generator\MethodGenerator

Complexity

Total Complexity

21

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
C	generate()	0	51	11
B	generateDocBlock()	0	26	7
A	generateTagFromArgument()	0	13	2

<?php

namespace Leaditin\Code\Generator;

use Leaditin\Code\Argument;
use Leaditin\Code\DocBlock;
use Leaditin\Code\Member\Method;
use Leaditin\Code\Tag;

/**
 * @package Leaditin\Code
 * @author Igor Vuckovic <igor@vuckovic.biz>
 * @license MIT
 */
class MethodGenerator extends MemberGenerator
{
    /**
     * @var ArgumentGenerator
     */
    protected $argumentGenerator;

    /**
     * @param ArgumentGenerator $argumentGenerator
     * @param DocBlockGenerator $docBlockGenerator
     * @param TypeGenerator $typeGenerator
     * @param VisibilityGenerator $visibilityGenerator
     */
    public function __construct(
        ArgumentGenerator $argumentGenerator,
        DocBlockGenerator $docBlockGenerator,
        TypeGenerator $typeGenerator,
        VisibilityGenerator $visibilityGenerator
    ) {
        parent::__construct($docBlockGenerator, $typeGenerator, $visibilityGenerator);

        $this->argumentGenerator = $argumentGenerator;
    }

    /**
     * @param Method $method
     *
     * @return string
     */
    public function generate(Method $method): string
    {
        $output = $this->generateLine($this->docBlockGenerator->generate($this->generateDocBlock($method)), 0);

        $line = '';
        if ($method->isAbstract()) {
            $line .= 'abstract ';
        } elseif ($method->isFinal()) {
            $line .= 'final ';
        }

        $line .= $this->visibilityGenerator->generate($method->visibility());

        if ($method->isStatic()) {
            $line .= ' static';
        }

        $line .= ' function ' . $method->name() . '(';

        $arguments = [];
        foreach ($method->arguments() as $argument) {
            $arguments[] = $this->argumentGenerator->generate($argument);
        }
        $line .= implode(', ', $arguments);

        $line .= ')';

        if ($method->returnType() !== null) {
            $line .= ': ' . $this->typeGenerator->generate($method->returnType());
        }

        if ($method->isAbstract() || $method->scope() === Method::SCOPE_INTERFACE) {
            $output .= $this->generateLine($line . ';');

            return rtrim($output, static::END_OF_LINE);
        }

        $output .= $this->generateLine($line);
        $output .= $this->generateLine('{');

        if ($method->body() !== null) {
            foreach (explode(PHP_EOL, trim($method->body())) as $line) {
                $line = preg_replace('#^((?![a-zA-Z0-9_-]+;).+?)$#m', '$1', $line);
                $output .= $this->generateLine($line, $line === '' ? 0 : 2);
            }
        }

        $output .= $this->generateLine('}');

        return rtrim($output, static::END_OF_LINE);
    }

    /**
     * @param Method $method
     *
     * @return DocBlock
     */
    protected function generateDocBlock(Method $method): DocBlock
    {
        $docblock = '';
        $shortDescription = null;
        $longDescription = null;
        $tags = [];

        if ($method->docBlock() !== null) {
            $docblock = $this->docBlockGenerator->generate($method->docBlock());
            $shortDescription = $method->docBlock()->shortDescription();
            $longDescription = $method->docBlock()->longDescription();
            $tags = $method->docBlock()->tags();
        }

        foreach ($method->arguments() as $argument) {
            if (($tag = $this->generateTagFromArgument($argument, $docblock)) !== null) {
                $tags[] = $tag;
            }
        }

        if ($method->returnType() !== null && strpos($docblock, '@return') === false) {
            $tags[] = new Tag('return', ($method->returnType()->isNullable() ? 'null|' : '') . $method->returnType()->type());
        }

        return new DocBlock($shortDescription, $longDescription, $tags);
    }

    /**
     * @param Argument $argument
     * @param string $docBlock
     *
     * @return null|Tag
     */
    protected function generateTagFromArgument(Argument $argument, string $docBlock): ?Tag
    {
        $pattern = '/@param.+\$' . $argument->name() . '/';

        if (preg_match($pattern, $docBlock)) {
            return null;
        }

        $value = preg_replace('/\?(\w+)/', 'null|$1', $this->typeGenerator->generate($argument->type()));
        $value .= ' $' . $argument->name();

        return new Tag('param', $value);
    }
}