gossi\codegen\parser\visitor\parts\ValueParserPart

Complexity

Total Complexity

23

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.65%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	parseValue()	0	10	4
B	isPrimitive()	0	7	5
A	getPrimitiveValue()	0	11	3
A	isBool()	0	10	3
A	isNull()	0	6	2
B	getExpression()	0	23	6

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

use gossi\codegen\model\ValueInterface;
use gossi\codegen\parser\PrettyPrinter;
use PhpParser\Node;
use PhpParser\Node\Const_;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Scalar\DNumber;
use PhpParser\Node\Scalar\LNumber;
use PhpParser\Node\Scalar\MagicConst;
use PhpParser\Node\Scalar\String_;

trait ValueParserPart {
	
	private $constMap = [
		'false' => false,
		'true' => true
	];
	
	/**
	 * Parses the value of a node into the model
	 * 
	 * @param ValueInterface $obj
	 * @param Node $node
	 * @return void
	 */
	private function parseValue(ValueInterface $obj, Node $node) {
		$value = $node instanceof Const_ ? $node->value : $node->default;
		if ($value !== null) {
			if ($this->isPrimitive($value)) {
				$obj->setValue($this->getPrimitiveValue($value));
			} else {
				$obj->setExpression($this->getExpression($value));
			}
		}
	}
	
	/**
	 * Returns whether this node is a primitive value
	 * 
	 * @param Node $node
	 * @return boolean
	 */
	private function isPrimitive(Node $node) {
		return $node instanceof String_
			|| $node instanceof LNumber
			|| $node instanceof DNumber
			|| $this->isBool($node)
			|| $this->isNull($node);
	}
	
	/**
	 * Returns the primitive value
	 * 
	 * @param Node $node
	 * @return mixed
	 */
	private function getPrimitiveValue(Node $node) {
		if ($this->isBool($node)) {
			return (bool) $this->getExpression($node);
		}
	
		if ($this->isNull($node)) {
			return null;
		}
	
		return $node->value;

Accessing value on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

	}
	
	/**
	 * Returns whether this node is a boolean value
	 * 
	 * @param Node $node
	 * @return boolean
	 */
	private function isBool(Node $node) {
		if ($node instanceof ConstFetch) {
			$const = $node->name->parts[0];
			if (isset($this->constMap[$const])) {
				return is_bool($this->constMap[$const]);
			}
	
			return is_bool($const);
		}
	}
	
	/**
	 * Returns whether this node is a null value
	 * 
	 * @param Node $node
	 * @return boolean
	 */
	private function isNull(Node $node) {
		if ($node instanceof ConstFetch) {
			$const = $node->name->parts[0];
			return $const === 'null';
		}
	}
	
	/**
	 * Returns the value from a node
	 *
	 * @param Node $node
	 * @return mixed
	 */
	private function getExpression(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 ClassConstFetch) {
			return $node->class->parts[0] . '::' . $node->name;
		}
	
		if ($node instanceof MagicConst) {
			return $node->getName();
		}
		
		if ($node instanceof Array_) {
			$prettyPrinter = new PrettyPrinter();
			return $prettyPrinter->prettyPrintExpr($node);
		}
	}
}