Padawan\Parser\MethodParser

Complexity

Total Complexity

9

Size/Duplication

Total Lines	65
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	10	10	1
C	parse()	31	31	7
A	parseMethodArgument()	3	3	1

<?php

namespace Padawan\Parser;

use Padawan\Domain\Project\Node\MethodData;
use Padawan\Domain\Project\Node\MethodParam;
use Padawan\Domain\Project\Node\Comment;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Param;
use PhpParser\Node\Name;

class MethodParser {

This class seems to be duplicated in your project.

    /**
     * Constructs
     *
     * @param UseParser $useParser
     */
    public function __construct(
        UseParser $useParser,
        CommentParser $commentParser,
        ParamParser $paramParser
    )
    {
        $this->useParser        = $useParser;
        $this->commentParser    = $commentParser;
        $this->paramParser      = $paramParser;
    }

    /**
     * Parses ClassMethod node to MethodData
     *
     * @return MethodData
     */
    public function parse(ClassMethod $node)
    {
        $method = new MethodData($node->name);
        $method->startLine = $node->getAttribute("startLine");
        $method->endLine = $node->getAttribute("endLine");
        $method->setType($node->type);
        $comments = $node->getAttribute("comments");
        if (is_array($comments)) {
            /** @var Comment */
            $comment = $this->commentParser->parse(
                $comments[count($comments) - 1]->getText()
            );
            if ($comment->isInheritDoc()) {
                $method->doc = Comment::INHERIT_MARK;
            } else {
                $method->doc = $comment->getDoc();
                $method->return = $comment->getReturn();
                foreach ($comment->getVars() as $var) {
                    if ($var instanceof MethodParam) {
                        $method->addParam($var);
                    }
                }
            }
        }
        foreach ($node->params AS $child) {
            if ($child instanceof Param) {
                $method->addParam($this->parseMethodArgument($child));
            }
        }
        return $method;
    }
    protected function parseMethodArgument(Param $node) {
        return $this->paramParser->parse($node);
    }

    /** @var UseParser $useParser */
    private $useParser;
    /** @property CommentParser $commentParser */
    private $commentParser;
    /** @var ParamParser */
    private $paramParser;
}