FieldSet::offsetSet() - Code Metrics - slickframework/form - Measure and Improve Code Quality continuously with Scrutinizer

FieldSet::offsetSet() A
last analyzed 2017-02-06 17:13 UTC

↳ Parent: FieldSet

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2
crap	1

<?php

/**
 * This file is part of slick/form package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Form\Element;

use Slick\Common\Utils\Collection\AbstractCollection;
use Slick\Form\ElementInterface;
use Slick\Form\Input\ValidationAwareInterface;
use Slick\Form\InputInterface;
use Slick\Form\Renderer\FieldSet as FieldSetRenderer;
use Slick\Form\Renderer\RendererInterface;

/**
 * FieldSet
 *
 * @package Slick\Form\Element
 */
class FieldSet extends AbstractCollection implements ContainerInterface
{

    /**
     * @var array
     */
    protected $settings = [];
    
    /**
     * Add attribute manipulation methods
     */
    use AttributesAwareMethods;

    /**
     * Add render capabilities to element
     */
    use RenderAwareMethods;

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

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

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

    /**
     * Checks if all elements are valid
     *
     * @return mixed
     */
    public function isValid()
    {
        $valid = true;
        $this->validate();
        foreach ($this->getIterator() as $element) {
            if ($element instanceof ValidationAwareInterface) {
                $valid = $element->isValid()
                    ? $valid
                    : false;
            }
        }
        return $valid;
    }

    /**
     * Adds an element to the container
     *
     * @param ElementInterface $element
     *
     * @return self|$this|ContainerInterface
     */
    public function add(ElementInterface $element)
    {
        if (null === $element->getName()) {
            $this->data[] = $element;
            return $this;
        }
        $this->data[$element->getName()] = $element;
        return $this;
    }

    /**
     * Gets element by name
     *
     * @param string $name
     *
     * @return null|ElementInterface|InputInterface
     */
    public function get($name)
    {
        $selected = null;
        /** @var ElementInterface|ContainerInterface $element */
        foreach ($this as $element) {
            if ($element->getName() == $name) {
                $selected = $element;
                break;
            }

            if ($element instanceof ContainerInterface) {
                $selected = $element->get($name);
                if (null !== $selected) {
                    break;
                }
            }
        }

        return $selected;
    }

    /**
     * Sets the values form matched elements
     *
     * The passed array is a key/value array where keys are used to
     * match against element names. It will only assign the value to
     * the marched element only.
     *
     * @param array $values
     *
     * @return self|$this|ContainerInterface
     */
    public function setValues(array $values)
    {
        foreach ($values as $name => $value) {
            if ($element = $this->get($name)) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                $element->setValue($value);
            }
        }
        return $this;
    }

    /**
     * Gets the element value
     *
     * This value here is just a string and it can be the content that
     * goes inside <label> tags for example.
     *
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * Returns element name.
     *
     * This name can be null however a form or field set will use it
     * in the FormInterface::get() method to retrieve it.
     *
     * @return mixed
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set element name
     *
     * @param string $name
     * @return $this|self|FieldSet
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }

    /**
     * Sets the value or content of the element
     *
     * @param mixed $value
     *
     * @return self|$this|FieldSet
     */
    public function setValue($value)
    {
        $this->value = $value;
        return $this;
    }

    /**
     * Adds an element to the collection
     *
     * @param mixed $offset unused
     * @param ElementInterface $value
     */
    public function offsetSet($offset, $value)
    {
        $this->add($value);
    }

    /**
     * Gets the HTML renderer for this element
     *
     * @return RendererInterface
     */
    protected function getRenderer()
    {
        return new FieldSetRenderer($this);
    }

    /**
     * Runs validation chain in all its elements
     *
     * @return self|$this|ElementInterface
     */
    public function validate()
    {
        foreach ($this as $element) {

            if (
                $element instanceof ValidationAwareInterface ||
                $element instanceof ContainerInterface
            ) {
                $element->validate();
            }
        }
        return $this;
    }

    /**
     * Set other input settings
     *
     * @param array $settings
     * @return self|AbstractElement
     */
    public function setSettings(array $settings)
    {
        $this->settings = array_merge($this->settings, $settings);
        return $this;
    }

    /**
     * Set rendering state
     *
     * @param bool $state
     *
     * @return FieldSet
     */
    public function setRendering($state)
    {
        $this->rendering = $state;
        return $this;
    }
}

