FieldAbstract - Code Metrics - Inspection of "Updating README with Dynamic Form instructions" - delboy1978uk/form - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 312f5c...551479 )

by Derek Stephen

created 2017-03-29 09:44 UTC

FieldAbstract B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	7

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	41
lcom	3
cbo	7
dl	0
loc	340
ccs	110
cts	110
cp	1
rs	8.2769
c	0
b	0
f	0

33 Methods

Rating	Name	Size	Complexity
	getTag()	1	?
	init()	1	?
A	__construct()	11	2
A	getName()	4	1
A	setName()	5	1
A	getId()	4	1
A	setId()	5	1
A	getClass()	4	2
A	setClass()	5	1
A	getValue()	4	1
A	setValue()	6	1
A	addValidator()	5	1
A	getValidators()	4	1
A	addFilter()	5	1
A	getFilters()	4	1
A	isValid()	11	2
A	checkForErrors()	8	3
A	filterValue()	11	2
A	getMessages()	4	1
A	getLabel()	4	1
A	setLabel()	5	1
A	setCustomErrorMessage()	5	1
A	hasCustomErrorMessage()	4	1
A	getCustomErrorMessage()	4	1
A	getRenderer()	4	1
A	setRenderer()	5	1
A	isRequired()	4	1
A	setRequired()	6	2
A	addNotEmptyValidator()	5	1
A	hasDynamicForms()	4	1
A	removeNotEmptyValidator()	11	3
A	addDynamicForm()	5	1
A	getDynamicForms()	7	2

How to fix Complexity

<?php
/**
 * User: delboy1978uk
 * Date: 19/11/2016
 * Time: 21:41
 */

namespace Del\Form\Field;

use Del\Form\Collection\FilterCollection;
use Del\Form\Collection\ValidatorCollection;
use Del\Form\Filter\FilterInterface;
use Del\Form\FormInterface;
use Del\Form\Renderer\Field\FieldRendererInterface;
use Del\Form\Renderer\Field\TextRender;
use Del\Form\Traits\HasAttributesTrait;
use Del\Form\Validator\NotEmpty;
use Del\Form\Validator\ValidatorInterface;
use Exception;

abstract class FieldAbstract implements FieldInterface
{

    /**  @var FormInterface[] $dynamicFormCollection */
    private $dynamicFormCollection;

    /**  @var FilterCollection $filterCollection */
    private $filterCollection;

    /**  @var ValidatorCollection $validatorCollection */
    private $validatorCollection;

    /** @var FieldRendererInterface $renderer  */
    private $renderer;

    /** @var array $errorMessages */
    private $errorMessages;

    /** @var string $customErrorMessage */
    private $customErrorMessage;

    /** @var string $label */
    private $label;

    /** @var bool $required */
    private $required;

    use HasAttributesTrait;

    /**
     * @return string
     */
    abstract public function getTag();

    abstract public function init();

    public function __construct($name, $value = null)
    {
        $this->required = false;
        $this->dynamicFormCollection = [];
        $this->filterCollection = new FilterCollection();
        $this->validatorCollection = new ValidatorCollection();
        $this->renderer = new TextRender();
        $this->setName($name);
        is_null($value) ? null : $this->setValue($value);
        $this->init();
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->getAttribute('name');
    }

    /**
     * @param string $name
     * @return FieldAbstract
     */
    public function setName($name)
    {
        $this->setAttribute('name', $name);
        return $this;
    }

    /**
     * @return string
     */
    public function getId()
    {
        return $this->getAttribute('id');
    }

    /**
     * @param string $id
     * @return FieldAbstract
     */
    public function setId($id)
    {
        $this->setAttribute('id', $id);
        return $this;
    }

    /**
     * @return string
     */
    public function getClass()
    {
        return $this->getAttribute('class') ?: 'form-control';
    }

    /**
     * @param string $class
     * @return FieldAbstract
     */
    public function setClass($class)
    {
        $this->setAttribute('class', $class);
        return $this;
    }

    /**
     * @return mixed
     */
    public function getValue()
    {
        return $this->getAttribute('value');
    }

    /**
     * @param mixed $value
     * @return FieldAbstract
     */
    public function setValue($value)
    {
        $this->setAttribute('value', $value);
        $this->filterValue();
        return $this;
    }

    /**
     * @param ValidatorInterface $validator
     * @return $this
     */
    public function addValidator(ValidatorInterface $validator)
    {
        $this->validatorCollection->append($validator);
        return $this;
    }

