1HTML::FormHandler(3)  User Contributed Perl Documentation HTML::FormHandler(3)
2
3
4

NAME

6       HTML::FormHandler - HTML forms using Moose
7

VERSION

9       version 0.40068
10

SYNOPSIS

12       See the manual at HTML::FormHandler::Manual.
13
14           use HTML::FormHandler; # or a custom form: use MyApp::Form::User;
15           my $form = HTML::FormHandler->new( .... );
16           $form->process( params => $params );
17           my $rendered_form = $form->render;
18           if( $form->validated ) {
19               # perform validated form actions
20           }
21           else {
22               # perform non-validated actions
23           }
24
25       Or, if you want to use a form 'result' (which contains only the form
26       values and error messages) instead:
27
28           use MyApp::Form; # or a generic form: use HTML::FormHandler;
29           my $form = MyApp::Form->new( .... );
30           my $result = $form->run( params => $params );
31           if( $result->validated ) {
32               # perform validated form actions
33           }
34           else {
35               # perform non-validated actions
36               $result->render;
37           }
38
39       An example of a custom form class:
40
41           package MyApp::Form::User;
42
43           use HTML::FormHandler::Moose;
44           extends 'HTML::FormHandler';
45           use Moose::Util::TypeConstraints;
46
47           has '+item_class' => ( default => 'User' );
48
49           has_field 'name' => ( type => 'Text' );
50           has_field 'age' => ( type => 'PosInteger', apply => [ 'MinimumAge' ] );
51           has_field 'birthdate' => ( type => 'DateTime' );
52           has_field 'birthdate.month' => ( type => 'Month' );
53           has_field 'birthdate.day' => ( type => 'MonthDay' );
54           has_field 'birthdate.year' => ( type => 'Year' );
55           has_field 'hobbies' => ( type => 'Multiple' );
56           has_field 'address' => ( type => 'Text' );
57           has_field 'city' => ( type => 'Text' );
58           has_field 'state' => ( type => 'Select' );
59           has_field 'email' => ( type => 'Email' );
60
61           has '+dependency' => ( default => sub {
62                 [ ['address', 'city', 'state'], ]
63              }
64           );
65
66           subtype 'MinimumAge'
67              => as 'Int'
68              => where { $_ > 13 }
69              => message { "You are not old enough to register" };
70
71           no HTML::FormHandler::Moose;
72           1;
73
74       A dynamic form - one that does not use a custom form class - may be
75       created using the 'field_list' attribute to set fields:
76
77           my $form = HTML::FormHandler->new(
78               name => 'user_form',
79               item => $user,
80               field_list => [
81                   'username' => {
82                       type  => 'Text',
83                       apply => [ { check => qr/^[0-9a-z]*\z/,
84                          message => 'Contains invalid characters' } ],
85                   },
86                   'select_bar' => {
87                       type     => 'Select',
88                       options  => \@select_options,
89                       multiple => 1,
90                       size     => 4,
91                   },
92               ],
93           );
94
95       FormHandler does not provide a custom controller for Catalyst because
96       it isn't necessary. Interfacing to FormHandler is only a couple of
97       lines of code. See HTML::FormHandler::Manual::Catalyst for more
98       details, or
99       Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormHandler.
100

DESCRIPTION

