gossi\codegen\parser\visitor\AbstractPhpStructVisitor

Complexity

Total Complexity

49

Size/Duplication

Total Lines	247
Duplicated Lines	4.05 %

Coupling/Cohesion

Components	1
Dependencies	25

Test Coverage

Coverage

99.39%

Importance

Changes	2
Bugs	1	Features	1

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getStruct()	0	3	1
D	enterNode()	0	45	10
A	visitStruct()	0	10	2
A	visitClass()	0	1	1
A	visitInterface()	0	1	1
A	visitTrait()	0	1	1
A	visitTraitUse()	0	5	2
A	visitConstants()	0	6	2
A	visitConstant()	0	8	1
A	visitProperty()	0	3	1
A	visitNamespace()	0	5	2
A	visitUseStatement()	0	6	2
C	visitMethod()	10	63	10
A	getProperty()	0	17	2
A	parseMemberDocblock()	0	14	3
A	getValue()	0	14	4
A	getVisibility()	0	11	3

<?php
namespace gossi\codegen\parser\visitor;

use gossi\codegen\model\AbstractPhpMember;
use gossi\codegen\model\AbstractPhpStruct;
use gossi\codegen\model\PhpConstant;
use gossi\codegen\model\PhpMethod;
use gossi\codegen\model\PhpParameter;
use gossi\codegen\model\PhpProperty;
use PhpParser\Node;
use PhpParser\Node\Const_;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Name;
use PhpParser\Node\Param;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\TraitUse;
use PhpParser\Node\Stmt\UseUse;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use PhpParser\PrettyPrinter\Standard;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Trait_;
use PhpParser\Node\Stmt\ClassConst;
use PhpParser\Comment\Doc;
use gossi\docblock\tags\ParamTag;

abstract class AbstractPhpStructVisitor extends NodeVisitorAbstract {
	
	private $constMap = [
		'false' => false,
		'true' => true
	];
	
	protected $struct;
	
	public function __construct(AbstractPhpStruct $struct) {
		$this->struct = $struct;
	}
	
	/**
	 * @return AbstractPhpStruct
	 */
	public function getStruct() {
		return $this->struct;
	}
	
