Field::setRequired() - Code Metrics - Inspection of "kolekcja nie bedzie NULL-em tylko bedzie posiadala..." - adam-boduch/coyote - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (249862)

by Adam

created 2018-02-13 08:46 UTC

Field::setRequired() A

↳ Parent: Field

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Coyote\Services\FormBuilder\Fields;

use Coyote\Services\FormBuilder\Form;
use Coyote\Services\FormBuilder\RenderTrait;
use Illuminate\Database\Eloquent\Model;

abstract class Field
{
    use RenderTrait;

    const DEFAULT_TEMPLATE = 'row';

    /**
     * @var string
     */
    protected $name;

    /**
     * @var mixed
     */
    protected $value;

    /**
     * @var string
     */
    protected $type;

    /**
     * @var Form
     */
    protected $parent;

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

    /**
     * @var string
     */
    protected $help;

    /**
     * @var string
     */
    protected $theme;

    /**
     * @var string
     */
    protected $template = self::DEFAULT_TEMPLATE;

    /**
     * @var string
     */
    protected $rules;

    /**
     * @var array
     */
    protected $attr = [];

    /**
     * @var array
     */
    protected $labelAttr = [];

    /**
     * @var array
     */
    protected $rowAttr = [];

    /**
     * @var array
     */
    protected $helpAttr = [];

    /**
     * Name of the property for value setting
     *
     * @var string
     */
    protected $valueProperty = 'value';

    /**
     * @var bool
     */
    protected $required = false;

    /**
     * Field constructor.
     * @param $name
     * @param $type
     * @param Form $parent
     * @param array $options
     */
    public function __construct($name, $type, Form $parent, array $options = [])
    {
        $this->setName($name);
        $this->setType($type);
        $this->setParent($parent);

        // 1) Set up options (attributes, field value)
        $this->setDefaultOptions($options);
        // 2) Set up the value (from model, request, session etc) if it wasn't set before
        $this->setupValue();
    }

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

    /**
     * @param mixed $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

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

    /**
     * Set value (can be string, can be array etc)
     *
     * @param mixed $value
     */
    public function setValue($value)
    {
        $this->value = $value;
    }

    /**
     * @param string $type
     * @return $this
     */
    protected function setType($type)
    {
        $this->type = $type;
        return $this;
    }

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

    /**
     * @param Form $parent
     * @return $this
     */
    protected function setParent(Form $parent)
    {
        $this->parent = $parent;
        return $this;
    }

    /**
     * @return Form
     */
    public function getParent()
    {
        return $this->parent;
    }

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

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

    /**
     * @param string $rules
     * @return $this
     */
    public function setRules($rules)
    {
        $this->rules = $rules;

        if (is_string($rules)) {

            $rules = explode('|', $rules);

            if (in_array('required', $rules)) {
                $this->setRequired(true);
            }
        }
        return $this;
    }

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

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

    /**
     * @param mixed $help
     */
    public function setHelp($help)
    {
        $this->help = $help;
    }

    /**
     * @return array
     */
    public function getAttr()
    {
        return $this->attr;
    }

    /**
     * @param array $attr
     */
    public function setAttr($attr)
    {
        $this->attr = $attr;
    }

    /**
     * @return array
     */
    public function getLabelAttr()
    {
        return $this->labelAttr;
    }

    /**
     * @param array $labelAttr
     */
    public function setLabelAttr($labelAttr)
    {
        $this->labelAttr = $labelAttr;
    }

    /**
     * @return array
     */
    public function getRowAttr()
    {
        return $this->rowAttr;
    }

    /**
     * @param array $rowAttr
     */
    public function setRowAttr($rowAttr)
    {
        $this->rowAttr = $rowAttr;
    }

    /**
     * @return array
     */
    public function getHelpAttr()
    {
        return $this->helpAttr;
    }

    /**
     * @param array $helpAttr
     * @return $this
     */
    public function setHelpAttr($helpAttr)
    {
        $this->helpAttr = $helpAttr;

        return $this;
    }

    /**
     * @return boolean
     */
    public function isRequired()
    {
        return $this->required;
    }

    /**
     * Method alias
     *
     * @return bool
     */
    public function getRequired()
    {
        return $this->isRequired();
    }

    /**
     * @param boolean $required
     * @return $this
     */
    public function setRequired($required)
    {
        $this->required = $required;

        return $this;
    }

