PhpUnitGen\Parser\NodeParser\DocumentationNodeParser

Complexity

Total Complexity

55

Size/Duplication

Total Lines	351
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
B	consumeClosingParenthesisToken()	0	15	5
B	consumeOpeningParenthesisToken()	0	12	5
A	saveClassLikeAnnotation()	0	16	3
A	initialize()	0	5	1
C	parse()	0	38	12
A	saveAnnotations()	0	14	4
B	consumeQuoteToken()	0	11	5
A	addTokenToContent()	0	4	2
B	invoke()	0	37	5
A	__construct()	0	4	1
A	consumeAnnotationToken()	0	17	3
B	saveFunctionAnnotation()	0	14	5
A	reset()	0	8	1
A	afterConsume()	0	7	3

<?php

namespace PhpUnitGen\Parser\NodeParser;

use PhpParser\Comment\Doc;
use PhpUnitGen\Annotation\AbstractAnnotation;
use PhpUnitGen\Annotation\AnnotationFactory;
use PhpUnitGen\Annotation\AnnotationInterface\AnnotationInterface;
use PhpUnitGen\Annotation\Lexer;
use PhpUnitGen\Exception\AnnotationParseException;
use PhpUnitGen\Model\ModelInterface\FunctionModelInterface;
use PhpUnitGen\Model\PropertyInterface\ClassLikeInterface;
use PhpUnitGen\Model\PropertyInterface\DocumentationInterface;

/**
 * Class DocumentationNodeParser.
 *
 * @author     Paul Thébaud <paul.thebaud29@gmail.com>.
 * @copyright  2017-2018 Paul Thébaud <paul.thebaud29@gmail.com>.
 * @license    https://opensource.org/licenses/MIT The MIT license.
 * @link       https://github.com/paul-thebaud/phpunit-generator
 * @since      Class available since Release 2.0.0.
 */
class DocumentationNodeParser
{
    /**
     * @var Lexer $lexer The lexer to use.
     */
    private $lexer;

    /**
     * @var AnnotationFactory $annotationFactory The annotation factory to use.
     */
    private $annotationFactory;

    /**
     * @var AbstractAnnotation[] $parsedAnnotations The parsed annotation list.
     */
    private $parsedAnnotations;

    /**
     * @var int $currentLine The current line number.
     */
    private $currentLine;

    /**
     * @var AbstractAnnotation $currentAnnotation The current parsed annotation, null if none.
     */
    private $currentAnnotation;

    /**
     * @var string|null $currentAnnotationContent The current parsed annotation content, null if none.
     */
    private $currentAnnotationContent;

    /**
     * @var int|null $openedStringToken The opened string opening token identifier, null if no string opened.
     */
    private $openedStringToken;

    /**
     * @var bool $currentlyEscaping Tells if last parsed token was an escape token.
     */
    private $currentlyEscaping;

    /**
     * @var int $openedParenthesis The opened parenthesis number for an annotation content.
     */
    private $openedParenthesis;

    /**
     * DocumentationNodeParser constructor.
     *
     * @param Lexer             $lexer             The lexer to use.
     * @param AnnotationFactory $annotationFactory The annotation factory to use.
     */
    public function __construct(Lexer $lexer, AnnotationFactory $annotationFactory)
    {
        $this->lexer             = $lexer;
        $this->annotationFactory = $annotationFactory;
    }

    /**
     * Parse a node to update the parent node model.
     *
     * @param Doc                    $node   The node to parse.
     * @param DocumentationInterface $parent The parent node.
     *
     * @return DocumentationInterface The updated parent.
     *
     * @throws AnnotationParseException If an annotation is invalid.
     */
    public function invoke(Doc $node, DocumentationInterface $parent): DocumentationInterface
    {
        $documentation = $node->getText();
        $parent->setDocumentation($documentation);

        try {
            $this->initialize();

            $this->lexer->setInput($documentation);
            $this->lexer->moveNext();
            $this->lexer->moveNext();

            while ($this->lexer->token) {
                $this->parse(
                    $this->lexer->token['type'],
                    $this->lexer->token['value']
                );
                $this->lexer->moveNext();
                $this->lexer->moveNext();
            }

            if ($this->currentAnnotation !== null) {

The condition $this->currentAnnotation !== null can never be true.

                if ($this->currentAnnotationContent === null) {
                    $this->parsedAnnotations[] = $this->currentAnnotation;
                } else {
                    throw new AnnotationParseException(
                        'An annotation content is not closed (you probably forget to close a parenthesis or a quote)'
                    );
                }
            }

            $parent = $this->saveAnnotations($parent);
        } catch (AnnotationParseException $exception) {
            throw new AnnotationParseException($exception->getMessage());
        }

        return $parent;
    }

