InstanceViewer::_getPropertyValue() - Code Metrics - Inspection of "Simplification" - phpMv/phpMv-UI - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1b9fb1...489615 )

by Jean-Christophe

created 2017-02-18 23:49 UTC

InstanceViewer::_getPropertyValue() A

↳ Parent: InstanceViewer

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	10
rs	9.4285
cc	2
eloc	8
nc	2
nop	2

<?php
namespace Ajax\semantic\widgets\base;
use Ajax\service\JString;

class InstanceViewer {
	protected $widgetIdentifier;
	protected $instance;
	protected $reflect;
	protected $properties;
	protected $visibleProperties;
	protected $values;
	protected $afterCompile;
	protected $captions;
	protected $captionCallback;
	protected $defaultValueFunction;


	public static $index=0;

	public function __construct($identifier,$instance=NULL,$captions=NULL){
		$this->widgetIdentifier=$identifier;
		$this->values=[];
		$this->afterCompile=[];
		if(isset($instance))
			$this->setInstance($instance);
		$this->setCaptions($captions);
		$this->captionCallback=NULL;
		$this->defaultValueFunction=function($name,$value){return $value;};
	}

	public function getValues(){
		$values=[];
		$index=0;
		$count=$this->count();
		while($index<$count){
			$values[]=$this->getValue($index++);
		}
		return $values;
	}

	public function getIdentifier($index=NULL){
		if(!isset($index))
			$index=self::$index;
		$value=$index;
		if(isset($this->values["identifier"]))
			$value=$this->values["identifier"]($index,$this->instance);
		return $value;
	}

	public function getValue($index){
		$property=$this->properties[$index];
		return $this->_getValue($property, $index);
	}

	protected function _beforeAddProperty($index,&$field){

	}

	protected function _getDefaultValue($name,$value,$index){
		$func=$this->defaultValueFunction;
		return $func($name,$value,$index,$this->instance);
	}

	protected function _getPropertyValue(\ReflectionProperty $property,$index){
		$property->setAccessible(true);
		$value=$property->getValue($this->instance);
		if(isset($this->values[$index])){
			$value= $this->values[$index]($value,$this->instance,$index);
		}else{
			$value=$this->_getDefaultValue($property->getName(),$value, $index);
		}
		return $value;
	}

	protected function _getValue($property,$index){
		$value=null;
		if($property instanceof \ReflectionProperty){
			$value=$this->_getPropertyValue($property, $index);
		}else{
			if(\is_callable($property))
				$value=$property($this->instance);
			elseif(\is_array($property)){
				$values=\array_map(function($v) use ($index){return $this->_getValue($v, $index);}, $property);
				$value=\implode("", $values);
			}else{
				if(isset($this->values[$index])){
					$value= $this->values[$index]($property,$this->instance,$index);
				}elseif(isset($this->instance->{$property})){
					$value=$this->instance->{$property};
				}
			}
		}
		if(isset($this->afterCompile[$index])){
			if(\is_callable($this->afterCompile[$index])){
				$this->afterCompile[$index]($value,$this->instance,$index);
			}
		}
		return $value;
	}

	public function insertField($index,$field){
		array_splice( $this->visibleProperties, $index, 0, $field );
		return $this;
	}

	public function insertInField($index,$field){
		$vb=$this->visibleProperties;
		if(isset($vb[$index])){
			if(\is_array($vb[$index])){
				$this->visibleProperties[$index][]=$field;
			}else{
				$this->visibleProperties[$index]=[$vb[$index],$field];
			}
		}else{
			return $this->insertField($index, $field);
		}
		return $this;
	}

	public function addField($field){
		$this->visibleProperties[]=$field;
		return $this;
	}

	public function count(){
		return \sizeof($this->properties);
	}

	public function visiblePropertiesCount(){
		return \sizeof($this->visibleProperties);
	}

	public function getProperty($index){
		return $this->properties[$index];
	}

	public function getFieldName($index){
		$property=$this->getProperty($index);
		if($property instanceof \ReflectionProperty){
			$result=$property->getName();
		}elseif(\is_callable($property)){
			$result=$this->visibleProperties[$index];
		}else{
			$result=$property;
		}
		return $result;
	}


	protected function showableProperty(\ReflectionProperty $rProperty){
		return JString::startswith($rProperty->getName(),"_")===false;
	}