	public function enterNode(Node $node) {
		switch ($node->getType()) {
			case 'Stmt_Namespace':
				$this->visitNamespace($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\Namespace_>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_UseUse':
				$this->visitUseStatement($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\UseUse>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_Class':
				$this->visitStruct($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\ClassLike>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				$this->visitClass($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\Class_>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_Interface':
				$this->visitStruct($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\ClassLike>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				$this->visitInterface($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\Interface_>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_Trait':
				$this->visitStruct($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\ClassLike>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				$this->visitTrait($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\Trait_>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_TraitUse':
				$this->visitTraitUse($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\TraitUse>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_ClassConst':
				$this->visitConstants($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\ClassConst>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_Property':
				$this->visitProperty($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\Property>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
				
			case 'Stmt_ClassMethod':
				$this->visitMethod($node);

$node of type object<PhpParser\Node> is not a sub-type of object<PhpParser\Node\Stmt\ClassMethod>. It seems like you assume a concrete implementation of the interface PhpParser\Node to be always present.

				break;
		}
// 		echo $node->getType() . "\n";

54% of this comment could be valid code. Did you maybe forget this after debugging?

		
// 		return NodeTraverser::DONT_TRAVERSE_CHILDREN;

43% of this comment could be valid code. Did you maybe forget this after debugging?

	}
	
	protected function visitStruct(ClassLike $node) {
		$this->struct->setName($node->name);
	
		if (($doc = $node->getDocComment()) !== null) {
			$this->struct->setDocblock($doc->getReformattedText());
			$docblock = $this->struct->getDocblock();
			$this->struct->setDescription($docblock->getShortDescription());
			$this->struct->setLongDescription($docblock->getLongDescription());
		}
	}
	
	protected function visitClass(Class_ $node) {}
	
	protected function visitInterface(Interface_ $node) {}
	
	protected function visitTrait(Trait_ $node) {}

The parameter $node is not used and could be removed.

	
	protected function visitTraitUse(TraitUse $node) {
		foreach ($node->traits as $trait) {
			$this->struct->addTrait(implode('\\', $trait->parts));

It seems like you code against a specific sub-type and not the parent class gossi\codegen\model\AbstractPhpStruct as the method addTrait() does only exist in the following sub-classes of gossi\codegen\model\AbstractPhpStruct: gossi\codegen\model\PhpClass, gossi\codegen\model\PhpTrait. Maybe you want to instanceof check for one of these explicitly?

		}
	}
	
	protected function visitConstants(ClassConst $node) {
		$doc = $node->getDocComment();
		foreach ($node->consts as $const) {
			$this->visitConstant($const, $doc);
		}
	}
	
	protected function visitConstant(Const_ $node, Doc $doc = null) {
		$const = new PhpConstant($node->name, $this->getValue($node));
		$const->setValue($this->getValue($node->value));

		$this->parseMemberDocblock($const, $doc);
		
		$this->struct->setConstant($const);

It seems like you code against a specific sub-type and not the parent class gossi\codegen\model\AbstractPhpStruct as the method setConstant() does only exist in the following sub-classes of gossi\codegen\model\AbstractPhpStruct: gossi\codegen\model\PhpClass, gossi\codegen\model\PhpInterface. Maybe you want to instanceof check for one of these explicitly?

	}
	
	protected function visitProperty(Property $node) {
		$this->struct->setProperty($this->getProperty($node));

It seems like you code against a specific sub-type and not the parent class gossi\codegen\model\AbstractPhpStruct as the method setProperty() does only exist in the following sub-classes of gossi\codegen\model\AbstractPhpStruct: gossi\codegen\model\PhpClass, gossi\codegen\model\PhpTrait. Maybe you want to instanceof check for one of these explicitly?

	}
	
	protected function visitNamespace(Namespace_ $node) {
		if ($node->name !== null) {
			$this->struct->setNamespace(implode('\\', $node->name->parts));
		}
	}

	protected function visitUseStatement(UseUse $node) {
		$name = implode('\\', $node->name->parts);

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

		$alias = !empty($node->alias) ? $node->alias : null;
		
		$this->struct->addUseStatement($name, $alias);
	}
	
	protected function visitMethod(ClassMethod $node) {
		$m = new PhpMethod($node->name);
		$m->setAbstract($node->isAbstract());
		$m->setFinal($node->isFinal());
		$m->setVisibility($this->getVisibility($node));
		$m->setStatic($node->isStatic());
		$m->setReferenceReturned($node->returnsByRef());
		
		// docblock
		if (($doc = $node->getDocComment()) !== null) {

This code seems to be duplicated across your project.

			$m->setDocblock($doc->getReformattedText());
			$docblock = $m->getDocblock();
			$m->setDescription($docblock->getShortDescription());
			$m->setLongDescription($docblock->getLongDescription());
		}
		
		// params
		$params = $m->getDocblock()->getTags('param');
		foreach ($node->params as $param) {
			/* @var $param Param */
			
			$p = new PhpParameter();
			$p->setName($param->name);
			$p->setPassedByReference($param->byRef);
			
			if (is_string($param->type)) {
				$p->setType($param->type);
			} else if ($param->type instanceof Name) {
				$p->setType(implode('\\', $param->type->parts));
			}

			$default = $param->default;
			if ($default !== null) {
				$p->setDefaultValue($this->getValue($default));
			}
			
			$tag = $params->find($p, function (ParamTag $t, $p) {
				return $t->getVariable() == '$' . $p->getName();
			});
			
			if ($tag !== null) {
				$p->setType($tag->getType(), $tag->getDescription());
			}
			
			$m->addParameter($p);
		}
		
		// return type and description
		$returns = $m->getDocblock()->getTags('return');
		if ($returns->size() > 0) {

This code seems to be duplicated across your project.

			$return = $returns->get(0);
			$m->setType($return->getType(), $return->getDescription());
		}
		
		// body
		$stmts = $node->getStmts();
		if (is_array($stmts) && count($stmts)) {
			$prettyPrinter = new Standard();
			$m->setBody($prettyPrinter->prettyPrint($stmts));
		}

		$this->struct->setMethod($m);
	}
	
	protected function getProperty(Property $node) {
		$prop = $node->props[0];

		$p = new PhpProperty($prop->name);
	
		$default = $prop->default;
		if ($default !== null) {
			$p->setDefaultValue($this->getValue($default));
		}
	
		$p->setStatic($node->isStatic());
		$p->setVisibility($this->getVisibility($node));
		
		$this->parseMemberDocblock($p, $node->getDocComment());
	
		return $p;
	}
	
	private function parseMemberDocblock($member, Doc $doc = null) {
		if ($doc !== null) {
			$member->setDocblock($doc->getReformattedText());
			$docblock = $member->getDocblock();
			$member->setDescription($docblock->getShortDescription());
			$member->setLongDescription($docblock->getLongDescription());
	
			$vars = $docblock->getTags('var');
			if ($vars->size() > 0) {
				$var = $vars->get(0);
				$member->setType($var->getType(), $var->getDescription());
			}
		}
	}
	
	private function getValue(Node $node) {

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

		if ($node instanceof ConstFetch) {
			$const = $node->name->parts[0];
			if (isset($this->constMap[$const])) {
				return $this->constMap[$const];
			}
			
			return $const;
		}
		
		if ($node instanceof String_) {
			return $node->value;
		}
	}
	
	private function getVisibility(Node $node) {

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

		if ($node->isPrivate()) {

It seems like you code against a concrete implementation and not the interface PhpParser\Node as the method isPrivate() does only exist in the following implementations of said interface: PhpParser\Node\Stmt\ClassMethod, PhpParser\Node\Stmt\Property.

			return AbstractPhpMember::VISIBILITY_PRIVATE;
		}
		
		if ($node->isProtected()) {

It seems like you code against a concrete implementation and not the interface PhpParser\Node as the method isProtected() does only exist in the following implementations of said interface: PhpParser\Node\Stmt\ClassMethod, PhpParser\Node\Stmt\Property.

			return AbstractPhpMember::VISIBILITY_PROTECTED;
		}
		
		return AbstractPhpMember::VISIBILITY_PUBLIC;
	}
	
}