1		<?php
2
3		/**
4		* This file is part of slick/form package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Form\Element;
11
12		use Slick\Common\Utils\Collection\AbstractCollection;
13		use Slick\Form\ElementInterface;
14		use Slick\Form\Input\ValidationAwareInterface;
15		use Slick\Form\InputInterface;
16		use Slick\Form\Renderer\FieldSet as FieldSetRenderer;
17		use Slick\Form\Renderer\RendererInterface;
18
19		/**
20		* FieldSet
21		*
22		* @package Slick\Form\Element
23		*/
24		class FieldSet extends AbstractCollection implements ContainerInterface
25		{
26
27		/**
28		* @var array
29		*/
30		protected $settings = [];
31
32		/**
33		* Add attribute manipulation methods
34		*/
35		use AttributesAwareMethods;
36
37		/**
38		* Add render capabilities to element
39		*/
40		use RenderAwareMethods;
41
42		/**
43		* @var string
44		*/
45		protected $name;
46
47		/**
48		* @var string
49		*/
50		protected $value;
51
52		/**
53		* @var bool
54		*/
55		protected $rendering = false;
56
57		/**
58		* Checks if all elements are valid
59		*
60		* @return mixed
61		*/
62	4	public function isValid()
63		{
64	4	$valid = true;
65	4	$this->validate();
66	4	foreach ($this->getIterator() as $element) {
67	4	if ($element instanceof ValidationAwareInterface) {
68	4	$valid = $element->isValid()
69	4	? $valid
70	4	: false;
71	4	}
72	4	}
73	4	return $valid;
74		}
75
76		/**
77		* Adds an element to the container
78		*
79		* @param ElementInterface $element
80		*
81		* @return self\|$this\|ContainerInterface
82		*/
83	52	public function add(ElementInterface $element)
84		{
85	52	if (null === $element->getName()) {
86	4	$this->data[] = $element;
87	4	return $this;
88		}
89	52	$this->data[$element->getName()] = $element;
90	52	return $this;
91		}
92
93		/**
94		* Gets element by name
95		*
96		* @param string $name
97		*
98		* @return null\|ElementInterface\|InputInterface
99		*/
100	14	public function get($name)
101		{
102	14	$selected = null;
103		/** @var ElementInterface\|ContainerInterface $element */
104	14	foreach ($this as $element) {
105	14	if ($element->getName() == $name) {
106	14	$selected = $element;
107	14	break;
108		}
109
110	4	if ($element instanceof ContainerInterface) {
111	2	$selected = $element->get($name);
112	2	if (null !== $selected) {
113	2	break;
114		}
115	2	}
116	14	}
117
118	14	return $selected;
119		}
120
121		/**
122		* Sets the values form matched elements
123		*
124		* The passed array is a key/value array where keys are used to
125		* match against element names. It will only assign the value to
126		* the marched element only.
127		*
128		* @param array $values
129		*
130		* @return self\|$this\|ContainerInterface
131		*/
132	2	public function setValues(array $values)
133		{
134	2	foreach ($values as $name => $value) {
135	2	if ($element = $this->get($name)) {
		0 ignored issues – show Bug introduced 2016-02-24 17:15 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$element` is correct as `$this->get($name)` (which targets `Slick\Form\Element\FieldSet::get()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
136	2	$element->setValue($value);
137	2	}
138	2	}
139	2	return $this;
140		}
141
142		/**
143		* Gets the element value
144		*
145		* This value here is just a string and it can be the content that
146		* goes inside <label> tags for example.
147		*
148		* @return mixed
149		*/
150	4	public function getValue()
151		{
152	4	return $this->value;
153		}
154
155		/**
156		* Returns element name.
157		*
158		* This name can be null however a form or field set will use it
159		* in the FormInterface::get() method to retrieve it.
160		*
161		* @return mixed
162		*/
163	36	public function getName()
164		{
165	36	return $this->name;
166		}
167
168		/**
169		* Set element name
170		*
171		* @param string $name
172		* @return $this\|self\|FieldSet
173		*/
174	32	public function setName($name)
175		{
176	32	$this->name = $name;
177	32	return $this;
178		}
179
180		/**
181		* Sets the value or content of the element
182		*
183		* @param mixed $value
184		*
185		* @return self\|$this\|FieldSet
186		*/
187	4	public function setValue($value)
188		{
189	4	$this->value = $value;
190	4	return $this;
191		}
192
193		/**
194		* Adds an element to the collection
195		*
196		* @param mixed $offset unused
197		* @param ElementInterface $value
198		*/
199	2	public function offsetSet($offset, $value)
200		{
201	2	$this->add($value);
202	2	}
203
204		/**
205		* Gets the HTML renderer for this element
206		*
207		* @return RendererInterface
208		*/
209	2	protected function getRenderer()
210		{
211	2	return new FieldSetRenderer($this);
212		}
213
214		/**
215		* Runs validation chain in all its elements
216		*
217		* @return self\|$this\|ElementInterface
218		*/
219	4	public function validate()
220		{
221	4	foreach ($this as $element) {
222
223		if (
224	4	$element instanceof ValidationAwareInterface \|\|
225		$element instanceof ContainerInterface
226	4	) {
227	4	$element->validate();
228	4	}
229	4	}
230	4	return $this;
231		}
232
233		/**
234		* Set other input settings
235		*
236		* @param array $settings
237		* @return self\|AbstractElement
238		*/
239		public function setSettings(array $settings)
240		{
241		$this->settings = array_merge($this->settings, $settings);
242		return $this;
243		}
244
245		/**
246		* Set rendering state
247		*
248		* @param bool $state
249		*
250		* @return FieldSet
251		*/
252	4	public function setRendering($state)
253		{
254	4	$this->rendering = $state;
255	4	return $this;
256		}
257		}

slickframework / form

FieldSet::offsetSet() A last analyzed 2017-02-06 17:13 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

FieldSet::offsetSet() A
last analyzed 2017-02-06 17:13 UTC