CompositeField::setDisabled() - Code Metrics - Inspection of "FIX: Remap obsolete ClassName values." - sminnee/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — correct-classname-values ( f9b487 )

by Sam

created 2016-07-25 06:37 UTC

CompositeField::setDisabled() A

↳ Parent: CompositeField

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php
/**
 * Base class for all fields that contain other fields.
 *
 * Implements sequentialisation - so that when we're saving / loading data, we
 * can populate a tabbed form properly. All of the children are stored in
 * $this->children
 *
 * @package forms
 * @subpackage fields-structural
 */
class CompositeField extends FormField {

	/**
	 * @var FieldList
	 */
	protected $children;

	/**
	 * Set to true when this field is a readonly field
	 */
	protected $readonly;

	/**
	 * @var $columnCount int Toggle different css-rendering for multiple columns
	 * ("onecolumn", "twocolumns", "threecolumns"). The content is determined
	 * by the $children-array, so wrap all items you want to have grouped in a
	 * column inside a CompositeField.
	 * Caution: Please make sure that this variable actually matches the
	 * count of your $children.
	 */
	protected $columnCount = null;

	/**
	 * @var String custom HTML tag to render with, e.g. to produce a <fieldset>.
	 */
	protected $tag = 'div';

	/**
	 * @var String Optional description for this set of fields.
	 * If the {@link $tag} property is set to use a 'fieldset', this will be
	 * rendered as a <legend> tag, otherwise its a 'title' attribute.
	 */
	protected $legend;

	protected $schemaDataType = FormField::SCHEMA_DATA_TYPE_STRUCTURAL;

	public function __construct($children = null) {
		if($children instanceof FieldList) {
			$this->children = $children;
		} elseif(is_array($children)) {
			$this->children = new FieldList($children);
		} else {
			//filter out null/empty items
			$children = array_filter(func_get_args());
			$this->children = new FieldList($children);
		}
		$this->children->setContainerField($this);

		parent::__construct(null, false);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * Merge child field data into this form
	 */
	public function getSchemaDataDefaults() {
		$defaults = parent::getSchemaDataDefaults();
		$children = $this->getChildren();
		if($children && $children->count()) {
			$childSchema = [];
			/** @var FormField $child */
			foreach($children as $child) {
				$childSchema[] = $child->getSchemaData();
			}
			$defaults['children'] = $childSchema;
		}
		return $defaults;
	}

	/**
	 * Returns all the sub-fields, suitable for <% loop FieldList %>
	 *
	 * @return FieldList
	 */
	public function FieldList() {
		return $this->children;
	}

	/**
	 * Accessor method for $this->children
	 *
	 * @return FieldList
	 */
	public function getChildren() {
		return $this->children;
	}

	/**
	 * @param FieldList $children
	 * @return $this
	 */
	public function setChildren($children) {
		$this->children = $children;
		return $this;
	}

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

		return $this;
	}

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

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

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

	/**
	 * @deprecated
	 */
	public function extraClasses() {
		Deprecation::notice('4.0', 'Use extraClass() instead');
		return $this->extraClass();
	}

	public function extraClass() {
		$classes = array('field', 'CompositeField', parent::extraClass());
		if($this->columnCount) $classes[] = 'multicolumn';

		return implode(' ', $classes);
	}

	public function getAttributes() {
		return array_merge(
			parent::getAttributes(),
			array(
				'tabindex' => null,
				'type' => null,
				'value' => null,
				'title' => ($this->tag == 'fieldset') ? null : $this->legend
			)
		);
	}

