Ubiquity\orm\parser\Reflexion

Complexity

Total Complexity

34

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Test Coverage

Coverage

90.59%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getMemberValue()	0	4	1
A	getMembersAnnotationWithAnnotation()	0	2	1
A	getJoinTables()	0	7	2
A	getMembersNameWithAnnotation()	0	2	1
A	getKeyFields()	0	2	1
A	getAnnotationsMember()	0	2	1
A	getMembersWithAnnotation_()	0	9	3
A	getMembersWithAnnotation()	0	2	1
A	getAllJoinTables()	0	6	2
A	getAnnotationClass()	0	3	1
A	getPropValue()	0	2	1
A	setMemberValue()	0	8	2
A	getAnnotationMember()	0	3	1
A	getTableName()	0	11	3
A	getMethods()	0	4	1
A	getAnnotationsMethod()	0	15	5
A	getMethodParameters()	0	6	2
A	getPropertiesAndValues()	0	16	5

<?php

namespace Ubiquity\orm\parser;

use mindplay\annotations\Annotations;
use Ubiquity\orm\OrmUtils;


/**
 * Reflection utilities
 * in dev environment only
 * @author jcheron <myaddressmail@gmail.com>
 * @version 1.0.1
 */
class Reflexion {
	use ReflexionFieldsTrait;

	public static function getMethods($instance, $filter=null) {
		$reflect=new \ReflectionClass($instance);
		$methods=$reflect->getMethods($filter);
		return $methods;
	}

	public static function getKeyFields($instance) {
		return self::getMembersNameWithAnnotation(get_class($instance), "@id");
	}

	public static function getMemberValue($instance, $member) {
		$prop=self::getProperty($instance, $member);
		$prop->setAccessible(true);
		return $prop->getValue($instance);
	}
	
	public static function getPropValue($instance, $prop) {
		return $prop->getValue($instance);
	}

	public static function setMemberValue($instance, $member,$value) {
		$prop=self::getProperty($instance, $member);
		if($prop){
			$prop->setAccessible(true);
			$prop->setValue($instance,$value);
			return true;
		}
		return false;
	}

	public static function getPropertiesAndValues($instance, $props=NULL) {
		$ret=array ();
		$className=get_class($instance);
		if (is_null($props))
			$props=self::getProperties($instance);
		foreach ( $props as $prop ) {
			$prop->setAccessible(true);
			$v=$prop->getValue($instance);
			if (OrmUtils::isSerializable($className, $prop->getName())) {
				if (OrmUtils::isNotNullOrNullAccepted($v, $className, $prop->getName())) {
					$name=OrmUtils::getFieldName($className, $prop->getName());
					$ret[$name]=$v;
				}
			}
		}
		return $ret;
	}

	public static function getAnnotationClass($class, $annotation) {
		$annot=Annotations::ofClass($class, $annotation);
		return $annot;
	}

	public static function getAnnotationMember($class, $member, $annotation) {
		$annot=Annotations::ofProperty($class, $member, $annotation);
		return current($annot);
	}
	
	public static function getAnnotationsMember($class, $member, $annotation) {
		return Annotations::ofProperty($class, $member, $annotation);
	}

	public static function getAnnotationsMethod($class, $method, $annotation) {
		if(is_array($annotation)){
			$result=[];
			foreach($annotation as $annot){
				$annots=Annotations::ofMethod($class, $method, $annot);
				if(sizeof($annots)>0){
					$result=array_merge($result,$annots);
				}
			}
			return $result;
		}
		$annots=Annotations::ofMethod($class, $method, $annotation);
		if (\sizeof($annots) > 0)
			return $annots;
		return false;
	}

	public static function getMembersAnnotationWithAnnotation($class, $annotation) {
		return self::getMembersWithAnnotation_($class, $annotation, function(&$ret,$prop,$annot){$ret[$prop->getName()]=$annot;});
	}

	public static function getMembersWithAnnotation($class, $annotation) {
		return self::getMembersWithAnnotation_($class, $annotation, function(&$ret,$prop){$ret[]=$prop;});
	}

	public static function getMembersNameWithAnnotation($class, $annotation) {
		return self::getMembersWithAnnotation_($class, $annotation, function(&$ret,$prop){ $ret[]=$prop->getName();});
	}
	
	protected static function getMembersWithAnnotation_($class, $annotation,$callback) {
		$props=self::getProperties($class);
		$ret=array ();
		foreach ( $props as $prop ) {
			$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
			if ($annot !== false)
				$callback($ret,$prop,$annot);
		}
		return $ret;
	}

	public static function getTableName($class) {
		$ret=Reflexion::getAnnotationClass($class, "@table");
		if (\sizeof($ret) === 0) {
			$posSlash=strrpos($class, '\\');
			if ($posSlash !== false)
				$class=substr($class, $posSlash + 1);
			$ret=$class;
		} else {
			$ret=$ret[0]->name;
		}
		return $ret;
	}

	public static function getMethodParameters(\ReflectionMethod $method) {
		$result=array ();
		foreach ( $method->getParameters() as $param ) {
			$result[]=$param->name;
		}
		return $result;
	}
	
	public static function getJoinTables($class){
		$result=[];
		$annots=self::getMembersAnnotationWithAnnotation($class, "@joinTable");
		foreach ($annots as $annot){
			$result[]=$annot->name;
		}
		return $result;
	}
	
	public static function getAllJoinTables($models){
		$result=[];
		foreach ($models as $model){
			$result=array_merge($result,self::getJoinTables($model));
		}
		return $result;
	}
}