    /**
     * @return ValidatorCollection
     */
    public function getValidators()
    {
        return $this->validatorCollection;
    }

    /**
     * @param FilterInterface $filter
     * @return $this
     */
    public function addFilter(FilterInterface $filter)
    {
        $this->filterCollection->append($filter);
        return $this;
    }

    /**
     * @return FilterCollection
     */
    public function getFilters()
    {
        return $this->filterCollection;
    }

    /**
     *  Runs the checkForErrors method for each field, which adds to errorMessages if invalid
     *
     * @return bool
     * @throws Exception If validation of $value is impossible
     */
    public function isValid()
    {
        $this->errorMessages = [];
        $this->validatorCollection->rewind();
        while ($this->validatorCollection->valid()) {
            $this->checkForErrors($this->validatorCollection->current());
            $this->validatorCollection->next();
        }
        $count = count($this->errorMessages);
        return $count == 0;
    }

    /**
     * @param ValidatorInterface $validator
     */
    private function checkForErrors(ValidatorInterface $validator)
    {
        $value = $this->getValue();

        if ((!$validator->isValid($value)) && $this->isRequired()) {
            $this->errorMessages = array_merge($this->errorMessages, $validator->getMessages());
        }
    }

    private function filterValue()
    {
        $value = $this->getAttribute('value');
        $this->filterCollection->rewind();
        while ($this->filterCollection->valid()) {
            $value = $this->filterCollection->current()->filter($value);
            $this->filterCollection->next();
        }
        $this->filterCollection->rewind();
        $this->setAttribute('value', $value);
    }

    /**
     * @return array
     */
    public function getMessages()
    {
        return array_values($this->errorMessages);
    }

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

    /**
     * @param string $label
     * @return $this
     */
    public function setLabel($label)
    {
        $this->label = $label;
        return $this;
    }

    /**
     * @param string $message
     * @return $this
     */
    public function setCustomErrorMessage($message)
    {
        $this->customErrorMessage = $message;
        return $this;
    }

    /**
     * @return bool
     */
    public function hasCustomErrorMessage()
    {
        return $this->customErrorMessage != null;
    }

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

    /**
     * @return FieldRendererInterface
     */
    public function getRenderer()
    {
        return $this->renderer;
    }

    /**
     * @param FieldRendererInterface $renderer
     * @return $this
     */
    public function setRenderer(FieldRendererInterface $renderer)
    {
        $this->renderer = $renderer;
        return $this;
    }

    /**
     * If a field is required then it must have a value
     * We add a not empty validator
     *
     * @return boolean
     */
    public function isRequired()
    {
        return $this->required;
    }

    /**
     * @param boolean $required
     * @return FieldAbstract
     */
    public function setRequired($required)
    {
        $required ? $this->addNotEmptyValidator() : $this->removeNotEmptyValidator();
        $this->required = $required;
        return $this;
    }

    private function addNotEmptyValidator()
    {
        $notEmpty = new NotEmpty();
        $this->addValidator($notEmpty);
    }

    private function removeNotEmptyValidator()
    {
        $this->validatorCollection->rewind();
        while ($this->validatorCollection->valid()) {
            $validator = $this->validatorCollection->current();
            $validator instanceof NotEmpty
                ? $this->validatorCollection->offsetUnset($this->validatorCollection->key())
                : null;
            $this->validatorCollection->next();
        }
    }

    /**
     * @param FormInterface $form
     * @param $triggerValue
     * @return $this
     */
    public function addDynamicForm(FormInterface $form, $triggerValue)
    {
        $this->dynamicFormCollection[$triggerValue] = $form;
        return $this;
    }

    /**
     * @return bool
     */
    public function hasDynamicForms()
    {
        return count($this->dynamicFormCollection) > 0;
    }

    /**
     * @return FormInterface[]
     * @throws Exception
     */
    public function getDynamicForms()
    {
        if (!$this->hasDynamicForms()) {
            throw new Exception('No dynamic form for this value - Did you check hasDynamicForm() ?');
        }
        return $this->dynamicFormCollection;
    }
}

