AbstractField - Code Metrics - Inspection of "Fixed displaying value for fields" - code4interactive/forms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 11675b...1688ee )

by A

created 2015-11-26 14:55 UTC

AbstractField C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	419
Duplicated Lines	7.64 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	8
Bugs	3	Features	1

Metric	Value
wmc	67
c	8
b	3
f	1
lcom	1
cbo	1
dl	32
loc	419
rs	5.7098

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
D	parseBaseData()	0	53	10
A	attributes()	0	9	3
C	value()	0	68	22
A	setValue()	0	3	1
A	id()	8	8	2
A	name()	8	8	2
A	title()	0	8	2
A	_type()	0	8	2
A	rules()	0	8	2
A	getRulesForValidator()	0	7	2
A	getDotNotatedName()	0	12	1
A	addRule()	8	8	2
A	removeRule()	8	8	2
A	customRules()	0	8	2
A	render()	0	3	1
A	__toString()	0	3	1
A	setProperty()	0	8	2
A	getProperty()	0	8	3
A	__call()	0	9	3
A	isAssoc()	0	3	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractField often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractField, and based on these observations, apply Extract Interface, too.

<?php

namespace Code4\Forms\Fields;

use Code4\View\Attributes;

abstract class AbstractField implements FieldsInterface {

    protected $name;

    protected $title;

    protected $label;

    /**
     * @var string Index elementu w pliku konfiguracyjnym
     */
    protected $fieldName;

    protected $id;

    protected $attributes;

    /**
     * List of all properties
     * @var array
     */
    protected $properties = [];

    protected $value;

    protected $rules;
    protected $customRules;

    protected $optionKeys;

    protected $_viewNamespace = 'forms::';
    protected $_view; //Widok do załadowania
    protected $_type; //Typ elementu (np text, password) ten sam widok tylko inny typ

    /**
     * Pola specjalne dla których nie nadajemy automatycznie klas (form-control) itp.
     * @var array
     */
    protected $specialFields = [
        'separator', 'header', 'htmlTag'
    ];

    /**
     * Constructs base element
     * @param $fieldName
     * @param array $data
     */
    public function __construct($fieldName, $data = []) {
        $this->fieldName = $fieldName;
        $this->parseBaseData($data);
    }

    /**
     * Parses base data passed to field. More field specific data has to be parsed in classes extending AbstractField
     * @param array $data
     */
    public function parseBaseData($data) {
        //Attributes
        if (array_key_exists('attributes', $data)) {
            $this->attributes($data['attributes']);
            unset($data['attributes']);
        }

        //Name
        if (array_key_exists('name', $data)) {
            $this->name = $data['name'];
            unset($data['name']);
        } else {
            $this->name = $this->fieldName;
        }

        //Pre set title
        $this->title($this->name);

        //Values
        if (array_key_exists('value', $data)) {
            $this->setValue($data['value']);
            unset($data['value']);
        }

        //Rules
        if (array_key_exists('rules', $data)) {
            $this->rules($data['rules']);
            unset($data['rules']);
        }

        //Setting remaining properties
        //Title
        if (array_key_exists('title', $data)) {
            $this->title($data['title']);
            unset($data['title']);
        }

        //Title
        if (array_key_exists('label', $data)) {
            $this->label($data['label']);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            unset($data['label']);
        }

        foreach ($data as $propertyName => $value) {
            $this->setProperty($propertyName, $value);
        }

        //If classes not set - default = form-control
        if (!$this->attributes()->has('class') && !in_array($this->_type,$this->specialFields)) {
            $this->attributes()->add('class', 'form-control');
        }

    }

    /**
     * Gets or sets attributes
     * @param null|array $data
     * @return Attributes
     */
    public function attributes($data = null) {
        if ($data !== null) {
            $this->attributes = new Attributes($data);
        }
        if (is_null($this->attributes)) {
            $this->attributes = new Attributes();
        }
        return $this->attributes;
    }