    /**
     * @param array $options
     * @return $this
     */
    public function mergeOptions(array $options)
    {
        $reflection = new \ReflectionClass($this);

        foreach ($options as $key => $values) {
            $baseName = ucfirst(camel_case($key));
            $setter = 'set' . $baseName;

            if (method_exists($this, $setter)) {
                $getter = 'get' . $baseName;

                if ($reflection->hasMethod($getter)
                    && $reflection->getMethod($getter)->getNumberOfParameters() === 0) {
                    $currentValue = $this->$getter();

                    if (is_array($currentValue)) {
                        $values = $this->arrayMerge($currentValue, $values);
                    }
                }
                $this->$setter($values);
            }
        }

        return $this;
    }

    /**
     * @param array $old
     * @param array $new
     * @return array
     */
    protected function arrayMerge($old, $new)
    {
        return array_merge($old, $new);
    }

    /**
     * @return array|null
     */
    public function getErrors()
    {
        return $this->parent->errors() ? $this->parent->errors()->get($this->transformToDotSyntax($this->name)) : null;
    }

    /**
     * @return string|null
     */
    public function getError()
    {
        return $this->parent->errors() ? $this->parent->errors()->first($this->transformToDotSyntax($this->name)) : null;
    }

    /**
     * @return string
     * @throws \Exception
     * @throws \Throwable
     */
    public function renderLabel()
    {
        return $this->view($this->getViewPath('label'), $this->viewData())->render();
    }

    /**
     * @return string
     * @throws \Exception
     * @throws \Throwable
     */
    public function renderWidget()
    {
        return $this->view($this->getWidgetPath(), $this->viewData())->render();
    }

    /**
     * @return string
     * @throws \Exception
     * @throws \Throwable
     */
    public function renderError()
    {
        return $this->view($this->getViewPath('error'), $this->viewData())->render();
    }

    /**
     * Render entire element
     *
     * @return mixed
     */
    public function render()
    {
        return $this->view($this->getViewPath($this->getTemplate()), $this->viewData())->render();
    }

    /**
     * Setup field value when initialized
     */
    protected function setupValue()
    {
        if ($this->parent->isSubmitted()) {
            $this->setValue($this->parent->getRequest()->get($this->name));
        } elseif ($this->hasOldInput($this->name)) {
            $this->setValue($this->getOldInput($this->name));
        // we set value from model/object/array only if current value is empty.
            // that's because we can set custom value in form class and we DO NOT want
            // overwrite this here:
        } elseif ($this->value === null && !($this instanceof ChildForm)) {
            $this->setValue($this->getDataValue($this->parent->getData(), $this->name));
        }
    }

    /**
     * @param mixed $data
     * @param string $name
     * @return mixed|null
     */
    protected function getDataValue($data, $name)
    {
        $name = $this->transformToDotSyntax($name);
        $data = $this->loadModelRelation($data, $name);

        if (is_string($data)) {
            return $data;
        } elseif (is_array($data) || $data instanceof \ArrayAccess) {
            return array_get($data, $name);
        } elseif (is_object($data)) {
            return object_get($data, $name);
        }

        return $this->getValue();
    }

    /**
     * @param string $key
     * @return string
     */
    protected function getOldInput($key)
    {
        return $this->parent->getRequest()->session()->getOldInput($key);
    }

    /**
     * @param string $key
     * @return bool
     */
    protected function hasOldInput($key)
    {
        return $this->parent->getRequest()->session()->hasOldInput($key);
    }

    /**
     * If object is a instance of Eloquent model, we have to make sure that relations were loaded
     *
     * @param $model
     * @param string $key
     * @return mixed
     */
    protected function loadModelRelation($model, $key)
    {
        if (!($model instanceof Model)) {
            return $model;
        }

        if (!isset($model->$key) && method_exists($model, $key)) {
            $model->getRelationValue($key);
        }

        return $model;
    }

    /**
     * @return array
     */
    protected function viewData()
    {
        $result = [];

        $reflection = new \ReflectionClass($this);

        foreach ($reflection->getMethods() as $method) {
            $name = $method->getName();
            $snakeCase = snake_case($name);
            $prefix = substr($snakeCase, 0, strpos($snakeCase, '_'));

            if (in_array($prefix, ['get', 'is']) && $method->getNumberOfParameters() === 0 && !$method->isPrivate() && $name !== 'getParent') {
                $withoutPrefix = $snakeCase;

                if ($prefix === 'get') {
                    $withoutPrefix = substr($withoutPrefix, 4);
                }
                $result[$withoutPrefix] = $this->$name();
            }
        }

        return $result;
    }