	/**
	 * Add all of the non-composite fields contained within this field to the
	 * list.
	 *
	 * Sequentialisation is used when connecting the form to its data source
	 *
	 * @param array $list
	 * @param bool $saveableOnly
	 */
	public function collateDataFields(&$list, $saveableOnly = false) {
		foreach($this->children as $field) {
			if(! $field instanceof FormField) {
				continue;
			}
			if($field instanceof CompositeField) {
				$field->collateDataFields($list, $saveableOnly);
			}
			if($saveableOnly) {

				$isIncluded =  ($field->hasData() && !$field->isReadonly() && !$field->isDisabled());
			} else {
				$isIncluded =  ($field->hasData());
			}
			if($isIncluded) {
				$name = $field->getName();
				if($name) {
					$formName = (isset($this->form)) ? $this->form->FormName() : '(unknown form)';
					if(isset($list[$name])) {
						user_error("collateDataFields() I noticed that a field called '$name' appears twice in"
							. " your form: '{$formName}'.  One is a '{$field->class}' and the other is a"
							. " '{$list[$name]->class}'", E_USER_ERROR);
					}
					$list[$name] = $field;
				}
			}
		}
	}

	public function setForm($form) {
		foreach($this->getChildren() as $field) {
			if ($field instanceof FormField) {
				$field->setForm($form);
			}
		}

		parent::setForm($form);
		return $this;
	}



	public function setDisabled($disabled) {
		parent::setDisabled($disabled);
		foreach($this->getChildren() as $child) {
			$child->setDisabled($disabled);
		}
		return $this;
	}

	public function setReadonly($readonly)
	{
		parent::setReadonly($readonly);
		foreach($this->getChildren() as $child) {
			$child->setReadonly($readonly);
		}
		return $this;
	}

	public function setColumnCount($columnCount) {
		$this->columnCount = $columnCount;
		return $this;
	}

	public function getColumnCount() {
		return $this->columnCount;
	}

	public function isComposite() {
		return true;
	}

	public function hasData() {
		return false;
	}

	public function fieldByName($name) {
		return $this->children->fieldByName($name);
	}

	/**
	 * Add a new child field to the end of the set.
	 *
	 * @param FormField
	 */
	public function push(FormField $field) {
		$this->children->push($field);
	}

	/**
	 * Add a new child field to the beginning of the set.
	 *
	 * @param FormField
	 */
	public function unshift(FormField $field) {
		$this->children->unshift($field);
	}

	/**
	 * @uses FieldList->insertBefore()
	 *
	 * @param string $insertBefore
	 * @param FormField $field
	 * @return false|FormField
	 */
	public function insertBefore($insertBefore, $field) {
		return $this->children->insertBefore($insertBefore, $field);
	}

	/**
	 * @uses FieldList->insertAfter()
	 * @param string $insertAfter
	 * @param FormField $field
	 * @return false|FormField
	 */
	public function insertAfter($insertAfter, $field) {
		return $this->children->insertAfter($insertAfter, $field);
	}

	/**
	 * Remove a field from this CompositeField by Name.
	 * The field could also be inside a CompositeField.
	 *
	 * @param string $fieldName The name of the field
	 * @param boolean $dataFieldOnly If this is true, then a field will only
	 * be removed if it's a data field.  Dataless fields, such as tabs, will
	 * be left as-is.
	 */
	public function removeByName($fieldName, $dataFieldOnly = false) {
		$this->children->removeByName($fieldName, $dataFieldOnly);
	}

	public function replaceField($fieldName, $newField) {
		return $this->children->replaceField($fieldName, $newField);
	}

	public function rootFieldList() {
		if(is_object($this->containerFieldList)) return $this->containerFieldList->rootFieldList();
		else return $this->children;
	}

	public function __clone() {
		/** {@see FieldList::__clone(}} */
		$this->setChildren(clone $this->children);
	}

	/**
	 * Return a readonly version of this field. Keeps the composition but returns readonly
	 * versions of all the child {@link FormField} objects.
	 *
	 * @return CompositeField
	 */
	public function performReadonlyTransformation() {
		$newChildren = new FieldList();
		$clone = clone $this;
		if($clone->getChildren()) foreach($clone->getChildren() as $child) {

			/** @var FormField $child */
			$child = $child->transform(new ReadonlyTransformation());
			$newChildren->push($child);
		}

		$clone->setChildren($newChildren);
		$clone->setReadonly(true);
		$clone->addExtraClass($this->extraClass());
		$clone->setDescription($this->getDescription());

		return $clone;
	}