1		<?php
2		/**
3		* User: delboy1978uk
4		* Date: 19/11/2016
5		* Time: 21:41
6		*/
7
8		namespace Del\Form\Field;
9
10		use Del\Form\Collection\FilterCollection;
11		use Del\Form\Collection\ValidatorCollection;
12		use Del\Form\Filter\FilterInterface;
13		use Del\Form\FormInterface;
14		use Del\Form\Renderer\Field\FieldRendererInterface;
15		use Del\Form\Renderer\Field\TextRender;
16		use Del\Form\Traits\HasAttributesTrait;
17		use Del\Form\Validator\NotEmpty;
18		use Del\Form\Validator\ValidatorInterface;
19		use Exception;
20
21		abstract class FieldAbstract implements FieldInterface
22		{
23
24		/** @var FormInterface[] $dynamicFormCollection */
25		private $dynamicFormCollection;
26
27		/** @var FilterCollection $filterCollection */
28		private $filterCollection;
29
30		/** @var ValidatorCollection $validatorCollection */
31		private $validatorCollection;
32
33		/** @var FieldRendererInterface $renderer */
34		private $renderer;
35
36		/** @var array $errorMessages */
37		private $errorMessages;
38
39		/** @var string $customErrorMessage */
40		private $customErrorMessage;
41
42		/** @var string $label */
43		private $label;
44
45		/** @var bool $required */
46		private $required;
47
48		use HasAttributesTrait;
49
50		/**
51		* @return string
52		*/
53		abstract public function getTag();
54
55		abstract public function init();
56
57	47	public function __construct($name, $value = null)
58		{
59	47	$this->required = false;
60	47	$this->dynamicFormCollection = [];
61	47	$this->filterCollection = new FilterCollection();
62	47	$this->validatorCollection = new ValidatorCollection();
63	47	$this->renderer = new TextRender();
64	47	$this->setName($name);
65	47	is_null($value) ? null : $this->setValue($value);
66	47	$this->init();
67	47	}
68
69		/**
70		* @return string
71		*/
72	31	public function getName()
73		{
74	31	return $this->getAttribute('name');
75		}
76
77		/**
78		* @param string $name
79		* @return FieldAbstract
80		*/
81	47	public function setName($name)
82		{
83	47	$this->setAttribute('name', $name);
84	47	return $this;
85		}
86
87		/**
88		* @return string
89		*/
90	28	public function getId()
91		{
92	28	return $this->getAttribute('id');
93		}
94
95		/**
96		* @param string $id
97		* @return FieldAbstract
98		*/
99	8	public function setId($id)
100		{
101	8	$this->setAttribute('id', $id);
102	8	return $this;
103		}
104
105		/**
106		* @return string
107		*/
108	1	public function getClass()
109		{
110	1	return $this->getAttribute('class') ?: 'form-control';
111		}
112
113		/**
114		* @param string $class
115		* @return FieldAbstract
116		*/
117	8	public function setClass($class)
118		{
119	8	$this->setAttribute('class', $class);
120	8	return $this;
121		}
122
123		/**
124		* @return mixed
125		*/
126	34	public function getValue()
127		{
128	34	return $this->getAttribute('value');
129		}
130
131		/**
132		* @param mixed $value
133		* @return FieldAbstract
134		*/
135	28	public function setValue($value)
136		{
137	28	$this->setAttribute('value', $value);
138	28	$this->filterValue();
139	28	return $this;
140		}
141
142		/**
143		* @param ValidatorInterface $validator
144		* @return $this
145		*/
146	19	public function addValidator(ValidatorInterface $validator)
147		{
148	19	$this->validatorCollection->append($validator);
149	19	return $this;
150		}
151
152		/**
153		* @return ValidatorCollection
154		*/
155	2	public function getValidators()
156		{
157	2	return $this->validatorCollection;
158		}
159
160		/**
161		* @param FilterInterface $filter
162		* @return $this
163		*/
164	27	public function addFilter(FilterInterface $filter)
165		{
166	27	$this->filterCollection->append($filter);
167	27	return $this;
168		}
169
170		/**
171		* @return FilterCollection
172		*/
173	1	public function getFilters()
174		{
175	1	return $this->filterCollection;
176		}
177
178		/**
179		* Runs the checkForErrors method for each field, which adds to errorMessages if invalid
180		*
181		* @return bool
182		* @throws Exception If validation of $value is impossible
183		*/
184	29	public function isValid()
185		{
186	29	$this->errorMessages = [];
187	29	$this->validatorCollection->rewind();
188	29	while ($this->validatorCollection->valid()) {
189	16	$this->checkForErrors($this->validatorCollection->current());
190	16	$this->validatorCollection->next();
191		}
192	29	$count = count($this->errorMessages);
193	29	return $count == 0;
194		}
195
196		/**
197		* @param ValidatorInterface $validator
198		*/
199	16	private function checkForErrors(ValidatorInterface $validator)
200		{
201	16	$value = $this->getValue();
202
203	16	if ((!$validator->isValid($value)) && $this->isRequired()) {
204	12	$this->errorMessages = array_merge($this->errorMessages, $validator->getMessages());
205		}
206	16	}
207
208	28	private function filterValue()
209		{
210	28	$value = $this->getAttribute('value');
211	28	$this->filterCollection->rewind();
212	28	while ($this->filterCollection->valid()) {
213	9	$value = $this->filterCollection->current()->filter($value);
214	9	$this->filterCollection->next();
215		}
216	28	$this->filterCollection->rewind();
217	28	$this->setAttribute('value', $value);
218	28	}
219
220		/**
221		* @return array
222		*/
223	9	public function getMessages()
224		{
225	9	return array_values($this->errorMessages);
226		}
227
228		/**
229		* @return string
230		*/
231	27	public function getLabel()
232		{
233	27	return $this->label;
234		}
235
236		/**
237		* @param string $label
238		* @return $this
239		*/
240	17	public function setLabel($label)
241		{
242	17	$this->label = $label;
243	17	return $this;
244		}
245
246		/**
247		* @param string $message
248		* @return $this
249		*/
250	5	public function setCustomErrorMessage($message)
251		{
252	5	$this->customErrorMessage = $message;
253	5	return $this;
254		}
255
256		/**
257		* @return bool
258		*/
259	4	public function hasCustomErrorMessage()
260		{
261	4	return $this->customErrorMessage != null;
262		}
263
264		/**
265		* @return string
266		*/
267	2	public function getCustomErrorMessage()
268		{
269	2	return $this->customErrorMessage;
270		}
271
272		/**
273		* @return FieldRendererInterface
274		*/
275	28	public function getRenderer()
276		{
277	28	return $this->renderer;
278		}
279
280		/**
281		* @param FieldRendererInterface $renderer
282		* @return $this
283		*/
284	32	public function setRenderer(FieldRendererInterface $renderer)
285		{
286	32	$this->renderer = $renderer;
287	32	return $this;
288		}
289
290		/**
291		* If a field is required then it must have a value
292		* We add a not empty validator
293		*
294		* @return boolean
295		*/
296	33	public function isRequired()
297		{
298	33	return $this->required;
299		}
300
301		/**
302		* @param boolean $required
303		* @return FieldAbstract
304		*/
305	16	public function setRequired($required)
306		{
307	16	$required ? $this->addNotEmptyValidator() : $this->removeNotEmptyValidator();
308	16	$this->required = $required;
309	16	return $this;
310		}
311
312	16	private function addNotEmptyValidator()
313		{
314	16	$notEmpty = new NotEmpty();
315	16	$this->addValidator($notEmpty);
316	16	}
317
318	2	private function removeNotEmptyValidator()
319		{
320	2	$this->validatorCollection->rewind();
321	2	while ($this->validatorCollection->valid()) {
322	2	$validator = $this->validatorCollection->current();
323	2	$validator instanceof NotEmpty
324	2	? $this->validatorCollection->offsetUnset($this->validatorCollection->key())
325	1	: null;
326	2	$this->validatorCollection->next();
327		}
328	2	}
329
330		/**
331		* @param FormInterface $form
332		* @param $triggerValue
333		* @return $this
334		*/
335	3	public function addDynamicForm(FormInterface $form, $triggerValue)
336		{
337	3	$this->dynamicFormCollection[$triggerValue] = $form;
338	3	return $this;
339		}
340
341		/**
342		* @return bool
343		*/
344	33	public function hasDynamicForms()
345		{
346	33	return count($this->dynamicFormCollection) > 0;
347		}
348
349		/**
350		* @return FormInterface[]
351		* @throws Exception
352		*/
353	4	public function getDynamicForms()
354		{
355	4	if (!$this->hasDynamicForms()) {
356	1	throw new Exception('No dynamic form for this value - Did you check hasDynamicForm() ?');
357		}
358	3	return $this->dynamicFormCollection;
359		}
360		}

delboy1978uk / form

Push — master ( 312f5c...551479 )

FieldAbstract B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

33 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like