    /**
     * Initialize the documentation parsing process.
     */
    private function initialize(): void
    {
        $this->parsedAnnotations = [];
        $this->currentLine       = 0;
        $this->reset();
    }

    /**
     * Reset an annotation parsing.
     */
    private function reset(): void
    {
        $this->currentAnnotation        = null;
        $this->currentAnnotationContent = null;
        $this->openedStringToken        = null;
        $this->currentlyEscaping        = false;

        $this->openedParenthesis = 0;
    }

    /**
     * Parse a token with a value and type, and consume it depending on type.
     *
     * @param int    $type  The token type (an integer from the Lexer class constant).
     * @param string $value The token value.
     *
     * @throws AnnotationParseException If the token type is invalid.
     */
    private function parse(int $type, string $value): void
    {
        switch ($type) {
            case Lexer::T_ANNOTATION:
                $this->consumeAnnotationToken($value);
                break;
            case Lexer::T_O_PARENTHESIS:
                $this->consumeOpeningParenthesisToken();
                $this->addTokenToContent($value);
                break;
            case Lexer::T_C_PARENTHESIS:
                $this->addTokenToContent($value);
                $this->consumeClosingParenthesisToken();
                break;
            case Lexer::T_SINGLE_QUOTE:
            case Lexer::T_DOUBLE_QUOTE:
                $this->addTokenToContent($value);
                $this->consumeQuoteToken($type);
                break;
            case Lexer::T_ASTERISK:
                if ($this->openedStringToken !== null) {
                    // We are in a string, save this token value.
                    $this->addTokenToContent($value);
                }
                break;
            case Lexer::T_LINE_BREAK:
                $this->addTokenToContent($value);
                $this->currentLine++;
                break;
            case Lexer::T_BACKSLASH:
            case Lexer::T_WHITESPACE:
            case Lexer::T_OTHER:
                $this->addTokenToContent($value);
                break;
            default:
                throw new AnnotationParseException(sprintf('A token of value "%s" has an invalid type', $value));
        }
        $this->afterConsume($type);
    }

    /**
     * Add a token content to the current annotation content.
     *
     * @param string $value The token value to add.
     */
    private function addTokenToContent(string $value)
    {
        if ($this->currentAnnotationContent !== null) {
            $this->currentAnnotationContent .= $value;
        }
    }

    /**
     * Consume an annotation token ("@PhpUnitGen" for example).
     *
     * @param string $value The annotation token value.
     *
     * @throws AnnotationParseException If the annotation is unknown.
     */
    private function consumeAnnotationToken(string $value): void
    {
        if ($this->currentAnnotation === null) {
            // We are not in an annotation, build a new one.
            $this->currentAnnotation = $this->annotationFactory
                ->invoke($value, $this->currentLine);
        } else {
            if ($this->currentAnnotationContent === null) {
                // It is an annotation without content, save it and create the new one.
                $this->parsedAnnotations[] = $this->currentAnnotation;
                $this->reset();
                $this->currentAnnotation = $this->annotationFactory
                    ->invoke($value, $this->currentLine);
            } else {
                // An annotation content parsing is not finished.
                throw new AnnotationParseException(
                    'An annotation content is not closed (you probably forget to close a parenthesis or a quote)'
                );
            }
        }
    }

    /**
     * Consume an opening parenthesis token.
     */
    private function consumeOpeningParenthesisToken(): void
    {
        if ($this->currentAnnotation !== null && $this->openedStringToken === null) {
            // We are in an annotation but not in a string, lets do something.
            if ($this->currentAnnotationContent === null) {
                if ($this->currentAnnotation->getLine() === $this->currentLine) {
                    // Begin content parsing only if it is on the same line.
                    $this->currentAnnotationContent = '';
                    $this->openedParenthesis++;
                }
            } else {
                $this->openedParenthesis++;
            }
        }
    }