	/**
	 * Return a disabled version of this field. Keeps the composition but returns disabled
	 * versions of all the child {@link FormField} objects.
	 *
	 * @return CompositeField
	 */
	public function performDisabledTransformation() {
		$newChildren = new FieldList();
		$clone = clone $this;
		if($clone->getChildren()) foreach($clone->getChildren() as $child) {

			/** @var FormField $child */
			$child = $child->transform(new DisabledTransformation());
			$newChildren->push($child);
		}

		$clone->setChildren($newChildren);
		$clone->setDisabled(true);
		$clone->addExtraClass($this->extraClass());
		$clone->setDescription($this->getDescription());
		foreach($this->attributes as $k => $v) {
			$clone->setAttribute($k, $v);
		}

		return $clone;
	}

	public function IsReadonly() {
		return $this->readonly;
	}

	/**
	 * Find the numerical position of a field within
	 * the children collection. Doesn't work recursively.
	 *
	 * @param string|FormField
	 * @return int Position in children collection (first position starts with 0). Returns FALSE if the field can't
	 *             be found.
	 */
	public function fieldPosition($field) {

		if(is_string($field)) {
			$field = $this->fieldByName($field);
		}
		if(!$field) {
			return false;
		}

		$i = 0;
		foreach($this->children as $child) {
			/** @var FormField $child */
			if($child->getName() == $field->getName()) {
				return $i;
			}
			$i++;
		}

		return false;
	}

	/**
	 * Transform the named field into a readonly feld.
	 *
	 * @param string|FormField
	 * @return bool
	 */
	public function makeFieldReadonly($field) {
		$fieldName = ($field instanceof FormField) ? $field->getName() : $field;

		// Iterate on items, looking for the applicable field
		foreach($this->children as $i => $item) {
			if($item instanceof CompositeField) {
				if($item->makeFieldReadonly($fieldName)) {
					return true;
				};
			} elseif($item instanceof FormField && $item->getName() == $fieldName) {
				// Once it's found, use FormField::transform to turn the field into a readonly version of itself.
				$this->children->replaceField($fieldName, $item->transform(new ReadonlyTransformation()));

				// A true results indicates that the field was found
				return true;
			}
		}
		return false;
	}

	public function debug() {
		$result = "$this->class ($this->name) <ul>";
		foreach($this->children as $child) {
			$result .= "<li>" . Debug::text($child) . "&nbsp;</li>";
		}
		$result .= "</ul>";
		return $result;
	}

	/**
	 * Validate this field
	 *
	 * @param Validator $validator
	 * @return bool
	 */
	public function validate($validator) {
		$valid = true;
		foreach($this->children as $child){
			/** @var FormField $child */
			$valid = ($child && $child->validate($validator) && $valid);
		}
		return $valid;
	}

}


