Ubiquity\utils\yuml\ClassToYuml

Complexity

Total Complexity

47

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	6	3
A	__construct()	0	8	1
A	__toString()	0	7	2
A	parseMethod()	0	11	3
A	setDisplayMethods()	0	3	1
A	getAccess()	0	8	3
A	oneToManyTostring()	0	3	1
B	parse()	0	41	9
A	getShortClassName()	0	3	1
A	parseProperty()	0	12	4
A	setDisplayProperties()	0	3	1
A	_getYumlManyToOne()	0	2	1
A	loadOneToManys()	0	5	3
A	manyToOneTostring()	0	3	1
A	_getNote()	0	2	1
A	getMethodParameters()	0	11	3
A	loadManyToOne()	0	8	5
A	_getYumlOneToMany()	0	2	1
A	_getYumlRelationsType()	0	7	2
A	setDisplayAssociations()	0	3	1

<?php

namespace Ubiquity\utils\yuml;

use Ubiquity\orm\OrmUtils;

/**
 * @author jc
 * yuml export tool for class
 */
class ClassToYuml {
	protected $class;
	protected $displayProperties=true;
	protected $displayMethods=false;
	protected $displayMethodsParams=false;
	protected $displayPropertiesTypes=false;
	protected $displayAssociations;
	protected $displayAssociationClassProperties=false;
	protected $displayForeignKeys=true;
	protected $properties;
	protected $oneToManys=[];
	protected $manyToOne=[];
	protected $parseResult;
	protected $note;

	public function __construct($class,$displayProperties=true,$displayAssociations=true,$displayMethods=false,$displayMethodsParams=false,$displayPropertiesTypes=false,$displayAssociationClassProperties=false){
		$this->class=$class;
		$this->displayProperties=$displayProperties;
		$this->displayAssociations=$displayAssociations;
		$this->displayMethods=$displayMethods;
		$this->displayMethodsParams=$displayMethodsParams;
		$this->displayPropertiesTypes=$displayPropertiesTypes;
		$this->displayAssociationClassProperties=$displayAssociationClassProperties;
	}

	public function init($hasManyToOne,$hasOneToMany){
		if($hasManyToOne){
			$this->loadManyToOne();
		}
		if($hasOneToMany){
			$this->loadOneToManys();
		}
	}

	public function parse(){
		$reflect=new \ReflectionClass($this->class);
		$yumlAnnot=OrmUtils::getAnnotationInfo($this->class, "#yuml");
		$color="";
		if ($yumlAnnot!==false){
			if(isset($yumlAnnot["color"])){
				$color="{bg:".$yumlAnnot["color"]."}";
			}
			if(isset($yumlAnnot["note"])){
				$this->note=$yumlAnnot["note"];
			}
		}
		$parts=[$reflect->getShortName()];
		
		if($this->displayProperties){
			$prikeys=OrmUtils::getKeyFields($this->class);
			$types=OrmUtils::getFieldTypes($this->class);
			$propertiesArray=[];
			$properties=$reflect->getProperties();
			foreach ($properties as $property){
				$this->parseProperty($propertiesArray, $property, $prikeys, $types);
			}
			$parts[]=\implode(Yuml::$memberSeparator, $propertiesArray);
		}

		if($this->displayMethods){
			$methodsArray=[];
			$methods=$reflect->getMethods();
			foreach ($methods as $method){
				$this->parseMethod($methodsArray, $method);
			}
			$parts[]=\implode(Yuml::$memberSeparator, $methodsArray);
		}

		$result=\implode(Yuml::$classSeparator, $parts).$color;
		$result=Yuml::setClassContent($result);
		if(isset($this->note)){
			$result.=$this->_getNote();
		}
		$this->parseResult=$result;
		return $result;
	}
	