102       *** Although documentation in this file provides some overview, it is
103       mainly intended for API documentation. See
104       HTML::FormHandler::Manual::Intro for an introduction, with links to
105       other documentation.
106
107       HTML::FormHandler maintains a clean separation between form
108       construction and form rendering. It allows you to define your forms and
109       fields in a number of flexible ways. Although it provides renderers for
110       HTML, you can define custom renderers for any kind of presentation.
111
112       HTML::FormHandler allows you to define form fields and validators. It
113       can be used for both database and non-database forms, and will
114       automatically update or create rows in a database. It can be used to
115       process structured data that doesn't come from an HTML form.
116
117       One of its goals is to keep the controller/application program
118       interface as simple as possible, and to minimize the duplication of
119       code. In most cases, interfacing your controller to your form is only a
120       few lines of code.
121
122       With FormHandler you shouldn't have to spend hours trying to figure out
123       how to make a simple HTML change that would take one minute by hand.
124       Because you _can_ do it by hand. Or you can automate HTML generation as
125       much as you want, with template widgets or pure Perl rendering classes,
126       and stay completely in control of what, where, and how much is done
127       automatically. You can define custom renderers and display your
128       rendered forms however you want.
129
130       You can split the pieces of your forms up into logical parts and
131       compose complete forms from FormHandler classes, roles, fields,
132       collections of validations, transformations and Moose type constraints.
133       You can write custom methods to process forms, add any attribute you
134       like, and use Moose method modifiers.  FormHandler forms are Perl
135       classes, so there's a lot of flexibility in what you can do.
136
137       HTML::FormHandler provides rendering through roles which are applied to
138       form and field classes (although there's no reason you couldn't write a
139       renderer as an external object either).  There are currently two
140       flavors: all-in-one solutions like HTML::FormHandler::Render::Simple
141       and HTML::FormHandler::Render::Table that contain methods for rendering
142       field widget classes, and the HTML::FormHandler::Widget roles, which
143       are more atomic roles which are automatically applied to fields and
144       form. See HTML::FormHandler::Manual::Rendering for more details.  (And
145       you can easily use hand-built forms - FormHandler doesn't care.)
146
147       The typical application for FormHandler would be in a Catalyst,
148       DBIx::Class, Template Toolkit web application, but use is not limited
149       to that. FormHandler can be used in any Perl application.
150
151       More Formhandler documentation and a tutorial can be found in the
152       manual at HTML::FormHandler::Manual.
153

ATTRIBUTES and METHODS

155   Creating a form with 'new'
156       The new constructor takes name/value pairs:
157
158           MyForm->new(
159               item    => $item,
160           );
161
162       No attributes are required on new. The form's fields will be built from
163       the form definitions. If no initial data object or defaults have been
164       provided, the form will be empty. Most attributes can be set on either
165       'new' or 'process'.  The common attributes to be passed in to the
166       constructor for a database form are either item_id and schema or item:
167
168          item_id  - database row primary key
169          item     - database row object
170          schema   - (for DBIC) the DBIx::Class schema
171
172       The following are sometimes passed in, but are also often set in the
173       form class:
174
175          item_class  - source name of row
176          dependency  - (see dependency)
177          field_list  - an array of field definitions
178          init_object - a hashref or object to provide initial values
179
180       Examples of creating a form object with new:
181
182           my $form = MyApp::Form::User->new;
183
184           # database form using a row object
185           my $form = MyApp::Form::Member->new( item => $row );
186
187           # a dynamic form (no form class has been defined)
188           my $form = HTML::FormHandler::Model::DBIC->new(
189               item_id         => $id,
190               item_class    => 'User',
191               schema          => $schema,
192               field_list         => [
193                       name    => 'Text',
194                       active  => 'Boolean',
195                       submit_btn => 'Submit',
196               ],
197           );
198
199       See the model class for more information about 'item', 'item_id',
200       'item_class', and 'schema' (for the DBIC model).
201       HTML::FormHandler::Model::DBIC.
202
203       FormHandler forms are handled in two steps: 1) create with 'new', 2)
204       handle with 'process'. FormHandler doesn't care whether most parameters
205       are set on new or process or update, but a 'field_list' argument must
206       be passed in on 'new' since the fields are built at construction time.
207
208       If you want to update field attributes on the 'process' call, you can
209       use an 'update_field_list' or 'defaults' hashref attribute , or
210       subclass update_fields in your form. The 'update_field_list' hashref
211       can be used to set any field attribute. The 'defaults' hashref will
212       update only the 'default' attribute in the field. (There are a lot of
213       ways to set defaults. See HTML::FormHandler::Manual::Defaults.)
214
215          $form->process( defaults => { foo => 'foo_def', bar => 'bar_def' } );
216          $form->process( update_field_list => { foo => { label => 'New Label' } });
217
218       Field results are built on the 'new' call, but will then be re-built on
219       the process call. If you always use 'process' before rendering the
220       form, accessing fields, etc, you can set the 'no_preload' flag to skip
221       this step.
222
223   Processing the form
224       process
225
226       Call the 'process' method on your form to perform validation and
227       update. A database form must have either an item (row object) or a
228       schema, item_id (row primary key), and item_class (usually set in the
229       form).  A non-database form requires only parameters.
230
231          $form->process( item => $book, params => $c->req->parameters );
232          $form->process( item_id => $item_id,
233              schema => $schema, params => $c->req->parameters );
234          $form->process( params => $c->req->parameters );
235
236       This process method returns the 'validated' flag ("$form->validated").
237       If it is a database form and the form validates, the database row will
238       be updated.
239
240       After the form has been processed, you can get a parameter hashref
241       suitable for using to fill in the form from "$form->fif".  A hash of
242       inflated values (that would be used to update the database for a
243       database form) can be retrieved with "$form->value".
244
245       If you don't want to update the database on this process call, you can
246       set the 'no_update' flag:
247
248          $form->process( item => $book, params => $params, no_update => 1 );
249
250       params
251
252       Parameters are passed in when you call 'process'.  HFH gets data to
253       validate and store in the database from the params hash.  If the params
254       hash is empty, no validation is done, so it is not necessary to check
255       for POST before calling "$form->process". (Although see the 'posted'
256       option for complications.)
257
258       Params can either be in the form of CGI/HTTP style params:
259
260          {
261             user_name => "Joe Smith",
262             occupation => "Programmer",
263             'addresses.0.street' => "999 Main Street",
264             'addresses.0.city' => "Podunk",
265             'addresses.0.country' => "UT",
266             'addresses.0.address_id' => "1",
267             'addresses.1.street' => "333 Valencia Street",
268             'addresses.1.city' => "San Francisco",
269             'addresses.1.country' => "UT",
270             'addresses.1.address_id' => "2",
271          }
272
273       or as structured data in the form of hashes and lists:
274
275          {
276             addresses => [
277                {
278                   city => 'Middle City',
279                   country => 'GK',
280                   address_id => 1,
281                   street => '101 Main St',
282                },
283                {
284                   city => 'DownTown',
285                   country => 'UT',
286                   address_id => 2,
287                   street => '99 Elm St',
288                },
289             ],
290             'occupation' => 'management',
291             'user_name' => 'jdoe',
292          }
293
294       CGI style parameters will be converted to hashes and lists for HFH to
295       operate on.
296
297       posted
298
299       Note that FormHandler by default uses empty params as a signal that the
300       form has not actually been posted, and so will not attempt to validate
301       a form with empty params. Most of the time this works OK, but if you
302       have a small form with only the controls that do not return a post
303       parameter if unselected (checkboxes and select lists), then the form
304       will not be validated if everything is unselected. For this case you
305       can either add a hidden field as an 'indicator', or use the 'posted'
306       flag:
307
308          $form->process( posted => ($c->req->method eq 'POST'), params => ... );
309
310       The 'posted' flag also works to prevent validation from being performed
311       if there are extra params in the params hash and it is not a 'POST'
312       request.
313
314   Getting data out
315       fif  (fill in form)
316
317       If you don't use FormHandler rendering and want to fill your form
318       values in using some other method (such as with HTML::FillInForm or
319       using a template) this returns a hash of values that are equivalent to
320       params which you may use to fill in your form.
321
322       The fif value for a 'title' field in a TT form:
323
324          [% form.fif.title %]
325
326       Or you can use the 'fif' method on individual fields:
327
328          [% form.field('title').fif %]
329
330       If you use FormHandler to render your forms or field you probably won't
331       use these methods.
332
333       value
334
335       Returns a hashref of all field values. Useful for non-database forms,
336       or if you want to update the database yourself. The 'fif' method
337       returns a hashref with the field names for the keys and the field's
338       'fif' for the values; 'value' returns a hashref with the field
339       accessors for the keys, and the field's 'value' (possibly inflated) for
340       the values.
341
342       Forms containing arrays to be processed with
343       HTML::FormHandler::Field::Repeatable will have parameters with dots and
344       numbers, like 'addresses.0.city', while the values hash will transform
345       the fields with numbers to arrays.
346
347   Accessing and setting up fields
348       Fields are declared with a number of attributes which are defined in
349       HTML::FormHandler::Field. If you want additional attributes you can
350       define your own field classes (or apply a role to a field class - see
351       HTML::FormHandler::Manual::Cookbook). The field 'type' (used in field
352       definitions) is the short class name of the field class, used when
353       searching the 'field_name_space' for the field class.
354
355       has_field
356
357       The most common way of declaring fields is the 'has_field' syntax.
358       Using the 'has_field' syntax sugar requires " use
359       HTML::FormHandler::Moose; " or " use HTML::FormHandler::Moose::Role; "
360       in a role.  See HTML::FormHandler::Manual::Intro
361
362          use HTML::FormHandler::Moose;
363          has_field 'field_name' => ( type => 'FieldClass', .... );
364
365       field_list
366
367       A 'field_list' is an array of field definitions which can be used as an
368       alternative to 'has_field' in small, dynamic forms to create fields.
369
370           field_list => [
371              field_one => {
372                 type => 'Text',
373                 required => 1
374              },
375              field_two => 'Text,
376           ]
377
378       The field_list array takes elements which are either a field_name key
379       pointing to a 'type' string or a field_name key pointing to a hashref
380       of field attributes. You can also provide an array of hashref elements
381       with the name as an additional attribute.  The field list can be set
382       inside a form class, when you want to add fields to the form depending
383       on some other state, although you can also create all the fields and
384       set some of them inactive.
385
386          sub field_list {
387             my $self = shift;
388             my $fields = $self->schema->resultset('SomeTable')->
389                                 search({user_id => $self->user_id, .... });
390             my @field_list;
391             while ( my $field = $fields->next )
392             {
393                < create field list >
394             }
395             return \@field_list;
396          }
397
398       update_field_list
399
400       Used to dynamically set particular field attributes on the 'process'
401       (or 'run') call. (Will not create fields.)
402
403           $form->process( update_field_list => {
404              foo_date => { format => '%m/%e/%Y', date_start => '10-01-01' } },
405              params => $params );
406
407       The 'update_field_list' is processed by the 'update_fields' form
408       method, which can also be used in a form to do specific field updates:
409
410           sub update_fields {
411               my $self = shift;
412               $self->field('foo')->temp( 'foo_temp' );
413               $self->field('bar')->default( 'foo_value' );
414               $self->next::method();
415           }
416
417       (Note that you although you can set a field's 'default', you can't set
418       a field's 'value' directly here, since it will be overwritten by the
419       validation process. Set the value in a field validation method.)
420
421       update_subfields
422
423       Yet another way to provide settings for the field, except this one is
424       intended for use in roles and compound fields, and is only executed
425       when the form is initially built. It takes the same field name keys as
426       'update_field_list', plus 'all', 'by_flag', and 'by_type'.
427
428           sub build_update_subfields {{
429               all => { tags => { wrapper_tag => 'p' } },
430               foo => { element_class => 'blue' },
431           }}
432
433       The 'all' hash key will apply updates to all fields. (Conflicting
434       attributes in a field definition take precedence.)
435
436       The 'by_flag' hash key will apply updates to fields with a particular
437       flag.  The currently supported subkeys are 'compound', 'contains', and
438       'repeatable'.  (For repeatable instances, in addition to 'contains' you
439       can also use the 'repeatable' key and the 'init_contains' attribute.)
440       This is useful for turning on the rendering wrappers for compounds and
441       repeatables, which are off by default. (The repeatable instances are
442       wrapped by default.)
443
444           sub build_update_subfields {{
445               by_flag => { compound => { do_wrapper => 1 } },
446               by_type => { Select => { element_class => ['sel_elem'] } },
447           }}
448
449       The 'by_type' hash key will provide values to all fields of a
450       particular type.
451
452       defaults
453
454       This is a more specialized version of the 'update_field_list'. It can
455       be used to provide 'default' settings for fields, in a shorthand way
456       (you don't have to say 'default' for every field).
457
458          $form->process( defaults => { foo => 'this_foo', bar => 'this_bar' }, ... );
459
460       active/inactive
461
462       A field can be marked 'inactive' and set to active at new or process
463       time by specifying the field name in the 'active' array:
464
465          has_field 'foo' => ( type => 'Text', inactive => 1 );
466          ...
467          my $form = MyApp::Form->new( active => ['foo'] );
468          ...
469          $form->process( active => ['foo'] );
470
471       Or a field can be a normal active field and set to inactive at new or
472       process time:
473
474          has_field 'bar';
475          ...
476          my $form = MyApp::Form->new( inactive => ['foo'] );
477          ...
478          $form->process( inactive => ['foo'] );
479
480       Fields specified as active/inactive on new will have the form's
481       inactive/active arrayref cleared and the field's inactive flag set
482       appropriately, so that the state will be effective for the life of the
483       form object. Fields specified as active/inactive on 'process' will have
484       the field's '_active' flag set for the life of the request (the _active
485       flag will be cleared when the form is cleared).
486
487       The 'sorted_fields' method returns only active fields, sorted according
488       to the 'order' attribute. The 'fields' method returns all fields.
489
490          foreach my $field ( $self->sorted_fields ) { ... }
491
492       You can test whether a field is active by using the field 'is_active'
493       and 'is_inactive' methods.
494
495       field_name_space
496
497       Use to look for field during form construction. If a field is not found
498       with the field_name_space (or HTML::FormHandler/HTML::FormHandlerX),
499       the 'type' must start with a '+' and be the complete package name.
500
501       fields
502
503       The array of fields, objects of HTML::FormHandler::Field or its
504       subclasses.  A compound field will itself have an array of fields, so
505       this is a tree structure.
506
507       sorted_fields
508
509       Returns those fields from the fields array which are currently active.
510       This is the method that returns the fields that are looped through when
511       rendering.
512
513       field($name), subfield($name)
514
515       'field' is the method that is usually called to access a field:
516
517           my $title = $form->field('title')->value;
518           [% f = form.field('title') %]
519
520           my $city = $form->field('addresses.0.city')->value;
521
522       Pass a second true value to die on errors.
523
524       Since fields are searched for using the form as a base, if you want to
525       find a sub field in a compound field method, the 'subfield' method may
526       be more useful, since you can search starting at the current field. The
527       'chained' method also works:
528
529           -- in a compound field --
530           $self->field('media.caption'); # fails
531           $self->field('media')->field('caption'); # works
532           $self->subfield('media.caption'); # works
533
534   Constraints and validation
535       Most validation is performed on a per-field basis, and there are a
536       number of different places in which validation can be performed.
537
538       See also HTML::FormHandler::Manual::Validation.
539
540       Form class validation for individual fields
541
542       You can define a method in your form class to perform validation on a
543       field.  This method is the equivalent of the field class validate
544       method except it is in the form class, so you might use this validation
545       method if you don't want to create a field subclass.
546
547       It has access to the form ($self) and the field.  This method is called
548       after the field class 'validate' method, and is not called if the value
549       for the field is empty ('', undef). (If you want an error message when
550       the field is empty, use the 'required' flag and message or the form
551       'validate' method.)  The name of this method can be set with
552       'set_validate' on the field. The default is 'validate_' plus the field
553       name:
554
555          sub validate_testfield { my ( $self, $field ) = @_; ... }
556
557       If the field name has dots they should be replaced with underscores.
558
559       Note that you can also provide a coderef which will be a method on the
560       field:
561
562          has_field 'foo' => ( validate_method => \&validate_foo );
563
564       validate
565
566       This is a form method that is useful for cross checking values after
567       they have been saved as their final validated value, and for performing
568       more complex dependency validation. It is called after all other field
569       validation is done, and whether or not validation has succeeded, so it
570       has access to the post-validation values of all the fields.
571
572       This is the best place to do validation checks that depend on the
573       values of more than one field.
574
575   Accessing errors
576       Also see HTML::FormHandler::Manual::Errors.
577
578       Set an error in a field with "$field->add_error('some error string');".
579       Set a form error not tied to a specific field with
580       "$self->add_form_error('another error string');".  The 'add_error' and
581       'add_form_error' methods call localization. If you want to skip
582       localization for a particular error, you can use 'push_errors' or
583       'push_form_errors' instead.
584
585         has_errors - returns true or false
586         error_fields - returns list of fields with errors
587         errors - returns array of error messages for the entire form
588         num_errors - number of errors in form
589
590       Each field has an array of error messages. (errors, has_errors,
591       num_errors, clear_errors)
592
593         $form->field('title')->errors;
594
595       Compound fields also have an array of error_fields.
596
597   Clear form state
598       The clear method is called at the beginning of 'process' if the form
599       object is reused, such as when it is persistent in a Moose attribute,
600       or in tests.  If you add other attributes to your form that are set on
601       each request, you may need to clear those yourself.
602
603       If you do not call the form's 'process' method on a persistent form,
604       such as in a REST controller's non-POST method, or if you only call
605       process when the form is posted, you will also need to call
606       "$form->clear".
607
608       The 'run' method which returns a result object always performs 'clear',
609       to keep the form object clean.
610
611   Miscellaneous attributes
612       name
613
614       The form's name.  Useful for multiple forms. Used for the form element
615       'id'.  When 'html_prefix' is set it is used to construct the field 'id'
616       and 'name'.  The default is "form" + a one to three digit random
617       number.  Because the HTML standards have flip-flopped on whether the
618       HTML form element can contain a 'name' attribute, please set a name
619       attribute using 'form_element_attr'.
620
621       init_object
622
623       An 'init_object' may be used instead of the 'item' to pre-populate the
624       values in the form. This can be useful when populating a form from
625       default values stored in a similar but different object than the one
626       the form is creating.  The 'init_object' should be either a hash or the
627       same type of object that the model uses (a DBIx::Class row for the DBIC
628       model). It can be set in a variety of ways:
629
630          my $form = MyApp::Form->new( init_object => { .... } );
631          $form->process( init_object => {...}, ... );
632          has '+init_object' => ( default => sub { { .... } } );
633          sub init_object { my $self = shift; .... }
634
635       The method version is useful if the organization of data in your form
636       does not map to an existing or database object in an automatic way, and
637       you need to create a different type of object for initialization. (You
638       might also want to do 'update_model' yourself.)
639
640       Also see the 'use_init_obj_over_item' and the
641       'use_init_obj_when_no_accessor_in_item' flags, if you want to provide
642       both an item and an init_object, and use the values from the
643       init_object.
644
645       The 'use_init_obj_when_no_accessor_in_item' flag is particularly useful
646       when some of the fields in your form come from the database and some
647       are process or environment type flags that are not in the database. You
648       can provide defaults from both a database row and an 'init_object.
649
650       ctx
651
652       Place to store application context for your use in your form's methods.
653
654       language_handle
655
656       See 'language_handle' and '_build_language_handle' in
657       HTML::FormHandler::TraitFor::I18N.
658
659       dependency
660
661       Arrayref of arrayrefs of fields. If one of a group of fields has a
662       value, then all of the group are set to 'required'.
663
664         has '+dependency' => ( default => sub { [
665            ['street', 'city', 'state', 'zip' ],] }
666         );
667
668   Flags
669       validated, is_valid
670
671       Flag that indicates if form has been validated. You might want to use
672       this flag if you're doing something in between process and returning,
673       such as setting a stash key. ('is_valid' is a synonym for this flag)
674
675          $form->process( ... );
676          $c->stash->{...} = ...;
677          return unless $form->validated;
678
679       ran_validation
680
681       Flag to indicate that validation has been run. This flag will be false
682       when the form is initially loaded and displayed, since validation is
683       not run until FormHandler has params to validate.
684
685       verbose, dump, peek
686
687       Flag to dump diagnostic information. See 'dump_fields' and
688       'dump_validated'. 'Peek' can be useful in diagnosing bugs.  It will
689       dump a brief listing of the fields and results.
690
691          $form->process( ... );
692          $form->peek;
693
694       html_prefix
695
696       Flag to indicate that the form name is used as a prefix for fields in
697       an HTML form. Useful for multiple forms on the same HTML page. The
698       prefix is stripped off of the fields before creating the internal field
699       name, and added back in when returning a parameter hash from the 'fif'
700       method. For example, the field name in the HTML form could be
701       "book.borrower", and the field name in the FormHandler form (and the
702       database column) would be just "borrower".
703
704          has '+name' => ( default => 'book' );
705          has '+html_prefix' => ( default => 1 );
706
707       Also see the Field attribute "html_name", a convenience function which
708       will return the form name + "." + field full_name
709
710       is_html5
711
712       Flag to indicate the fields will render using specialized attributes
713       for html5.  Set to 0 by default.
714
715       use_defaults_over_obj
716
717       The 'normal' precedence is that if there is an accessor in the
718       item/init_object that value is used and not the 'default'. This flag
719       makes the defaults of higher precedence. Mainly useful if providing an
720       empty row on create.
721
722       use_init_obj_over_item
723
724       If you are providing both an item and an init_object, and want the
725       init_object to be used for defaults instead of the item.
726
727   For use in HTML
728          form_element_attr - hashref for setting arbitrary HTML attributes
729             set in form with: sub build_form_element_attr {...}
730          form_element_class - arrayref for setting form tag class
731          form_wrapper_attr - hashref for form wrapper element attributes
732             set in form with: sub build_form_wrapper_attr {...}
733          form_wrapper_class - arrayref for setting wrapper class
734          do_form_wrapper - flag to wrap the form
735          http_method - For storing 'post' or 'get'
736          action - Store the form 'action' on submission. No default value.
737          uuid - generates a string containing an HTML field with UUID
738          form_tags - hashref of tags for use in rendering code
739          widget_tags - rendering tags to be transferred to fields
740
741       Discouraged (use form_element_attr instead):
742
743          style - adds a 'style' attribute to the form tag
744          enctype - Request enctype
745
746       Note that the form tag contains an 'id' attribute which is set to the
747       form name. The standards have been flip-flopping over whether a 'name'
748       attribute is valid. It can be set with 'form_element_attr'.
749
750       The rendering of the HTML attributes is done using the 'process_attrs'
751       function and the 'element_attributes' or 'wrapper_attributes' method,
752       which adds other attributes in for backward compatibility, and calls
753       the 'html_attributes' hook.
754
755       For HTML attributes, there is a form method hook, 'html_attributes',
756       which can be used to customize/modify/localize form & field HTML
757       attributes.  Types: element, wrapper, label, form_element,
758       form_wrapper, checkbox_label
759
760          sub html_attributes {
761              my ( $self, $obj, $type, $attrs, $result ) = @_;
762
763              # obj is either form or field
764              $attr->{class} = 'label' if $type eq 'label';
765              $attr->{placeholder} = $self->_localize($attr->{placeholder})
766                  if exists $attr->{placeholder};
767              return $attr;
768          }
769
770       Also see the documentation in HTML::FormHandler::Field and in
771       HTML::FormHandler::Manual::Rendering.
772