	public function setInstance($instance) {
		if(\is_string($instance)){
			$instance=new $instance();
		}
		$this->instance=$instance;
		$this->properties=[];
		$this->reflect=new \ReflectionClass($instance);
		if(\sizeof($this->visibleProperties)===0){
			$this->properties=$this->getDefaultProperties();
		}else{
			foreach ($this->visibleProperties as $property){
				$this->setInstanceProperty($property);
			}
		}
		return $this;
	}

	private function setInstanceProperty($property){
		if(\is_callable($property)){
			$this->properties[]=$property;
		}elseif(\is_string($property)){
			try{
				$this->_beforeAddProperty(\sizeof($this->properties), $property);
				$rProperty=$this->reflect->getProperty($property);
				$this->properties[]=$rProperty;
			}catch(\Exception $e){
				$this->_beforeAddProperty(\sizeof($this->properties), $property);
				$this->properties[]=$property;
			}
		}elseif(\is_int($property)){
			$props=$this->getDefaultProperties();
			if(isset($props[$property]))
				$this->properties[]=$props[$property];
				else
					$this->properties[]=$property;
		}else{
			$this->properties[]=$property;
		}
	}

	protected function getDefaultProperties(){
		$result=[];
		$properties=$this->reflect->getProperties();
		foreach ($properties as $property){
			$showable=$this->showableProperty($property);
			if($showable!==false){
				$result[]=$property;
			}
		}
		return $result;
	}

	public function setVisibleProperties($visibleProperties) {
		$this->visibleProperties=$visibleProperties;
		return $this;
	}

	public function setValueFunction($index,$callback){
		$this->values[$index]=$callback;
		return $this;
	}

	public function setIdentifierFunction($callback){
		$this->values["identifier"]=$callback;
		return $this;
	}

	public static function setIndex($index) {
		self::$index=$index;
	}

	public function getProperties() {
		return $this->properties;
	}

	public function getCaption($index){
		if(isset($this->captions[$index])){
			return $this->captions[$index];
		}
		if($this->properties[$index] instanceof \ReflectionProperty)
			return $this->properties[$index]->getName();
		elseif(\is_callable($this->properties[$index]))
			return "";
		else
			return $this->properties[$index];
	}

	public function getCaptions(){
		if(isset($this->captions)){
			$captions= $this->captions;
			for($i=\sizeof($captions);$i<$this->count();$i++){
				$captions[]="";
			}
		}else{
			$captions=[];
			$index=0;
			$count=$this->count();
			while($index<$count){
				$captions[]=$this->getCaption($index++);
			}
		}
		if(isset($this->captionCallback) && \is_callable($this->captionCallback)){
			$callback=$this->captionCallback;
			$callback($captions,$this->instance);
		}
		return $captions;
	}

	public function setCaption($index,$caption){
		if(isset($this->captions)===false)
			$this->captions=[];
		$this->captions[$index]=$caption;
		return $this;
	}

	public function setCaptions($captions) {
		$this->captions=$captions;
		return $this;
	}

	/**
	 * Associates a $callback function after the compilation of the field at $index position
	 * The $callback function can take the following arguments : $field=>the compiled field, $instance : the active instance of the object, $index: the field position
	 * @param int $index postion of the compiled field
	 * @param callable $callback function called after the field compilation
	 * @return \Ajax\semantic\widgets\datatable\InstanceViewer
	 */
	public function afterCompile($index,$callback){
		$this->afterCompile[$index]=$callback;
		return $this;
	}

	/**
	 * Defines a callback function to call for modifying captions
	 * function parameters are $captions: the captions to modify and $instance: the active model instance
	 * @param callable $captionCallback
	 * @return \Ajax\semantic\widgets\base\InstanceViewer
	 */
	public function setCaptionCallback($captionCallback) {
		$this->captionCallback=$captionCallback;
		return $this;
	}

	/**
	 * Defines the default function which displays fields value
	 * @param callable $defaultValueFunction function parameters are : $name : the field name, $value : the field value ,$index : the field index, $instance : the active instance of model
	 * @return \Ajax\semantic\widgets\base\InstanceViewer
	 */
	public function setDefaultValueFunction($defaultValueFunction) {
		$this->defaultValueFunction=$defaultValueFunction;
		return $this;
	}


}