    /**
     * Sets or gets value
     * @param $value
     * @param $key
     * @return FieldsInterface|mixed $this
     */
    public function value($value = null, $key = null) {

        if ($value === null) {
            if (is_array($this->value) && count($this->value) == 1) {
                return (string)$this->value[0];
            }
            if (is_array($this->value) && count($this->value) > 1) {
                return $this->value;
            }
            return (string)$this->value;
        }

        // Store value as array if string or numeric
        if (is_string($value) || is_numeric($value) || is_bool($value)) {
            $this->value = [$value];
            return $this;
        }

        //If value is assoc array store only keys
        //Usually key=>value pairs represent value=>description eg. in select fields
        if (is_array($value) && $this->isAssoc($value)) {
            $this->value = [];
            foreach ($value as $k=>$v) {
                $this->value[] = $k;
            }
            return $this;
        }

        //Normal array of values (checkboxes)
        if (is_array($value)) {
            $this->value = $value;
            return $this;
        }

        //Values are in object. To extract them we need property names (keys)
        //$optionKeys is used also to extract value=>description for option field
        //So in config $optionsKeys is an 2 element array
        if (is_object($value)) {
            if (is_null($key) && count($this->optionKeys) == 2) {
                $key = $this->optionKeys[0];
            }

            //If still no key - try using name as key??
            if (is_null($key)) {
                $key = $this->name;
            }

            if (!$key) {
                return $this;
            }

            $this->value = [];
            //iterating over $value object because it may be an collection eg. results from DB
            foreach($value as $objectKey=>$o) {
                if (is_object($o) && property_exists($o, $key)) {
                    $this->value[] = $o->$key;
                } else {
                    //If passed object is not an iterable collection loop will iterate over properties
                    if ($objectKey == $key) {
                        $this->value[] = $o;
                        return $this;
                    }
                }
            }
            return $this;
        }
        return $this;
    }

    /**
     * Shortcut for values() method. Used to set value of field after initiation from config. Is needed for fields
     * with checked traits where method is overrided
     * @param null $value
     * @param null $key
     * @return FieldsInterface|mixed
     */
    public function setValue($value = null, $key = null) {
        return $this->value($value = null, $key = null);
    }

    /**
     * @param null $id
     * @return string|FieldsInterface
     */
    public function id($id = null) {

        if (is_null($id)) {
            return $this->id;
        } else {
            $this->id = $id;
        }
        return $this;
    }

    /**
     * @param null $name
     * @return string|FieldsInterface
     */
    public function name($name = null) {

        if (is_null($name)) {
            return $this->name;
        } else {
            $this->name = $name;
        }
        return $this;
    }

    /**
     * @param null $title
     * @return string|FieldsInterface
     */
    public function title($title = null) {
        if (is_null($title)) {
            return $this->title;
        } else {
            $this->title = $title;
        }
        return $this;
    }

    /**
     * @param null $_type
     * @return string|FieldsInterface
     */
    public function _type($_type = null) {
        if (is_null($_type)) {
            return $this->_type;
        } else {
            $this->_type = $_type;
        }
        return $this;
    }

    /**
     * Sets or retrives rules for field and child fields
     * @param null $rules
     * @return string|FieldsInterface
     */
    public function rules($rules = null) {
        if (is_null($rules)) {
            return $this->rules;
        } else {
            $this->rules = $rules;
        }
        return $this;
    }

    /**
     * Returns name=>rules array for validator
     * @return array
     */
    public function getRulesForValidator() {
        if ($this->rules == '') {
            return [];
        }

        return [$this->getDotNotatedName() => $this->rules];
    }

    /**
     * Returns name of field in 'dot' notation. Eg. field[] -> field, field[test] -> field.test
     * @return string
     */
    public function getDotNotatedName() {
        $name = $this->name();

        //multi value fields are validated as single value
        $name = str_replace('[]','',$name);

        //if in config field field is named field[test][tes2] replace that to: field.test.test2
        $pattern = '/\[{1}([^\]]+)\]{1}/';
        //preg_replace("/\[{1}([^\]]+)\]{1}/", ".$1", $input_lines);
        $name = preg_replace($pattern, ".$1", $name);
        return $name;
    }

    /**
     * Adds rule if it don't exist
     * @param $rule
     * @return $this
     */
    public function addRule($rule) {

        $rules = explode("|", $this->rules);
        if (array_search($rule, $rules) === false) {
            array_push($rules, $rule);
        }
        $this->rules = trim(implode("|", $rules), "|");
        return $this;
    }

    /**
     * Removes rule from field
     * @param $rule
     * @return $this
     */
    public function removeRule($rule) {

        $rules = explode("|", $this->rules);
        if (($index = array_search($rule, $rules)) !== false) {
            unset($rules[$index]);
        }
        $this->rules = trim(implode("|", $rules), "|");
        return $this;
    }