SUPPORT

774       IRC:
775
776         Join #formhandler on irc.perl.org
777
778       Mailing list:
779
780         http://groups.google.com/group/formhandler
781
782       Code repository:
783
784         http://github.com/gshank/html-formhandler/tree/master
785
786       Bug tracker:
787
788         https://rt.cpan.org/Dist/Display.html?Name=HTML-FormHandler
789

SEE ALSO

791       HTML::FormHandler::Manual
792
793       HTML::FormHandler::Manual::Tutorial
794
795       HTML::FormHandler::Manual::Intro
796
797       HTML::FormHandler::Manual::Templates
798
799       HTML::FormHandler::Manual::Cookbook
800
801       HTML::FormHandler::Manual::Rendering
802
803       HTML::FormHandler::Manual::Reference
804
805       HTML::FormHandler::Field
806
807       HTML::FormHandler::Model::DBIC
808
809       HTML::FormHandler::Render::Simple
810
811       HTML::FormHandler::Render::Table
812
813       HTML::FormHandler::Moose
814

CONTRIBUTORS

816       gshank: Gerda Shank <gshank@cpan.org>
817
818       zby: Zbigniew Lukasiak <zby@cpan.org>
819
820       t0m: Tomas Doran <bobtfish@bobtfish.net>
821
822       augensalat: Bernhard Graf <augensalat@gmail.com>
823
824       cubuanic: Oleg Kostyuk <cub.uanic@gmail.com>
825
826       rafl: Florian Ragwitz <rafl@debian.org>
827
828       mazpe: Lester Ariel Mesa
829
830       dew: Dan Thomas
831
832       koki: Klaus Ita
833
834       jnapiorkowski: John Napiorkowski
835
836       lestrrat: Daisuke Maki
837
838       hobbs: Andrew Rodland
839
840       Andy Clayton
841
842       boghead: Bryan Beeley
843
844       Csaba Hetenyi
845
846       Eisuke Oishi
847
848       Lian Wan Situ
849
850       Murray
851
852       Nick Logan
853
854       Vladimir Timofeev
855
856       diegok: Diego Kuperman
857
858       ijw: Ian Wells
859
860       amiri: Amiri Barksdale
861
862       ozum: Ozum Eldogan
863
864       lukast: Lukas Thiemeier
865
866       Initially based on the source code of Form::Processor by Bill Moseley
867

AUTHOR

869       FormHandler Contributors - see HTML::FormHandler
870
872       This software is copyright (c) 2017 by Gerda Shank.
873
874       This is free software; you can redistribute it and/or modify it under
875       the same terms as the Perl 5 programming language system itself.
876
877
878
879perl v5.36.0                      2022-07-22              HTML::FormHandler(3)
Impressum