Field - Code Metrics - Inspection of "8e0976e81dc9a8030756bfbdbd01fa2082947fd7" - adam-boduch/coyote - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (8e0976)

by Adam

created 2019-01-22 06:23 UTC

Field F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	573
Duplicated Lines	1.22 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
dl	7
loc	573
rs	2.56
c	0
b	0
f	0
wmc	73
lcom	1
cbo	5

44 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getName()	0	4	1
A	setName()	0	4	1
A	getValue()	0	4	1
A	setValue()	0	4	1
A	setType()	0	5	1
A	getType()	0	4	1
A	setParent()	0	5	1
A	getParent()	0	4	1
A	getLabel()	0	4	1
A	setLabel()	0	4	1
A	setRules()	0	13	3
A	getRules()	0	4	1
A	getHelp()	0	4	1
A	setHelp()	0	4	1
A	getAttr()	0	4	1
A	setAttr()	0	4	1
A	getLabelAttr()	0	4	1
A	setLabelAttr()	0	4	1
A	getRowAttr()	0	4	1
A	setRowAttr()	0	4	1
A	getHelpAttr()	0	4	1
A	setHelpAttr()	0	6	1
A	isRequired()	0	4	1
A	getRequired()	0	4	1
A	setRequired()	0	6	1
B	mergeOptions()	0	25	6
A	arrayMerge()	0	4	1
A	getErrors()	0	4	2
A	getError()	0	4	2
A	renderLabel()	0	4	1
A	renderWidget()	0	4	1
A	renderError()	0	4	1
A	render()	0	4	1
A	setupValue()	0	13	5
A	getDataValue()	0	15	5
A	getOldInput()	0	4	1
A	hasOldInput()	0	4	1
A	loadModelRelation()	0	12	4
B	viewData()	0	23	7
A	getWidgetName()	0	4	1
A	setDefaultOptions()	7	19	4
A	transformToDotSyntax()	0	4	1
A	__toString()	0	4	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 Field 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 Field, and based on these observations, apply Extract Interface, too.

<?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)) {
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);
		0 ignored issues – show Bug introduced 2017-06-03 14:37 UTC by Report Bug Copy Issue Report The method `getOldInput()` does not seem to exist on `object<Symfony\Component...ssion\SessionInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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);
		0 ignored issues – show Bug introduced 2017-06-03 14:37 UTC by Report Bug Copy Issue Report The method `hasOldInput()` does not seem to exist on `object<Symfony\Component...ssion\SessionInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
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();
		0 ignored issues – show Bug introduced 2016-04-26 05:54 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
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	View Code Duplication	foreach ($options as $key => $values) {
		0 ignored issues – show Duplication introduced 2016-04-26 05:54 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
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