1		<?php
2		/**
3		* Base class for all fields that contain other fields.
4		*
5		* Implements sequentialisation - so that when we're saving / loading data, we
6		* can populate a tabbed form properly. All of the children are stored in
7		* $this->children
8		*
9		* @package forms
10		* @subpackage fields-structural
11		*/
12		class CompositeField extends FormField {
13
14		/**
15		* @var FieldList
16		*/
17		protected $children;
18
19		/**
20		* Set to true when this field is a readonly field
21		*/
22		protected $readonly;
23
24		/**
25		* @var $columnCount int Toggle different css-rendering for multiple columns
26		* ("onecolumn", "twocolumns", "threecolumns"). The content is determined
27		* by the $children-array, so wrap all items you want to have grouped in a
28		* column inside a CompositeField.
29		* Caution: Please make sure that this variable actually matches the
30		* count of your $children.
31		*/
32		protected $columnCount = null;
33
34		/**
35		* @var String custom HTML tag to render with, e.g. to produce a <fieldset>.
36		*/
37		protected $tag = 'div';
38
39		/**
40		* @var String Optional description for this set of fields.
41		* If the {@link $tag} property is set to use a 'fieldset', this will be
42		* rendered as a <legend> tag, otherwise its a 'title' attribute.
43		*/
44		protected $legend;
45
46		protected $schemaDataType = FormField::SCHEMA_DATA_TYPE_STRUCTURAL;
47
48		public function __construct($children = null) {
49		if($children instanceof FieldList) {
50		$this->children = $children;
51		} elseif(is_array($children)) {
52		$this->children = new FieldList($children);
53		} else {
54		//filter out null/empty items
55		$children = array_filter(func_get_args());
56		$this->children = new FieldList($children);
57		}
58		$this->children->setContainerField($this);
59
60		parent::__construct(null, false);
		0 ignored issues – show Documentation introduced 2016-07-19 01:21 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `null\|string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
61		}
62
63		/**
64		* Merge child field data into this form
65		*/
66		public function getSchemaDataDefaults() {
67		$defaults = parent::getSchemaDataDefaults();
68		$children = $this->getChildren();
69		if($children && $children->count()) {
70		$childSchema = [];
71		/** @var FormField $child */
72		foreach($children as $child) {
73		$childSchema[] = $child->getSchemaData();
74		}
75		$defaults['children'] = $childSchema;
76		}
77		return $defaults;
78		}
79
80		/**
81		* Returns all the sub-fields, suitable for <% loop FieldList %>
82		*
83		* @return FieldList
84		*/
85		public function FieldList() {
86		return $this->children;
87		}
88
89		/**
90		* Accessor method for $this->children
91		*
92		* @return FieldList
93		*/
94		public function getChildren() {
95		return $this->children;
96		}
97
98		/**
99		* @param FieldList $children
100		* @return $this
101		*/
102		public function setChildren($children) {
103		$this->children = $children;
104		return $this;
105		}
106
107		/**
108		* @param string $tag
109		* @return $this
110		*/
111		public function setTag($tag) {
112		$this->tag = $tag;
113
114		return $this;
115		}
116
117		/**
118		* @return string
119		*/
120		public function getTag() {
121		return $this->tag;
122		}
123
124		/**
125		* @param string $legend
126		* @return $this
127		*/
128		public function setLegend($legend) {
129		$this->legend = $legend;
130		return $this;
131		}
132
133		/**
134		* @return string
135		*/
136		public function getLegend() {
137		return $this->legend;
138		}
139
140		/**
141		* @deprecated
142		*/
143		public function extraClasses() {
144		Deprecation::notice('4.0', 'Use extraClass() instead');
145		return $this->extraClass();
146		}
147
148		public function extraClass() {
149		$classes = array('field', 'CompositeField', parent::extraClass());
150		if($this->columnCount) $classes[] = 'multicolumn';
151
152		return implode(' ', $classes);
153		}
154
155		public function getAttributes() {
156		return array_merge(
157		parent::getAttributes(),
158		array(
159		'tabindex' => null,
160		'type' => null,
161		'value' => null,
162		'title' => ($this->tag == 'fieldset') ? null : $this->legend
163		)
164		);
165		}
166
167		/**
168		* Add all of the non-composite fields contained within this field to the
169		* list.
170		*
171		* Sequentialisation is used when connecting the form to its data source
172		*
173		* @param array $list
174		* @param bool $saveableOnly
175		*/
176		public function collateDataFields(&$list, $saveableOnly = false) {
177		foreach($this->children as $field) {
178		if(! $field instanceof FormField) {
179		continue;
180		}
181		if($field instanceof CompositeField) {
182		$field->collateDataFields($list, $saveableOnly);
183		}
184	View Code Duplication	if($saveableOnly) {
		0 ignored issues – show Duplication introduced 2015-12-18 04:35 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...
185		$isIncluded = ($field->hasData() && !$field->isReadonly() && !$field->isDisabled());
186		} else {
187		$isIncluded = ($field->hasData());
188		}
189		if($isIncluded) {
190		$name = $field->getName();
191		if($name) {
192		$formName = (isset($this->form)) ? $this->form->FormName() : '(unknown form)';
193		if(isset($list[$name])) {
194		user_error("collateDataFields() I noticed that a field called '$name' appears twice in"
195		. " your form: '{$formName}'. One is a '{$field->class}' and the other is a"
196		. " '{$list[$name]->class}'", E_USER_ERROR);
197		}
198		$list[$name] = $field;
199		}
200		}
201		}
202		}
203
204		public function setForm($form) {
205		foreach($this->getChildren() as $field) {
206		if ($field instanceof FormField) {
207		$field->setForm($form);
208		}
209		}
210
211		parent::setForm($form);
212		return $this;
213		}
214
215
216
217		public function setDisabled($disabled) {
218		parent::setDisabled($disabled);
219		foreach($this->getChildren() as $child) {
220		$child->setDisabled($disabled);
221		}
222		return $this;
223		}
224
225		public function setReadonly($readonly)
226		{
227		parent::setReadonly($readonly);
228		foreach($this->getChildren() as $child) {
229		$child->setReadonly($readonly);
230		}
231		return $this;
232		}
233
234		public function setColumnCount($columnCount) {
235		$this->columnCount = $columnCount;
236		return $this;
237		}
238
239		public function getColumnCount() {
240		return $this->columnCount;
241		}
242
243		public function isComposite() {
244		return true;
245		}
246
247		public function hasData() {
248		return false;
249		}
250
251		public function fieldByName($name) {
252		return $this->children->fieldByName($name);
253		}
254
255		/**
256		* Add a new child field to the end of the set.
257		*
258		* @param FormField
259		*/
260		public function push(FormField $field) {
261		$this->children->push($field);
262		}
263
264		/**
265		* Add a new child field to the beginning of the set.
266		*
267		* @param FormField
268		*/
269		public function unshift(FormField $field) {
270		$this->children->unshift($field);
271		}
272
273		/**
274		* @uses FieldList->insertBefore()
275		*
276		* @param string $insertBefore
277		* @param FormField $field
278		* @return false\|FormField
279		*/
280		public function insertBefore($insertBefore, $field) {
281		return $this->children->insertBefore($insertBefore, $field);
282		}
283
284		/**
285		* @uses FieldList->insertAfter()
286		* @param string $insertAfter
287		* @param FormField $field
288		* @return false\|FormField
289		*/
290		public function insertAfter($insertAfter, $field) {
291		return $this->children->insertAfter($insertAfter, $field);
292		}
293
294		/**
295		* Remove a field from this CompositeField by Name.
296		* The field could also be inside a CompositeField.
297		*
298		* @param string $fieldName The name of the field
299		* @param boolean $dataFieldOnly If this is true, then a field will only
300		* be removed if it's a data field. Dataless fields, such as tabs, will
301		* be left as-is.
302		*/
303		public function removeByName($fieldName, $dataFieldOnly = false) {
304		$this->children->removeByName($fieldName, $dataFieldOnly);
305		}
306
307		public function replaceField($fieldName, $newField) {
308		return $this->children->replaceField($fieldName, $newField);
309		}
310
311		public function rootFieldList() {
312		if(is_object($this->containerFieldList)) return $this->containerFieldList->rootFieldList();
313		else return $this->children;
314		}
315
316		public function __clone() {
317		/** {@see FieldList::__clone(}} */
318		$this->setChildren(clone $this->children);
319		}
320
321		/**
322		* Return a readonly version of this field. Keeps the composition but returns readonly
323		* versions of all the child {@link FormField} objects.
324		*
325		* @return CompositeField
326		*/
327		public function performReadonlyTransformation() {
328		$newChildren = new FieldList();
329		$clone = clone $this;
330	View Code Duplication	if($clone->getChildren()) foreach($clone->getChildren() as $child) {
		0 ignored issues – show Duplication introduced 2016-04-03 09:32 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...
331		/** @var FormField $child */
332		$child = $child->transform(new ReadonlyTransformation());
333		$newChildren->push($child);
334		}
335
336		$clone->setChildren($newChildren);
337		$clone->setReadonly(true);
338		$clone->addExtraClass($this->extraClass());
339		$clone->setDescription($this->getDescription());
340
341		return $clone;
342		}
343
344		/**
345		* Return a disabled version of this field. Keeps the composition but returns disabled
346		* versions of all the child {@link FormField} objects.
347		*
348		* @return CompositeField
349		*/
350		public function performDisabledTransformation() {
351		$newChildren = new FieldList();
352		$clone = clone $this;
353	View Code Duplication	if($clone->getChildren()) foreach($clone->getChildren() as $child) {
		0 ignored issues – show Duplication introduced 2016-07-19 01:21 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...
354		/** @var FormField $child */
355		$child = $child->transform(new DisabledTransformation());
356		$newChildren->push($child);
357		}
358
359		$clone->setChildren($newChildren);
360		$clone->setDisabled(true);
361		$clone->addExtraClass($this->extraClass());
362		$clone->setDescription($this->getDescription());
363		foreach($this->attributes as $k => $v) {
364		$clone->setAttribute($k, $v);
365		}
366
367		return $clone;
368		}
369
370		public function IsReadonly() {
371		return $this->readonly;
372		}
373
374		/**
375		* Find the numerical position of a field within
376		* the children collection. Doesn't work recursively.
377		*
378		* @param string\|FormField
379		* @return int Position in children collection (first position starts with 0). Returns FALSE if the field can't
380		* be found.
381		*/
382	View Code Duplication	public function fieldPosition($field) {
		0 ignored issues – show Duplication introduced 2015-12-18 04:35 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...
383		if(is_string($field)) {
384		$field = $this->fieldByName($field);
385		}
386		if(!$field) {
387		return false;
388		}
389
390		$i = 0;
391		foreach($this->children as $child) {
392		/** @var FormField $child */
393		if($child->getName() == $field->getName()) {
394		return $i;
395		}
396		$i++;
397		}
398
399		return false;
400		}
401
402		/**
403		* Transform the named field into a readonly feld.
404		*
405		* @param string\|FormField
406		* @return bool
407		*/
408		public function makeFieldReadonly($field) {
409		$fieldName = ($field instanceof FormField) ? $field->getName() : $field;
410
411		// Iterate on items, looking for the applicable field
412		foreach($this->children as $i => $item) {
413		if($item instanceof CompositeField) {
414		if($item->makeFieldReadonly($fieldName)) {
415		return true;
416		};
417		} elseif($item instanceof FormField && $item->getName() == $fieldName) {
418		// Once it's found, use FormField::transform to turn the field into a readonly version of itself.
419		$this->children->replaceField($fieldName, $item->transform(new ReadonlyTransformation()));
420
421		// A true results indicates that the field was found
422		return true;
423		}
424		}
425		return false;
426		}
427
428		public function debug() {
429		$result = "$this->class ($this->name) <ul>";
430		foreach($this->children as $child) {
431		$result .= "<li>" . Debug::text($child) . " </li>";
432		}
433		$result .= "</ul>";
434		return $result;
435		}
436
437		/**
438		* Validate this field
439		*
440		* @param Validator $validator
441		* @return bool
442		*/
443		public function validate($validator) {
444		$valid = true;
445		foreach($this->children as $child){
446		/** @var FormField $child */
447		$valid = ($child && $child->validate($validator) && $valid);
448		}
449		return $valid;
450		}
451
452		}
453

sminnee / silverstripe-framework

Push — correct-classname-values ( f9b487 )

CompositeField::setDisabled() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like