    /**
     * @param null $customRules
     * @return string|FieldsInterface
     */
    public function customRules($customRules = null) {
        if (is_null($customRules)) {
            return $this->customRules;
        } else {
            $this->customRules[] = $customRules;
        }
        return $this;
    }

    /**
     * Renders element
     * @return \Illuminate\View\View
     */
    public function render() {
        return view($this->_viewNamespace.$this->_view, ['el'=>$this])->render();
    }

    /**
     * @return string
     */
    public function __toString() {
        return $this->render();
    }

    /**
     * Sets property
     * @param string $propertyName
     * @param mixed $value
     * @return $this
     */
    public function setProperty($propertyName, $value) {
        if (property_exists($this, $propertyName)) {
            $this->$propertyName = $value;
        } else {
            $this->properties[$propertyName] = $value;
        }
        return $this;
    }

    /**
     * Gets property
     * @param string $propertyName
     * @return mixed
     */
    public function getProperty($propertyName) {
        if (property_exists($this, $propertyName)) {
            return $this->$propertyName;
        } else
        {
            return array_key_exists($propertyName, $this->properties) ? $this->properties[$propertyName] : '';
        }
    }

    /**
     * Magic methods
     * @param $method
     * @param $args
     * @return AbstractField|mixed
     */
    public function __call($method, $args) {
        if (count($args) == 0) {
            return $this->getProperty($method);
        }

        if (count($args) == 1) {
            return $this->setProperty($method, $args[0]);
        }
    }


    /**
     * Checks if passed array is associative or indexed
     * @param $arr
     * @return bool
     */
    private function isAssoc($arr) {
        return array_keys($arr) !== range(0, count($arr) - 1);
    }


}