	protected function parseProperty(&$propertiesArray,$property,$prikeys,$types){
		$propertyName=$property->getName();
		$type="";$isPri="";
		if($this->displayPropertiesTypes){
			if(\array_key_exists($propertyName, $types)){
				$type=Yuml::$parameterTypeSeparator.$types[$propertyName];
			}
		}
		if(\array_search($propertyName, $prikeys)!==false){
			$isPri=Yuml::$primary;
		}
		$propertiesArray[]=Yuml::setPropertyVariables([$this->getAccess($property),$isPri,$propertyName,$type]);
	}
	
	protected function parseMethod(&$methodsArray,$method){
		$parameters="";
		if($this->displayMethodsParams){
			$parameters=$this->getMethodParameters($method);
		}
		$methodName=$method->getName();
		$type="";
		if($method->hasReturnType()){
			$type=Yuml::$parameterTypeSeparator.$method->getReturnType();
		}
		$methodsArray[]=Yuml::setMethodVariables([$this->getAccess($method),$methodName,$parameters,$type]);
	}

	protected function getShortClassName($class){
		$reflect=new \ReflectionClass($class);
		return $reflect->getShortName();
	}

	protected function loadOneToManys(){
		$oneToManys=OrmUtils::getAnnotationInfo($this->class, "#oneToMany");
		if($oneToManys){
			foreach ($oneToManys as $member=>$array){
				$this->oneToManys[$member]=$array["className"];
			}
		}
	}

	protected function loadManyToOne(){
		$manyToOne=OrmUtils::getAnnotationInfo($this->class, "#manyToOne");
		if($manyToOne){
			foreach ($manyToOne as $member){
				$joinColumn=OrmUtils::getAnnotationInfoMember($this->class, "#joinColumn", $member);
				if($joinColumn){
					if(isset($joinColumn["className"])){
						$this->manyToOne[$member]=$joinColumn["className"];
					}
				}
			}
		}
	}

	protected function _getYumlManyToOne(){
		return $this->_getYumlRelationsType($this->manyToOne,"0..*-1");
	}

	protected function _getYumlOneToMany(){
		return $this->_getYumlRelationsType($this->oneToManys,"1-0..*");
	}

	protected function _getYumlRelationsType($relations,$branche){
		$myClass=$this->getShortClassName($this->class);
		$yumlRelations=[];
		foreach ($relations as $model){
			$yumlRelations[]=Yuml::setClassContent($myClass).$branche.new ClassToYuml($model,$this->displayAssociationClassProperties,false);
		}
		return $yumlRelations;
	}

	protected function _getNote(){
		return "-[note:".$this->note."]";
	}

	protected function getMethodParameters(\ReflectionMethod $method){
		$paramsValues=[];
		$parameters=$method->getParameters();
		foreach ($parameters as $parameter){
			$v=$parameter->getName();
			if($parameter->hasType()){
				$v.=Yuml::$parameterTypeSeparator.$parameter->getType();
			}
			$paramsValues[]=$v;
		}
		return \implode(Yuml::$parameterSeparator, $paramsValues);
	}

	protected function getAccess($property){
		$result=Yuml::$private;
		if($property->isPublic()){
			$result=Yuml::$public;
		}elseif($property->isProtected()){
			$result=Yuml::$protected;
		}
		return $result;
	}

	public function manyToOneTostring(){
		$this->loadManyToOne();
		return \implode(Yuml::$groupeSeparator, $this->_getYumlManyToOne());
	}

	public function oneToManyTostring(){
		$this->loadOneToManys();
		return \implode(Yuml::$groupeSeparator, $this->_getYumlOneToMany());
	}

	public function __toString(){
		$result=[$this->parse()];
		if($this->displayAssociations){
			$result=\array_merge($result,$this->_getYumlManyToOne());
			$result=\array_merge($result,$this->_getYumlOneToMany());
		}
		return \implode(Yuml::$groupeSeparator, $result);
	}


	public function setDisplayProperties($displayProperties) {
		$this->displayProperties=$displayProperties;
		return $this;
	}

	public function setDisplayMethods($displayMethods) {
		$this->displayMethods=$displayMethods;
		return $this;
	}

	public function setDisplayAssociations($displayAssociations) {
		$this->displayAssociations=$displayAssociations;
		return $this;
	}
}