forked from zendframework/zendframework
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Form.php
755 lines (661 loc) · 21.7 KB
/
Form.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @link http://github.com/zendframework/zf2 for the canonical source repository
* @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @package Zend_Form
*/
namespace Zend\Form;
use Traversable;
use Zend\Form\Element\Collection;
use Zend\Form\Exception;
use Zend\InputFilter\InputFilter;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\InputFilter\InputFilterInterface;
use Zend\InputFilter\InputFilterProviderInterface;
use Zend\InputFilter\InputProviderInterface;
use Zend\Stdlib\ArrayUtils;
use Zend\Stdlib\Hydrator\HydratorInterface;
/**
* @category Zend
* @package Zend_Form
*/
class Form extends Fieldset implements FormInterface
{
/**
* Seed attributes
*
* @var array
*/
protected $attributes = array(
'method' => 'POST',
);
/**
* How to bind values to the attached object
*
* @var int
*/
protected $bindAs = FormInterface::VALUES_NORMALIZED;
/**
* Whether or not to bind values to the bound object on successful validation
*
* @var int
*/
protected $bindOnValidate = FormInterface::BIND_ON_VALIDATE;
/**
* Base fieldset to use for hydrating (if none specified, directly hydrate elements)
*
* @var FieldsetInterface
*/
protected $baseFieldset;
/**
* Data being validated
*
* @var null|array|Traversable
*/
protected $data;
/**
* @var null|InputFilterInterface
*/
protected $filter;
/**
* Whether or not to automatically scan for input filter defaults on
* attached fieldsets and elements
*
* @var bool
*/
protected $useInputFilterDefaults = true;
/**
* Has the input filter defaults been added already ?
*
* @var bool
*/
protected $hasAddedInputFilterDefaults = false;
/**
* Whether or not validation has occurred
*
* @var bool
*/
protected $hasValidated = false;
/**
* Result of last validation operation
*
* @var bool
*/
protected $isValid = false;
/**
* Is the form prepared ?
*
* @var bool
*/
protected $isPrepared = false;
/**
* Are the form elements/fieldsets wrapped by the form name ?
*
* @var bool
*/
protected $wrapElements = false;
/**
* Validation group, if any
*
* @var null|array
*/
protected $validationGroup;
/**
* Add an element or fieldset
*
* If $elementOrFieldset is an array or Traversable, passes the argument on
* to the composed factory to create the object before attaching it.
*
* $flags could contain metadata such as the alias under which to register
* the element or fieldset, order in which to prioritize it, etc.
*
* @param array|Traversable|ElementInterface $elementOrFieldset
* @param array $flags
* @return \Zend\Form\Fieldset|\Zend\Form\FieldsetInterface|\Zend\Form\FormInterface
*/
public function add($elementOrFieldset, array $flags = array())
{
// TODO: find a better solution than duplicating the factory code, the problem being that if $elementOrFieldset is an array,
// it is passed by value, and we don't get back the concrete ElementInterface
if (is_array($elementOrFieldset)
|| ($elementOrFieldset instanceof Traversable && !$elementOrFieldset instanceof ElementInterface)
) {
$factory = $this->getFormFactory();
$elementOrFieldset = $factory->create($elementOrFieldset);
}
parent::add($elementOrFieldset, $flags);
if ($elementOrFieldset instanceof Fieldset && $elementOrFieldset->useAsBaseFieldset()) {
$this->baseFieldset = $elementOrFieldset;
}
return $this;
}
/**
* Ensures state is ready for use
*
* Marshalls the input filter, to ensure validation error messages are
* available, and prepares any elements and/or fieldsets that require
* preparation.
*
* @return Form
*/
public function prepare()
{
if ($this->isPrepared) {
return $this;
}
$this->getInputFilter();
// If the user wants to, elements names can be wrapped by the form's name
if ($this->wrapElements()) {
$this->prepareElement($this);
} else {
foreach ($this->getIterator() as $elementOrFieldset) {
if ($elementOrFieldset instanceof ElementPrepareAwareInterface) {
$elementOrFieldset->prepareElement($this);
}
}
}
$this->isPrepared = true;
return $this;
}
/**
* Set data to validate and/or populate elements
*
* Typically, also passes data on to the composed input filter.
*
* @param array|\ArrayAccess|\Traversable $data
* @return Form|FormInterface
* @throws Exception\InvalidArgumentException
*/
public function setData($data)
{
if ($data instanceof Traversable) {
$data = ArrayUtils::iteratorToArray($data);
}
if (!is_array($data)) {
throw new Exception\InvalidArgumentException(sprintf(
'%s expects an array or Traversable argument; received "%s"',
__METHOD__,
(is_object($data) ? get_class($data) : gettype($data))
));
}
$this->hasValidated = false;
$this->data = $data;
$this->populateValues($data);
return $this;
}
/**
* Bind an object to the form
*
* Ensures the object is populated with validated values.
*
* @param object $object
* @param int $flags
* @return mixed|void
* @throws Exception\InvalidArgumentException
*/
public function bind($object, $flags = FormInterface::VALUES_NORMALIZED)
{
if (!in_array($flags, array(FormInterface::VALUES_NORMALIZED, FormInterface::VALUES_RAW))) {
throw new Exception\InvalidArgumentException(sprintf(
'%s expects the $flags argument to be one of "%s" or "%s"; received "%s"',
__METHOD__,
'Zend\Form\FormInterface::VALUES_NORMALIZED',
'Zend\Form\FormInterface::VALUES_RAW',
$flags
));
}
if ($this->baseFieldset !== null) {
$this->baseFieldset->setObject($object);
}
$this->bindAs = $flags;
$this->setObject($object);
$this->extract();
}
/**
* Set the hydrator to use when binding an object to the element
*
* @param HydratorInterface $hydrator
* @return FieldsetInterface
*/
public function setHydrator(HydratorInterface $hydrator)
{
if ($this->baseFieldset !== null) {
$this->baseFieldset->setHydrator($hydrator);
}
return parent::setHydrator($hydrator);
}
/**
* Bind values to the bound object
*
* @param array $values
* @return mixed
*/
public function bindValues(array $values = array())
{
if (!is_object($this->object)) {
return;
}
if (!$this->hasValidated() && !empty($values)) {
$this->setData($values);
if (!$this->isValid()) {
return;
}
} elseif (!$this->isValid) {
return;
}
$filter = $this->getInputFilter();
switch ($this->bindAs) {
case FormInterface::VALUES_RAW:
$data = $filter->getRawValues();
break;
case FormInterface::VALUES_NORMALIZED:
default:
$data = $filter->getValues();
break;
}
$data = $this->prepareBindData($data, $this->data);
// If there is a base fieldset, only hydrate beginning from the base fieldset
if ($this->baseFieldset !== null) {
$data = $data[$this->baseFieldset->getName()];
$this->object = $this->baseFieldset->bindValues($data);
} else {
$this->object = parent::bindValues($data);
}
}
/**
* Parse filtered values and return only posted fields for binding
*
* @param array $values
* @param array $match
* @return array
*/
protected function prepareBindData(array $values, array $match)
{
$data = array();
foreach ($values as $name => $value) {
if (!array_key_exists($name, $match)) {
continue;
}
if (is_array($value)) {
$data[$name] = $this->prepareBindData($value, $match[$name]);
} else {
$data[$name] = $value;
}
}
return $data;
}
/**
* Set flag indicating whether or not to bind values on successful validation
*
* @param int $bindOnValidateFlag
* @return void|Form
* @throws Exception\InvalidArgumentException
*/
public function setBindOnValidate($bindOnValidateFlag)
{
if (!in_array($bindOnValidateFlag, array(self::BIND_ON_VALIDATE, self::BIND_MANUAL))) {
throw new Exception\InvalidArgumentException(sprintf(
'%s expects the flag to be one of %s::%s or %s::%s',
__METHOD__,
get_called_class(),
'BIND_ON_VALIDATE',
get_called_class(),
'BIND_MANUAL'
));
}
$this->bindOnValidate = $bindOnValidateFlag;
return $this;
}
/**
* Will we bind values to the bound object on successful validation?
*
* @return bool
*/
public function bindOnValidate()
{
return (self::BIND_ON_VALIDATE === $this->bindOnValidate);
}
/**
* Set the base fieldset to use when hydrating
*
* @param FieldsetInterface $baseFieldset
* @return Form
* @throws Exception\InvalidArgumentException
*/
public function setBaseFieldset(FieldsetInterface $baseFieldset)
{
$this->baseFieldset = $baseFieldset;
return $this;
}
/**
* Get the base fieldset to use when hydrating
*
* @return FieldsetInterface
*/
public function getBaseFieldset()
{
return $this->baseFieldset;
}
/**
* Check if the form has been validated
*
* @return bool
*/
public function hasValidated()
{
return $this->hasValidated;
}
/**
* Validate the form
*
* Typically, will proxy to the composed input filter.
*
* @return bool
* @throws Exception\DomainException
*/
public function isValid()
{
if ($this->hasValidated) {
return $this->isValid;
}
$this->isValid = false;
if (!is_array($this->data) && !is_object($this->object)) {
throw new Exception\DomainException(sprintf(
'%s is unable to validate as there is no data currently set',
__METHOD__
));
}
if (!is_array($this->data)) {
$data = $this->extract();
if (!is_array($data)) {
throw new Exception\DomainException(sprintf(
'%s is unable to validate as there is no data currently set',
__METHOD__
));
}
$this->data = $data;
}
$filter = $this->getInputFilter();
if (!$filter instanceof InputFilterInterface) {
throw new Exception\DomainException(sprintf(
'%s is unable to validate as there is no input filter present',
__METHOD__
));
}
$filter->setData($this->data);
$filter->setValidationGroup(InputFilterInterface::VALIDATE_ALL);
if ($this->validationGroup !== null) {
$this->prepareValidationGroup($this, $this->data, $this->validationGroup);
$filter->setValidationGroup($this->validationGroup);
}
$this->isValid = $result = $filter->isValid();
$this->hasValidated = true;
if ($result && $this->bindOnValidate()) {
$this->bindValues();
}
if (!$result) {
$this->setMessages($filter->getMessages());
}
return $result;
}
/**
* Retrieve the validated data
*
* By default, retrieves normalized values; pass one of the
* FormInterface::VALUES_* constants to shape the behavior.
*
* @param int $flag
* @return array|object
* @throws Exception\DomainException
*/
public function getData($flag = FormInterface::VALUES_NORMALIZED)
{
if (!$this->hasValidated) {
throw new Exception\DomainException(sprintf(
'%s cannot return data as validation has not yet occurred',
__METHOD__
));
}
if (($flag !== FormInterface::VALUES_AS_ARRAY) && is_object($this->object)) {
return $this->object;
}
$filter = $this->getInputFilter();
if ($flag === FormInterface::VALUES_RAW) {
return $filter->getRawValues();
}
return $filter->getValues();
}
/**
* Set the validation group (set of values to validate)
*
* Typically, proxies to the composed input filter
*
* @throws Exception\InvalidArgumentException
* @return Form|FormInterface
*/
public function setValidationGroup()
{
$argc = func_num_args();
if (0 === $argc) {
throw new Exception\InvalidArgumentException(sprintf(
'%s expects at least one argument; none provided',
__METHOD__
));
}
$argv = func_get_args();
$this->hasValidated = false;
if ($argc > 1) {
$this->validationGroup = $argv;
return $this;
}
$arg = array_shift($argv);
if ($arg === FormInterface::VALIDATE_ALL) {
$this->validationGroup = null;
return $this;
}
if (!is_array($arg)) {
$arg = (array) $arg;
}
$this->validationGroup = $arg;
return $this;
}
/**
* Prepare the validation group in case Collection elements were used (this function also handle the case where elements
* could have been dynamically added or removed from a collection using JavaScript)
*
* @param FieldsetInterface $formOrFieldset
* @param array $data
* @param array $validationGroup
*/
protected function prepareValidationGroup(FieldsetInterface $formOrFieldset, array $data, array &$validationGroup)
{
foreach ($validationGroup as $key => &$value) {
if (!$formOrFieldset->has($key)) {
continue;
}
$fieldset = $formOrFieldset->byName[$key];
if ($fieldset instanceof Collection) {
if (!isset($data[$key]) && $fieldset->getCount() == 0) {
unset ($validationGroup[$key]);
continue;
}
$values = array();
if (isset($data[$key])) {
$count = count($data[$key]);
for ($i = 0 ; $i != $count ; ++$i) {
$values[] = $value;
}
}
$value = $values;
} else {
if (isset($data[$key])) {
$this->prepareValidationGroup($fieldset, $data[$key], $validationGroup[$key]);
}
}
}
}
/**
* Set the input filter used by this form
*
* @param InputFilterInterface $inputFilter
* @return FormInterface
*/
public function setInputFilter(InputFilterInterface $inputFilter)
{
$this->hasValidated = false;
$this->hasAddedInputFilterDefaults = false;
$this->filter = $inputFilter;
return $this;
}
/**
* Retrieve input filter used by this form
*
* @return null|InputFilterInterface
*/
public function getInputFilter()
{
if ($this->object instanceof InputFilterAwareInterface) {
if (null == $this->baseFieldset) {
$this->filter = $this->object->getInputFilter();
} else {
$name = $this->baseFieldset->getName();
if (!$this->filter instanceof InputFilterInterface || !$this->filter->has($name)) {
$filter = new InputFilter();
$filter->add($this->object->getInputFilter(), $name);
$this->filter = $filter;
}
}
}
if (!isset($this->filter)) {
$this->filter = new InputFilter();
}
if (!$this->hasAddedInputFilterDefaults
&& $this->filter instanceof InputFilterInterface
&& $this->useInputFilterDefaults()
) {
$this->attachInputFilterDefaults($this->filter, $this);
$this->hasAddedInputFilterDefaults = true;
}
return $this->filter;
}
/**
* Set flag indicating whether or not to scan elements and fieldsets for defaults
*
* @param bool $useInputFilterDefaults
* @return Form
*/
public function setUseInputFilterDefaults($useInputFilterDefaults)
{
$this->useInputFilterDefaults = (bool) $useInputFilterDefaults;
return $this;
}
/**
* Should we use input filter defaults from elements and fieldsets?
*
* @return bool
*/
public function useInputFilterDefaults()
{
return $this->useInputFilterDefaults;
}
/**
* Attach defaults provided by the elements to the input filter
*
* @param InputFilterInterface $inputFilter
* @param FieldsetInterface $fieldset Fieldset to traverse when looking for default inputs
* @return void
*/
public function attachInputFilterDefaults(InputFilterInterface $inputFilter, FieldsetInterface $fieldset)
{
$formFactory = $this->getFormFactory();
$inputFactory = $formFactory->getInputFilterFactory();
foreach ($fieldset->getElements() as $element) {
$name = $element->getName();
if (!$element instanceof InputProviderInterface) {
if ($inputFilter->has($name)) {
continue;
}
// Create a new empty default input for this element
$spec = array('name' => $name, 'required' => false);
} else {
// Create an input based on the specification returned from the element
$spec = $element->getInputSpecification();
}
$input = $inputFactory->createInput($spec);
$inputFilter->add($input, $name);
}
foreach ($fieldset->getFieldsets() as $fieldset) {
$name = $fieldset->getName();
if (!$fieldset instanceof InputFilterProviderInterface) {
if (!$inputFilter->has($name)) {
// Add a new empty input filter if it does not exist (or the fieldset's object input filter),
// so that elements of nested fieldsets can be recursively added
if ($fieldset->getObject() instanceof InputFilterAwareInterface) {
$inputFilter->add($fieldset->getObject()->getInputFilter(), $name);
} else {
$inputFilter->add(new InputFilter(), $name);
}
}
$fieldsetFilter = $inputFilter->get($name);
if (!$fieldsetFilter instanceof InputFilterInterface) {
// Input attached for fieldset, not input filter; nothing more to do.
continue;
}
// Traverse the elements of the fieldset, and attach any
// defaults to the fieldset's input filter
$this->attachInputFilterDefaults($fieldsetFilter, $fieldset);
continue;
}
if ($inputFilter->has($name)) {
// if we already have an input/filter by this name, use it
continue;
}
// Create an input filter based on the specification returned from the fieldset
$spec = $fieldset->getInputFilterSpecification();
$filter = $inputFactory->createInputFilter($spec);
$inputFilter->add($filter, $name);
// Recursively attach sub filters
$this->attachInputFilterDefaults($filter, $fieldset);
}
}
/**
* Are the form elements/fieldsets names wrapped by the form name ?
*
* @param bool $wrapElements
* @return Form
*/
public function setWrapElements($wrapElements)
{
$this->wrapElements = (bool) $wrapElements;
return $this;
}
/**
* If true, form elements/fieldsets name's are wrapped around the form name itself
*
* @return bool
*/
public function wrapElements()
{
return $this->wrapElements;
}
/**
* Recursively extract values for elements and sub-fieldsets, and populate form values
*
* @return array
*/
protected function extract()
{
if (null !== $this->baseFieldset) {
$name = $this->baseFieldset->getName();
$values[$name] = $this->baseFieldset->extract();
$this->baseFieldset->populateValues($values[$name]);
} else {
$values = parent::extract();
$this->populateValues($values);
}
return $values;
}
}