1			<?php
2			namespace Ajax\semantic\widgets\base;
3			use Ajax\service\JString;
4
5			class InstanceViewer {
6			protected $widgetIdentifier;
7			protected $instance;
8			protected $reflect;
9			protected $properties;
10			protected $visibleProperties;
11			protected $values;
12			protected $afterCompile;
13			protected $captions;
14			protected $captionCallback;
15			protected $defaultValueFunction;
16
17
18			public static $index=0;
19
20			public function __construct($identifier,$instance=NULL,$captions=NULL){
21			$this->widgetIdentifier=$identifier;
22			$this->values=[];
23			$this->afterCompile=[];
24			if(isset($instance))
25			$this->setInstance($instance);
26			$this->setCaptions($captions);
27			$this->captionCallback=NULL;
28			$this->defaultValueFunction=function($name,$value){return $value;};
29			}
30
31			public function getValues(){
32			$values=[];
33			$index=0;
34			$count=$this->count();
35			while($index<$count){
36			$values[]=$this->getValue($index++);
37			}
38			return $values;
39			}
40
41			public function getIdentifier($index=NULL){
42			if(!isset($index))
43			$index=self::$index;
44			$value=$index;
45			if(isset($this->values["identifier"]))
46			$value=$this->values["identifier"]($index,$this->instance);
47			return $value;
48			}
49
50			public function getValue($index){
51			$property=$this->properties[$index];
52			return $this->_getValue($property, $index);
53			}
54
55			protected function _beforeAddProperty($index,&$field){
56
57			}
58
59			protected function _getDefaultValue($name,$value,$index){
60			$func=$this->defaultValueFunction;
61			return $func($name,$value,$index,$this->instance);
62			}
63
64			protected function _getPropertyValue(\ReflectionProperty $property,$index){
65			$property->setAccessible(true);
66			$value=$property->getValue($this->instance);
67			if(isset($this->values[$index])){
68			$value= $this->values[$index]($value,$this->instance,$index);
69			}else{
70			$value=$this->_getDefaultValue($property->getName(),$value, $index);
71			}
72			return $value;
73			}
74
75			protected function _getValue($property,$index){
76			$value=null;
77			if($property instanceof \ReflectionProperty){
78			$value=$this->_getPropertyValue($property, $index);
79			}else{
80			if(\is_callable($property))
81			$value=$property($this->instance);
82			elseif(\is_array($property)){
83			$values=\array_map(function($v) use ($index){return $this->_getValue($v, $index);}, $property);
84			$value=\implode("", $values);
85			}else{
86			if(isset($this->values[$index])){
87			$value= $this->values[$index]($property,$this->instance,$index);
88			}elseif(isset($this->instance->{$property})){
89			$value=$this->instance->{$property};
90			}
91			}
92			}
93			if(isset($this->afterCompile[$index])){
94			if(\is_callable($this->afterCompile[$index])){
95			$this->afterCompile[$index]($value,$this->instance,$index);
96			}
97			}
98			return $value;
99			}
100
101			public function insertField($index,$field){
102			array_splice( $this->visibleProperties, $index, 0, $field );
103			return $this;
104			}
105
106			public function insertInField($index,$field){
107			$vb=$this->visibleProperties;
108			if(isset($vb[$index])){
109			if(\is_array($vb[$index])){
110			$this->visibleProperties[$index][]=$field;
111			}else{
112			$this->visibleProperties[$index]=[$vb[$index],$field];
113			}
114			}else{
115			return $this->insertField($index, $field);
116			}
117			return $this;
118			}
119
120			public function addField($field){
121			$this->visibleProperties[]=$field;
122			return $this;
123			}
124
125			public function count(){
126			return \sizeof($this->properties);
127			}
128
129			public function visiblePropertiesCount(){
130			return \sizeof($this->visibleProperties);
131			}
132
133			public function getProperty($index){
134			return $this->properties[$index];
135			}
136
137			public function getFieldName($index){
138			$property=$this->getProperty($index);
139			if($property instanceof \ReflectionProperty){
140			$result=$property->getName();
141			}elseif(\is_callable($property)){
142			$result=$this->visibleProperties[$index];
143			}else{
144			$result=$property;
145			}
146			return $result;
147			}
148
149
150			protected function showableProperty(\ReflectionProperty $rProperty){
151			return JString::startswith($rProperty->getName(),"_")===false;
152			}
153
154			public function setInstance($instance) {
155			if(\is_string($instance)){
156			$instance=new $instance();
157			}
158			$this->instance=$instance;
159			$this->properties=[];
160			$this->reflect=new \ReflectionClass($instance);
161			if(\sizeof($this->visibleProperties)===0){
162			$this->properties=$this->getDefaultProperties();
163			}else{
164			foreach ($this->visibleProperties as $property){
165			$this->setInstanceProperty($property);
166			}
167			}
168			return $this;
169			}
170
171			private function setInstanceProperty($property){
172			if(\is_callable($property)){
173			$this->properties[]=$property;
174			}elseif(\is_string($property)){
175			try{
176			$this->_beforeAddProperty(\sizeof($this->properties), $property);
177			$rProperty=$this->reflect->getProperty($property);
178			$this->properties[]=$rProperty;
179			}catch(\Exception $e){
180			$this->_beforeAddProperty(\sizeof($this->properties), $property);
181			$this->properties[]=$property;
182			}
183			}elseif(\is_int($property)){
184			$props=$this->getDefaultProperties();
185			if(isset($props[$property]))
186			$this->properties[]=$props[$property];
187			else
188			$this->properties[]=$property;
189			}else{
190			$this->properties[]=$property;
191			}
192			}
193
194			protected function getDefaultProperties(){
195			$result=[];
196			$properties=$this->reflect->getProperties();
197			foreach ($properties as $property){
198			$showable=$this->showableProperty($property);
199			if($showable!==false){
200			$result[]=$property;
201			}
202			}
203			return $result;
204			}
205
206			public function setVisibleProperties($visibleProperties) {
207			$this->visibleProperties=$visibleProperties;
208			return $this;
209			}
210
211			public function setValueFunction($index,$callback){
212			$this->values[$index]=$callback;
213			return $this;
214			}
215
216			public function setIdentifierFunction($callback){
217			$this->values["identifier"]=$callback;
218			return $this;
219			}
220
221			public static function setIndex($index) {
222			self::$index=$index;
223			}
224
225			public function getProperties() {
226			return $this->properties;
227			}
228
229			public function getCaption($index){
230			if(isset($this->captions[$index])){
231			return $this->captions[$index];
232			}
233			if($this->properties[$index] instanceof \ReflectionProperty)
234			return $this->properties[$index]->getName();
235			elseif(\is_callable($this->properties[$index]))
236			return "";
237			else
238			return $this->properties[$index];
239			}
240
241			public function getCaptions(){
242			if(isset($this->captions)){
243			$captions= $this->captions;
244			for($i=\sizeof($captions);$i<$this->count();$i++){
245			$captions[]="";
246			}
247			}else{
248			$captions=[];
249			$index=0;
250			$count=$this->count();
251			while($index<$count){
252			$captions[]=$this->getCaption($index++);
253			}
254			}
255			if(isset($this->captionCallback) && \is_callable($this->captionCallback)){
256			$callback=$this->captionCallback;
257			$callback($captions,$this->instance);
258			}
259			return $captions;
260			}
261
262			public function setCaption($index,$caption){
263			if(isset($this->captions)===false)
264			$this->captions=[];
265			$this->captions[$index]=$caption;
266			return $this;
267			}
268
269			public function setCaptions($captions) {
270			$this->captions=$captions;
271			return $this;
272			}
273
274			/**
275			* Associates a $callback function after the compilation of the field at $index position
276			* The $callback function can take the following arguments : $field=>the compiled field, $instance : the active instance of the object, $index: the field position
277			* @param int $index postion of the compiled field
278			* @param callable $callback function called after the field compilation
279			* @return \Ajax\semantic\widgets\datatable\InstanceViewer
280			*/
281			public function afterCompile($index,$callback){
282			$this->afterCompile[$index]=$callback;
283			return $this;
284			}
285
286			/**
287			* Defines a callback function to call for modifying captions
288			* function parameters are $captions: the captions to modify and $instance: the active model instance
289			* @param callable $captionCallback
290			* @return \Ajax\semantic\widgets\base\InstanceViewer
291			*/
292			public function setCaptionCallback($captionCallback) {
293			$this->captionCallback=$captionCallback;
294			return $this;
295			}
296
297			/**
298			* Defines the default function which displays fields value
299			* @param callable $defaultValueFunction function parameters are : $name : the field name, $value : the field value ,$index : the field index, $instance : the active instance of model
300			* @return \Ajax\semantic\widgets\base\InstanceViewer
301			*/
302			public function setDefaultValueFunction($defaultValueFunction) {
303			$this->defaultValueFunction=$defaultValueFunction;
304			return $this;
305			}
306
307
308			}

phpMv / phpMv-UI

Push — master ( 1b9fb1...489615 )

InstanceViewer::_getPropertyValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like