1		<?php
2
3		namespace Code4\Forms\Fields;
4
5		use Code4\View\Attributes;
6
7		abstract class AbstractField implements FieldsInterface {
8
9		protected $name;
10
11		protected $title;
12
13		protected $label;
14
15		/**
16		* @var string Index elementu w pliku konfiguracyjnym
17		*/
18		protected $fieldName;
19
20		protected $id;
21
22		protected $attributes;
23
24		/**
25		* List of all properties
26		* @var array
27		*/
28		protected $properties = [];
29
30		protected $value;
31
32		protected $rules;
33		protected $customRules;
34
35		protected $optionKeys;
36
37		protected $_viewNamespace = 'forms::';
38		protected $_view; //Widok do załadowania
39		protected $_type; //Typ elementu (np text, password) ten sam widok tylko inny typ
40
41		/**
42		* Pola specjalne dla których nie nadajemy automatycznie klas (form-control) itp.
43		* @var array
44		*/
45		protected $specialFields = [
46		'separator', 'header', 'htmlTag'
47		];
48
49		/**
50		* Constructs base element
51		* @param $fieldName
52		* @param array $data
53		*/
54		public function __construct($fieldName, $data = []) {
55		$this->fieldName = $fieldName;
56		$this->parseBaseData($data);
57		}
58
59		/**
60		* Parses base data passed to field. More field specific data has to be parsed in classes extending AbstractField
61		* @param array $data
62		*/
63		public function parseBaseData($data) {
64		//Attributes
65		if (array_key_exists('attributes', $data)) {
66		$this->attributes($data['attributes']);
67		unset($data['attributes']);
68		}
69
70		//Name
71		if (array_key_exists('name', $data)) {
72		$this->name = $data['name'];
73		unset($data['name']);
74		} else {
75		$this->name = $this->fieldName;
76		}
77
78		//Pre set title
79		$this->title($this->name);
80
81		//Values
82		if (array_key_exists('value', $data)) {
83		$this->setValue($data['value']);
84		unset($data['value']);
85		}
86
87		//Rules
88		if (array_key_exists('rules', $data)) {
89		$this->rules($data['rules']);
90		unset($data['rules']);
91		}
92
93		//Setting remaining properties
94		//Title
95		if (array_key_exists('title', $data)) {
96		$this->title($data['title']);
97		unset($data['title']);
98		}
99
100		//Title
101		if (array_key_exists('label', $data)) {
102		$this->label($data['label']);
		0 ignored issues – show Documentation Bug introduced 2015-11-26 14:59 UTC by Report Bug Copy Issue Report The method `label` does not exist on `object<Code4\Forms\Fields\AbstractField>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
103		unset($data['label']);
104		}
105
106		foreach ($data as $propertyName => $value) {
107		$this->setProperty($propertyName, $value);
108		}
109
110		//If classes not set - default = form-control
111		if (!$this->attributes()->has('class') && !in_array($this->_type,$this->specialFields)) {
112		$this->attributes()->add('class', 'form-control');
113		}
114
115		}
116
117		/**
118		* Gets or sets attributes
119		* @param null\|array $data
120		* @return Attributes
121		*/
122		public function attributes($data = null) {
123		if ($data !== null) {
124		$this->attributes = new Attributes($data);
125		}
126		if (is_null($this->attributes)) {
127		$this->attributes = new Attributes();
128		}
129		return $this->attributes;
130		}
131
132		/**
133		* Sets or gets value
134		* @param $value
135		* @param $key
136		* @return FieldsInterface\|mixed $this
137		*/
138		public function value($value = null, $key = null) {
139
140		if ($value === null) {
141		if (is_array($this->value) && count($this->value) == 1) {
142		return (string)$this->value[0];
143		}
144		if (is_array($this->value) && count($this->value) > 1) {
145		return $this->value;
146		}
147		return (string)$this->value;
148		}
149
150		// Store value as array if string or numeric
151		if (is_string($value) \|\| is_numeric($value) \|\| is_bool($value)) {
152		$this->value = [$value];
153		return $this;
154		}
155
156		//If value is assoc array store only keys
157		//Usually key=>value pairs represent value=>description eg. in select fields
158		if (is_array($value) && $this->isAssoc($value)) {
159		$this->value = [];
160		foreach ($value as $k=>$v) {
161		$this->value[] = $k;
162		}
163		return $this;
164		}
165
166		//Normal array of values (checkboxes)
167		if (is_array($value)) {
168		$this->value = $value;
169		return $this;
170		}
171
172		//Values are in object. To extract them we need property names (keys)
173		//$optionKeys is used also to extract value=>description for option field
174		//So in config $optionsKeys is an 2 element array
175		if (is_object($value)) {
176		if (is_null($key) && count($this->optionKeys) == 2) {
177		$key = $this->optionKeys[0];
178		}
179
180		//If still no key - try using name as key??
181		if (is_null($key)) {
182		$key = $this->name;
183		}
184
185		if (!$key) {
186		return $this;
187		}
188
189		$this->value = [];
190		//iterating over $value object because it may be an collection eg. results from DB
191		foreach($value as $objectKey=>$o) {
192		if (is_object($o) && property_exists($o, $key)) {
193		$this->value[] = $o->$key;
194		} else {
195		//If passed object is not an iterable collection loop will iterate over properties
196		if ($objectKey == $key) {
197		$this->value[] = $o;
198		return $this;
199		}
200		}
201		}
202		return $this;
203		}
204		return $this;
205		}
206
207		/**
208		* Shortcut for values() method. Used to set value of field after initiation from config. Is needed for fields
209		* with checked traits where method is overrided
210		* @param null $value
211		* @param null $key
212		* @return FieldsInterface\|mixed
213		*/
214		public function setValue($value = null, $key = null) {
215		return $this->value($value = null, $key = null);
216		}
217
218		/**
219		* @param null $id
220		* @return string\|FieldsInterface
221		*/
222	View Code Duplication	public function id($id = null) {
		0 ignored issues – show Duplication introduced 2015-11-23 16:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
223		if (is_null($id)) {
224		return $this->id;
225		} else {
226		$this->id = $id;
227		}
228		return $this;
229		}
230
231		/**
232		* @param null $name
233		* @return string\|FieldsInterface
234		*/
235	View Code Duplication	public function name($name = null) {
		0 ignored issues – show Duplication introduced 2015-11-23 16:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
236		if (is_null($name)) {
237		return $this->name;
238		} else {
239		$this->name = $name;
240		}
241		return $this;
242		}
243
244		/**
245		* @param null $title
246		* @return string\|FieldsInterface
247		*/
248		public function title($title = null) {
249		if (is_null($title)) {
250		return $this->title;
251		} else {
252		$this->title = $title;
253		}
254		return $this;
255		}
256
257		/**
258		* @param null $_type
259		* @return string\|FieldsInterface
260		*/
261		public function _type($_type = null) {
262		if (is_null($_type)) {
263		return $this->_type;
264		} else {
265		$this->_type = $_type;
266		}
267		return $this;
268		}
269
270		/**
271		* Sets or retrives rules for field and child fields
272		* @param null $rules
273		* @return string\|FieldsInterface
274		*/
275		public function rules($rules = null) {
276		if (is_null($rules)) {
277		return $this->rules;
278		} else {
279		$this->rules = $rules;
280		}
281		return $this;
282		}
283
284		/**
285		* Returns name=>rules array for validator
286		* @return array
287		*/
288		public function getRulesForValidator() {
289		if ($this->rules == '') {
290		return [];
291		}
292
293		return [$this->getDotNotatedName() => $this->rules];
294		}
295
296		/**
297		* Returns name of field in 'dot' notation. Eg. field[] -> field, field[test] -> field.test
298		* @return string
299		*/
300		public function getDotNotatedName() {
301		$name = $this->name();
302
303		//multi value fields are validated as single value
304		$name = str_replace('[]','',$name);
305
306		//if in config field field is named field[test][tes2] replace that to: field.test.test2
307		$pattern = '/\[{1}([^\]]+)\]{1}/';
308		//preg_replace("/\[{1}([^\]]+)\]{1}/", ".$1", $input_lines);
309		$name = preg_replace($pattern, ".$1", $name);
310		return $name;
311		}
312
313		/**
314		* Adds rule if it don't exist
315		* @param $rule
316		* @return $this
317		*/
318	View Code Duplication	public function addRule($rule) {
		0 ignored issues – show Duplication introduced 2015-11-23 16:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
319		$rules = explode("\|", $this->rules);
320		if (array_search($rule, $rules) === false) {
321		array_push($rules, $rule);
322		}
323		$this->rules = trim(implode("\|", $rules), "\|");
324		return $this;
325		}
326
327		/**
328		* Removes rule from field
329		* @param $rule
330		* @return $this
331		*/
332	View Code Duplication	public function removeRule($rule) {
		0 ignored issues – show Duplication introduced 2015-11-23 16:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
333		$rules = explode("\|", $this->rules);
334		if (($index = array_search($rule, $rules)) !== false) {
335		unset($rules[$index]);
336		}
337		$this->rules = trim(implode("\|", $rules), "\|");
338		return $this;
339		}
340
341		/**
342		* @param null $customRules
343		* @return string\|FieldsInterface
344		*/
345		public function customRules($customRules = null) {
346		if (is_null($customRules)) {
347		return $this->customRules;
348		} else {
349		$this->customRules[] = $customRules;
350		}
351		return $this;
352		}
353
354		/**
355		* Renders element
356		* @return \Illuminate\View\View
357		*/
358		public function render() {
359		return view($this->_viewNamespace.$this->_view, ['el'=>$this])->render();
360		}
361
362		/**
363		* @return string
364		*/
365		public function __toString() {
366		return $this->render();
367		}
368
369		/**
370		* Sets property
371		* @param string $propertyName
372		* @param mixed $value
373		* @return $this
374		*/
375		public function setProperty($propertyName, $value) {
376		if (property_exists($this, $propertyName)) {
377		$this->$propertyName = $value;
378		} else {
379		$this->properties[$propertyName] = $value;
380		}
381		return $this;
382		}
383
384		/**
385		* Gets property
386		* @param string $propertyName
387		* @return mixed
388		*/
389		public function getProperty($propertyName) {
390		if (property_exists($this, $propertyName)) {
391		return $this->$propertyName;
392		} else
393		{
394		return array_key_exists($propertyName, $this->properties) ? $this->properties[$propertyName] : '';
395		}
396		}
397
398		/**
399		* Magic methods
400		* @param $method
401		* @param $args
402		* @return AbstractField\|mixed
403		*/
404		public function __call($method, $args) {
405		if (count($args) == 0) {
406		return $this->getProperty($method);
407		}
408
409		if (count($args) == 1) {
410		return $this->setProperty($method, $args[0]);
411		}
412		}
413
414
415		/**
416		* Checks if passed array is associative or indexed
417		* @param $arr
418		* @return bool
419		*/
420		private function isAssoc($arr) {
421		return array_keys($arr) !== range(0, count($arr) - 1);
422		}
423
424
425		}

code4interactive / forms