Ubiquity\orm\parser\Reflexion

Complexity

Total Complexity

56

Size/Duplication

Total Lines	210
Duplicated Lines	0 %

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	getMemberValue()	0	4	1
A	getKeyFields()	0	2	1
A	getMethods()	0	4	1
A	setMemberValue()	0	8	2
A	getProperty()	0	6	2
A	getProperties()	0	7	2
A	getMembersAnnotationWithAnnotation()	0	9	3
A	getJoinTables()	0	7	2
A	getAnnotationsMethod()	0	15	5
A	getMembersNameWithAnnotation()	0	9	3
A	getAnnotationsMember()	0	2	1
A	getPropertiesAndValues()	0	16	5
A	getPropertyType()	0	2	1
A	getMembersWithAnnotation()	0	9	3
A	getFieldName()	0	7	3
A	getAllJoinTables()	0	6	2
A	getMetadata()	0	6	2
A	getAnnotationClass()	0	3	1
A	getMethodParameters()	0	6	2
A	isSerializable()	0	5	5
A	getAnnotationMember()	0	5	2
A	getDbType()	0	6	2
A	getTableName()	0	11	3
A	isNullable()	0	6	2

<?php

namespace Ubiquity\orm\parser;

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

/**
 * Utilitaires de Reflexion
 * @author jc
 * @version 1.0.0.2
 */
class Reflexion {

	public static function getProperties($instance) {
		if (\is_string($instance)) {
			$instance=new $instance();
		}
		$reflect=new \ReflectionClass($instance);
		$props=$reflect->getProperties();
		return $props;
	}

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

	public static function getKeyFields($instance) {
		return Reflexion::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 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 getProperty($instance, $member) {
		$reflect=new \ReflectionClass($instance);
		$prop=false;
		if($reflect->hasProperty($member))
			$prop=$reflect->getProperty($member);
		return $prop;
	}
	
	public static function getPropertyType($class,$property){
		return self::getMetadata($class, $property, "@var", "type");
	}
	
	public static function getMetadata($class,$property, $type, $name){
		$a = Annotations::ofProperty($class, $property, $type);
		if (!count($a)){
			return false;
		}
		return trim($a[0]->$name,";");
	}
	

	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);
		if (\sizeof($annot) > 0)
			return $annot[0];
		return false;
	}
	
	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) {
		$props=self::getProperties($class);
		$ret=array ();
		foreach ( $props as $prop ) {
			$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
			if ($annot !== false)
				$ret[$prop->getName()]=$annot;
		}
		return $ret;
	}

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

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

	public static function isNullable($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if (!$ret)
			return false;
		else
			return $ret->nullable;

Accessing nullable on the interface mindplay\annotations\IAnnotation suggest that you code against a concrete implementation. How about adding an instanceof check?

	}

	public static function getDbType($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if (!$ret)
			return false;
		else
			return $ret->dbType;

Accessing dbType on the interface mindplay\annotations\IAnnotation suggest that you code against a concrete implementation. How about adding an instanceof check?

	}

	public static function isSerializable($class, $member) {
		if (self::getAnnotationMember($class, $member, "@transient") !== false || self::getAnnotationMember($class, $member, "@manyToOne") !== false || self::getAnnotationMember($class, $member, "@manyToMany") !== false || self::getAnnotationMember($class, $member, "@oneToMany") !== false)
			return false;
		else
			return true;
	}

	public static function getFieldName($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if ($ret === false || !isset($ret->name))

Accessing name on the interface mindplay\annotations\IAnnotation suggest that you code against a concrete implementation. How about adding an instanceof check?

			$ret=$member;
		else
			$ret=$ret->name;
		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;
	}
}