AbstractPhpStructVisitor::__construct() - Code Metrics - Inspection of "Bugfix for parsing default values/expression" - gossi/php-code-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3afdd0...9086d9 )

by Thomas

created 2016-06-16 17:50 UTC

AbstractPhpStructVisitor::__construct() A

↳ Parent: AbstractPhpStructVisitor

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	3
ccs	3
cts	3
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?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 gossi\docblock\tags\ParamTag;
use PhpParser\Comment\Doc;
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\Class_;
use PhpParser\Node\Stmt\ClassConst;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\Trait_;
use PhpParser\Node\Stmt\TraitUse;
use PhpParser\Node\Stmt\UseUse;
use PhpParser\NodeVisitorAbstract;
use PhpParser\PrettyPrinter\Standard;

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);

				break;

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

				break;

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

				$this->visitClass($node);

				break;

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

				$this->visitInterface($node);

				break;

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

				$this->visitTrait($node);

				break;

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

				break;

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

				break;

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

				break;

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

				break;
		}
	}

	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) {}


	protected function visitTraitUse(TraitUse $node) {
		foreach ($node->traits as $trait) {
			$this->struct->addTrait(implode('\\', $trait->parts));
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
		}
	}

	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);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}

	protected function visitProperty(Property $node) {
		$this->struct->setProperty($this->getProperty($node));
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}

	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);
		$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) {
			$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) {
				$this->setDefault($p, $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) {
			$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) {
			$this->setDefault($p, $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 setDefault($obj, $default) {
		if ($default instanceof String_) {
			$obj->setValue($this->getValue($default));
		} else {
			$obj->setExpression($this->getValue($default));
		}
	}

	/**
	 * Returns the value from a node
	 *
	 * @param Node $node
	 * @return mixed
	 */
	private function getValue(Node $node) {
		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;
		}
	}

	/**
	 * Returns the visibility from a node
	 *
	 * @param Node $node
	 * @return string
	 */
	private function getVisibility(Node $node) {
		if ($node->isPrivate()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
			return AbstractPhpMember::VISIBILITY_PRIVATE;
		}

		if ($node->isProtected()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
			return AbstractPhpMember::VISIBILITY_PROTECTED;
		}

		return AbstractPhpMember::VISIBILITY_PUBLIC;
	}

}


Push — master ( 3afdd0...9086d9 )

AbstractPhpStructVisitor::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1		<?php
2		namespace gossi\codegen\parser\visitor;
3
4		use gossi\codegen\model\AbstractPhpMember;
5		use gossi\codegen\model\AbstractPhpStruct;
6		use gossi\codegen\model\PhpConstant;
7		use gossi\codegen\model\PhpMethod;
8		use gossi\codegen\model\PhpParameter;
9		use gossi\codegen\model\PhpProperty;
10		use gossi\docblock\tags\ParamTag;
11		use PhpParser\Comment\Doc;
12		use PhpParser\Node;
13		use PhpParser\Node\Const_;
14		use PhpParser\Node\Expr\ConstFetch;
15		use PhpParser\Node\Name;
16		use PhpParser\Node\Param;
17		use PhpParser\Node\Scalar\String_;
18		use PhpParser\Node\Stmt\Class_;
19		use PhpParser\Node\Stmt\ClassConst;
20		use PhpParser\Node\Stmt\ClassLike;
21		use PhpParser\Node\Stmt\ClassMethod;
22		use PhpParser\Node\Stmt\Interface_;
23		use PhpParser\Node\Stmt\Namespace_;
24		use PhpParser\Node\Stmt\Property;
25		use PhpParser\Node\Stmt\Trait_;
26		use PhpParser\Node\Stmt\TraitUse;
27		use PhpParser\Node\Stmt\UseUse;
28		use PhpParser\NodeVisitorAbstract;
29		use PhpParser\PrettyPrinter\Standard;
30
31		abstract class AbstractPhpStructVisitor extends NodeVisitorAbstract {
32
33		private $constMap = [
34		'false' => false,
35		'true' => true
36		];
37
38		protected $struct;
39
40	7	public function __construct(AbstractPhpStruct $struct) {

gossi / php-code-generator

Push — master ( 3afdd0...9086d9 )

AbstractPhpStructVisitor::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like