    /**
     * @return string
     */
    protected function getWidgetName()
    {
        return $this->getType() . '_widget';
    }

    /**
     * @param array $options
     */
    protected function setDefaultOptions(array $options)
    {
        // if default value was provided, we would like to set it at the end after all other options
        // because setting value can modify children elements in Collection.php. Before creating children
        // forms, we want to make sure that other options have been set.
        $defaultValue = array_pull($options, 'value');

        foreach ($options as $key => $values) {
            $methodName = 'set' . ucfirst(camel_case($key));

            if (method_exists($this, $methodName)) {
                $this->$methodName($values);
            }
        }

        if ($defaultValue !== null) {
            $this->setValue($defaultValue);
        }
    }

    /**
     * @param string $string
     * @return string
     */
    public function transformToDotSyntax($string)
    {
        return str_replace(['.', '[]', '[', ']'], ['_', '', '.', ''], $string);
    }

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


1			<?php
2
3			namespace Coyote\Services\FormBuilder\Fields;
4
5			use Coyote\Services\FormBuilder\Form;
6			use Coyote\Services\FormBuilder\RenderTrait;
7			use Illuminate\Database\Eloquent\Model;
8
9			abstract class Field
10			{
11			use RenderTrait;
12
13			const DEFAULT_TEMPLATE = 'row';
14
15			/**
16			* @var string
17			*/
18			protected $name;
19
20			/**
21			* @var mixed
22			*/
23			protected $value;
24
25			/**
26			* @var string
27			*/
28			protected $type;
29
30			/**
31			* @var Form
32			*/
33			protected $parent;
34
35			/**
36			* @var string
37			*/
38			protected $label;
39
40			/**
41			* @var string
42			*/
43			protected $help;
44
45			/**
46			* @var string
47			*/
48			protected $theme;
49
50			/**
51			* @var string
52			*/
53			protected $template = self::DEFAULT_TEMPLATE;
54
55			/**
56			* @var string
57			*/
58			protected $rules;
59
60			/**
61			* @var array
62			*/
63			protected $attr = [];
64
65			/**
66			* @var array
67			*/
68			protected $labelAttr = [];
69
70			/**
71			* @var array
72			*/
73			protected $rowAttr = [];
74
75			/**
76			* @var array
77			*/
78			protected $helpAttr = [];
79
80			/**
81			* Name of the property for value setting
82			*
83			* @var string
84			*/
85			protected $valueProperty = 'value';
86
87			/**
88			* @var bool
89			*/
90			protected $required = false;
91
92			/**
93			* Field constructor.
94			* @param $name
95			* @param $type
96			* @param Form $parent
97			* @param array $options
98			*/
99			public function __construct($name, $type, Form $parent, array $options = [])
100			{
101			$this->setName($name);
102			$this->setType($type);
103			$this->setParent($parent);
104
105			// 1) Set up options (attributes, field value)
106			$this->setDefaultOptions($options);
107			// 2) Set up the value (from model, request, session etc) if it wasn't set before
108			$this->setupValue();
109			}
110
111			/**
112			* @return string
113			*/
114			public function getName()
115			{
116			return $this->name;
117			}
118
119			/**
120			* @param mixed $name
121			*/
122			public function setName($name)
123			{
124			$this->name = $name;
125			}
126
127			/**
128			* @return mixed
129			*/
130			public function getValue()
131			{
132			return $this->value;
133			}
134
135			/**
136			* Set value (can be string, can be array etc)
137			*
138			* @param mixed $value
139			*/
140			public function setValue($value)
141			{
142			$this->value = $value;
143			}
144
145			/**
146			* @param string $type
147			* @return $this
148			*/
149			protected function setType($type)
150			{
151			$this->type = $type;
152			return $this;
153			}
154
155			/**
156			* @return string
157			*/
158			public function getType()
159			{
160			return $this->type;
161			}
162
163			/**
164			* @param Form $parent
165			* @return $this
166			*/
167			protected function setParent(Form $parent)
168			{
169			$this->parent = $parent;
170			return $this;
171			}
172
173			/**
174			* @return Form
175			*/
176			public function getParent()
177			{
178			return $this->parent;
179			}
180
181			/**
182			* @return string
183			*/
184			public function getLabel()
185			{
186			return $this->label;
187			}
188
189			/**
190			* @param string $label
191			*/
192			public function setLabel($label)
193			{
194			$this->label = $label;
195			}
196
197			/**
198			* @param string $rules
199			* @return $this
200			*/
201			public function setRules($rules)
202			{
203			$this->rules = $rules;
204
205			if (is_string($rules)) {
			0 ignored issues – show introduced 2018-02-09 13:08 UTC by Report Bug Copy Issue Report The condition `is_string($rules)` can never be `false`. Loading history...
206			$rules = explode('\|', $rules);
207
208			if (in_array('required', $rules)) {
209			$this->setRequired(true);
210			}
211			}
212			return $this;
213			}
214
215			/**
216			* @return string
217			*/
218			public function getRules()
219			{
220			return $this->rules;
221			}
222
223			/**
224			* @return string
225			*/
226			public function getHelp()
227			{
228			return $this->help;
229			}
230
231			/**
232			* @param mixed $help
233			*/
234			public function setHelp($help)
235			{
236			$this->help = $help;
237			}
238
239			/**
240			* @return array
241			*/
242			public function getAttr()
243			{
244			return $this->attr;
245			}
246
247			/**
248			* @param array $attr
249			*/
250			public function setAttr($attr)
251			{
252			$this->attr = $attr;
253			}
254
255			/**
256			* @return array
257			*/
258			public function getLabelAttr()
259			{
260			return $this->labelAttr;
261			}
262
263			/**
264			* @param array $labelAttr
265			*/
266			public function setLabelAttr($labelAttr)
267			{
268			$this->labelAttr = $labelAttr;
269			}
270
271			/**
272			* @return array
273			*/
274			public function getRowAttr()
275			{
276			return $this->rowAttr;
277			}
278
279			/**
280			* @param array $rowAttr
281			*/
282			public function setRowAttr($rowAttr)
283			{
284			$this->rowAttr = $rowAttr;
285			}
286
287			/**
288			* @return array
289			*/
290			public function getHelpAttr()
291			{
292			return $this->helpAttr;
293			}
294
295			/**
296			* @param array $helpAttr
297			* @return $this
298			*/
299			public function setHelpAttr($helpAttr)
300			{
301			$this->helpAttr = $helpAttr;
302
303			return $this;
304			}
305
306			/**
307			* @return boolean
308			*/
309			public function isRequired()
310			{
311			return $this->required;
312			}
313
314			/**
315			* Method alias
316			*
317			* @return bool
318			*/
319			public function getRequired()
320			{
321			return $this->isRequired();
322			}
323
324			/**
325			* @param boolean $required
326			* @return $this
327			*/
328			public function setRequired($required)
329			{
330			$this->required = $required;
331
332			return $this;
333			}
334
335			/**
336			* @param array $options
337			* @return $this
338			*/
339			public function mergeOptions(array $options)
340			{
341			$reflection = new \ReflectionClass($this);
342
343			foreach ($options as $key => $values) {
344			$baseName = ucfirst(camel_case($key));
345			$setter = 'set' . $baseName;
346
347			if (method_exists($this, $setter)) {
348			$getter = 'get' . $baseName;
349
350			if ($reflection->hasMethod($getter)
351			&& $reflection->getMethod($getter)->getNumberOfParameters() === 0) {
352			$currentValue = $this->$getter();
353
354			if (is_array($currentValue)) {
355			$values = $this->arrayMerge($currentValue, $values);
356			}
357			}
358			$this->$setter($values);
359			}
360			}
361
362			return $this;
363			}
364
365			/**
366			* @param array $old
367			* @param array $new
368			* @return array
369			*/
370			protected function arrayMerge($old, $new)
371			{
372			return array_merge($old, $new);
373			}
374
375			/**
376			* @return array\|null
377			*/
378			public function getErrors()
379			{
380			return $this->parent->errors() ? $this->parent->errors()->get($this->transformToDotSyntax($this->name)) : null;
381			}
382
383			/**
384			* @return string\|null
385			*/
386			public function getError()
387			{
388			return $this->parent->errors() ? $this->parent->errors()->first($this->transformToDotSyntax($this->name)) : null;
389			}
390
391			/**
392			* @return string
393			* @throws \Exception
394			* @throws \Throwable
395			*/
396			public function renderLabel()
397			{
398			return $this->view($this->getViewPath('label'), $this->viewData())->render();
399			}
400
401			/**
402			* @return string
403			* @throws \Exception
404			* @throws \Throwable
405			*/
406			public function renderWidget()
407			{
408			return $this->view($this->getWidgetPath(), $this->viewData())->render();
409			}
410
411			/**
412			* @return string
413			* @throws \Exception
414			* @throws \Throwable
415			*/
416			public function renderError()
417			{
418			return $this->view($this->getViewPath('error'), $this->viewData())->render();
419			}
420
421			/**
422			* Render entire element
423			*
424			* @return mixed
425			*/
426			public function render()
427			{
428			return $this->view($this->getViewPath($this->getTemplate()), $this->viewData())->render();
429			}
430
431			/**
432			* Setup field value when initialized
433			*/
434			protected function setupValue()
435			{
436			if ($this->parent->isSubmitted()) {
437			$this->setValue($this->parent->getRequest()->get($this->name));
438			} elseif ($this->hasOldInput($this->name)) {
439			$this->setValue($this->getOldInput($this->name));
440			// we set value from model/object/array only if current value is empty.
441			// that's because we can set custom value in form class and we DO NOT want
442			// overwrite this here:
443			} elseif ($this->value === null && !($this instanceof ChildForm)) {
444			$this->setValue($this->getDataValue($this->parent->getData(), $this->name));
445			}
446			}
447
448			/**
449			* @param mixed $data
450			* @param string $name
451			* @return mixed\|null
452			*/
453			protected function getDataValue($data, $name)
454			{
455			$name = $this->transformToDotSyntax($name);
456			$data = $this->loadModelRelation($data, $name);
457
458			if (is_string($data)) {
459			return $data;
460			} elseif (is_array($data) \|\| $data instanceof \ArrayAccess) {
461			return array_get($data, $name);
462			} elseif (is_object($data)) {
463			return object_get($data, $name);
464			}
465
466			return $this->getValue();
467			}
468
469			/**
470			* @param string $key
471			* @return string
472			*/
473			protected function getOldInput($key)
474			{
475			return $this->parent->getRequest()->session()->getOldInput($key);
476			}
477
478			/**
479			* @param string $key
480			* @return bool
481			*/
482			protected function hasOldInput($key)
483			{
484			return $this->parent->getRequest()->session()->hasOldInput($key);
485			}
486
487			/**
488			* If object is a instance of Eloquent model, we have to make sure that relations were loaded
489			*
490			* @param $model
491			* @param string $key
492			* @return mixed
493			*/
494			protected function loadModelRelation($model, $key)
495			{
496			if (!($model instanceof Model)) {
497			return $model;
498			}
499
500			if (!isset($model->$key) && method_exists($model, $key)) {
501			$model->getRelationValue($key);
502			}
503
504			return $model;
505			}
506
507			/**
508			* @return array
509			*/
510			protected function viewData()
511			{
512			$result = [];
513
514			$reflection = new \ReflectionClass($this);
515
516			foreach ($reflection->getMethods() as $method) {
517			$name = $method->getName();
518			$snakeCase = snake_case($name);
519			$prefix = substr($snakeCase, 0, strpos($snakeCase, '_'));
520
521			if (in_array($prefix, ['get', 'is']) && $method->getNumberOfParameters() === 0 && !$method->isPrivate() && $name !== 'getParent') {
522			$withoutPrefix = $snakeCase;
523
524			if ($prefix === 'get') {
525			$withoutPrefix = substr($withoutPrefix, 4);
526			}
527			$result[$withoutPrefix] = $this->$name();
528			}
529			}
530
531			return $result;
532			}
533
534			/**
535			* @return string
536			*/
537			protected function getWidgetName()
538			{
539			return $this->getType() . '_widget';
540			}
541
542			/**
543			* @param array $options
544			*/
545			protected function setDefaultOptions(array $options)
546			{
547			// if default value was provided, we would like to set it at the end after all other options
548			// because setting value can modify children elements in Collection.php. Before creating children
549			// forms, we want to make sure that other options have been set.
550			$defaultValue = array_pull($options, 'value');
551
552			foreach ($options as $key => $values) {
553			$methodName = 'set' . ucfirst(camel_case($key));
554
555			if (method_exists($this, $methodName)) {
556			$this->$methodName($values);
557			}
558			}
559
560			if ($defaultValue !== null) {
561			$this->setValue($defaultValue);
562			}
563			}
564
565			/**
566			* @param string $string
567			* @return string
568			*/
569			public function transformToDotSyntax($string)
570			{
571			return str_replace(['.', '[]', '[', ']'], ['_', '', '.', ''], $string);
572			}
573
574			/**
575			* @return string
576			*/
577			public function __toString()
578			{
579			return $this->getValue();
580			}
581			}
582

adam-boduch / coyote

Branch — master (249862)

Field::setRequired() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like