    /**
     * Consume an closing parenthesis token.
     */
    private function consumeClosingParenthesisToken(): void
    {
        if ($this->currentAnnotationContent !== null && $this->openedStringToken === null) {
            // We are in an annotation content and not in a string.
            if ($this->openedParenthesis > 0) {
                $this->openedParenthesis--;
                if ($this->openedParenthesis === 0) {
                    // Annotation content is finished.
                    $this->currentAnnotation->setStringContent(substr(
                        $this->currentAnnotationContent,
                        1,
                        strlen($this->currentAnnotationContent) - 2
                    ));
                    $this->parsedAnnotations[] = $this->currentAnnotation;
                    $this->reset();
                }
            }
        }
    }

    /**
     * Consume a quote token (" or ').
     */
    private function consumeQuoteToken(int $type): void
    {
        if ($this->currentAnnotationContent !== null) {
            if ($this->openedStringToken === null) {
                // It is a string opening.
                $this->openedStringToken = $type;
            } else {
                if (! $this->currentlyEscaping && $type === $this->openedStringToken) {
                    // We are in a string, the token is not escaped and is the same as the string opening token.
                    // Close the string.
                    $this->openedStringToken = null;
                }
            }
        }
    }

    /**
     * A method that is executed after consuming a token.
     *
     * @param int $type The token type (an integer from the Lexer class constant).
     */
    private function afterConsume(int $type): void
    {
        // Put in escaping mode if it were not escaping and there is a backslash token.
        if (! $this->currentlyEscaping && $type === Lexer::T_BACKSLASH) {
            $this->currentlyEscaping = true;
        } else {
            $this->currentlyEscaping = false;
        }
    }

    /**
     * Save each annotations in the parent depending on type.
     *
     * @param DocumentationInterface $parent The parent node.
     *
     * @return DocumentationInterface The updated parent.
     */
    private function saveAnnotations(DocumentationInterface $parent): DocumentationInterface
    {
        foreach ($this->parsedAnnotations as $annotation) {
            if ($parent instanceof FunctionModelInterface) {
                // Parent is a function, save assert and mock annotations.
                $parent = $this->saveFunctionAnnotation($parent, $annotation);
            }
            if ($parent instanceof ClassLikeInterface) {
                // Parent is a class like, save mock and constructor annotations.
                $parent = $this->saveClassLikeAnnotation($parent, $annotation);
            }
        }

        return $parent;
    }

    private function saveFunctionAnnotation(
        FunctionModelInterface $function,
        AnnotationInterface $annotation
    ): FunctionModelInterface {
        if ($annotation->getType() === AnnotationInterface::TYPE_ASSERT
            || $annotation->getType() === AnnotationInterface::TYPE_GETTER
            || $annotation->getType() === AnnotationInterface::TYPE_SETTER
            || $annotation->getType() === AnnotationInterface::TYPE_MOCK
        ) {
            $annotation->setParentNode($function);
            $function->addAnnotation($annotation);
            $annotation->compile();
        }
        return $function;
    }

    private function saveClassLikeAnnotation(
        ClassLikeInterface $classLike,
        AnnotationInterface $annotation
    ): ClassLikeInterface {
        if ($annotation->getType() === AnnotationInterface::TYPE_MOCK) {
            $parent = $classLike->getParentNode();
            $annotation->setParentNode($parent);
            $parent->addAnnotation($annotation);

The method addAnnotation() does not exist on PhpUnitGen\Model\PropertyInterface\NodeInterface. It seems like you code against a sub-type of PhpUnitGen\Model\PropertyInterface\NodeInterface such as PhpUnitGen\Model\ModelInterface\FunctionModelInterface or PhpUnitGen\Model\PropertyInterface\ClassLikeInterface or PhpUnitGen\Model\PropertyInterface\DocumentationInterface.

            $annotation->compile();
        }
        if ($annotation->getType() === AnnotationInterface::TYPE_CONSTRUCTOR) {
            $annotation->setParentNode($classLike);
            $classLike->addAnnotation($annotation);
            $annotation->compile();
        }
        return $classLike;
    }
}