HTML::Form(3) User Contributed Perl Documentation HTML::Form(3)
NAME
HTML::Form - Class that represents an HTML form element
SYNOPSIS
use HTML::Form;
$form = HTML::Form->parse($html, $base_uri);
$form->value(query => "Perl");
use LWP::UserAgent;
$ua = LWP::UserAgent->new;
$response = $ua->request($form->click);
DESCRIPTION
Objects of the "HTML::Form" class represents a single HTML "<form> ... </form>" instance. A form
consists of a sequence of inputs that usually have names, and which can take on various values. The
state of a form can be tweaked and it can then be asked to provide "HTTP::Request" objects that can
be passed to the request() method of "LWP::UserAgent".
The following methods are available:
@forms = HTML::Form->parse( $response )
@forms = HTML::Form->parse( $html_document, $base )
@forms = HTML::Form->parse( $html_document, %opt )
The parse() class method will parse an HTML document and build up "HTML::Form" objects for each
<form> element found. If called in scalar context only returns the first <form>. Returns an
empty list if there are no forms to be found.
The $base is the URI used to retrieve the $html_document. It is needed to resolve relative
action URIs. If the document was retrieved with LWP then this this parameter is obtained from
the $response->base() method, as shown by the following example:
my $ua = LWP::UserAgent->new;
my $response = $ua->get("http://www.example.com/form.html");
my @forms = HTML::Form->parse($response->decoded_content,
$response->base);
The parse() method can parse from an "HTTP::Response" object directly, so the example above can
be more conveniently written as:
my $ua = LWP::UserAgent->new;
my $response = $ua->get("http://www.example.com/form.html");
my @forms = HTML::Form->parse($response);
Note that any object that implements a decoded_content() and base() method with similar behaviour
as "HTTP::Response" will do.
Finally options might be passed in to control how the parse method behaves. The following
options are currently recognized:
"base"
Another way to provide the base URI.
"verbose"
Print messages to STDERR about any bad HTML form constructs found.
$method = $form->method
$form->method( $new_method )
This method is gets/sets the method name used for the "HTTP::Request" generated. It is a string
like "GET" or "POST".
$action = $form->action
$form->action( $new_action )
This method gets/sets the URI which we want to apply the request method to.
$enctype = $form->enctype
$form->enctype( $new_enctype )
This method gets/sets the encoding type for the form data. It is a string like
"application/x-www-form-urlencoded" or "multipart/form-data".
$value = $form->attr( $name )
$form->attr( $name, $new_value )
This method give access to the original HTML attributes of the <form> tag. The $name should
always be passed in lower case.
Example:
@f = HTML::Form->parse( $html, $foo );
@f = grep $_->attr("id") eq "foo", @f;
die "No form named 'foo' found" unless @f;
$foo = shift @f;
@inputs = $form->inputs
This method returns the list of inputs in the form. If called in scalar context it returns the
number of inputs contained in the form. See "INPUTS" for what methods are available for the
input objects returned.
$input = $form->find_input( $name )
$input = $form->find_input( $name, $type )
$input = $form->find_input( $name, $type, $index )
This method is used to locate specific inputs within the form. All inputs that match the
arguments given are returned. In scalar context only the first is returned, or "undef" if none
match.
If $name is specified, then the input must have the indicated name.
If $type is specified, then the input must have the specified type. The following type names are
used: "text", "password", "hidden", "textarea", "file", "image", "submit", "radio", "checkbox"
and "option".
The $index is the sequence number of the input matched where 1 is the first. If combined with
$name and/or $type then it select the nth input with the given name and/or type.
$value = $form->value( $name )
$form->value( $name, $new_value )
The value() method can be used to get/set the value of some input. If no input has the indicated
name, then this method will croak.
If multiple inputs have the same name, only the first one will be affected.
The call:
$form->value('foo')
is a short-hand for:
$form->find_input('foo')->value;
@names = $form->param
@values = $form->param( $name )
$form->param( $name, $value, ... )
$form->param( $name, \@values )
Alternative interface to examining and setting the values of the form.
If called without arguments then it returns the names of all the inputs in the form. The names
will not repeat even if multiple inputs have the same name. In scalar context the number of
different names is returned.
If called with a single argument then it returns the value or values of inputs with the given
name. If called in scalar context only the first value is returned. If no input exists with the
given name, then "undef" is returned.
If called with 2 or more arguments then it will set values of the named inputs. This form will
croak if no inputs have the given name or if any of the values provided does not fit. Values can
also be provided as a reference to an array. This form will allow unsetting all values with the
given name as well.
This interface resembles that of the param() function of the CGI module.
$form->try_others( \&callback )
This method will iterate over all permutations of unvisited enumerated values (<select>, <radio>,
<checkbox>) and invoke the callback for each. The callback is passed the $form as argument. The
return value from the callback is ignored and the try_others() method itself does not return
anything.
$request = $form->make_request
Will return an "HTTP::Request" object that reflects the current setting of the form. You might
want to use the click() method instead.
$request = $form->click
$request = $form->click( $name )
$request = $form->click( $x, $y )
$request = $form->click( $name, $x, $y )
Will "click" on the first clickable input (which will be of type "submit" or "image"). The
result of clicking is an "HTTP::Request" object that can then be passed to "LWP::UserAgent" if
you want to obtain the server response.
If a $name is specified, we will click on the first clickable input with the given name, and the
method will croak if no clickable input with the given name is found. If $name is not specified,
then it is ok if the form contains no clickable inputs. In this case the click() method returns
the same request as the make_request() method would do.
If there are multiple clickable inputs with the same name, then there is no way to get the
click() method of the "HTML::Form" to click on any but the first. If you need this you would
have to locate the input with find_input() and invoke the click() method on the given input
yourself.
A click coordinate pair can also be provided, but this only makes a difference if you clicked on
an image. The default coordinate is (1,1). The upper-left corner of the image is (0,0), but
some badly coded CGI scripts are known to not recognize this. Therefore (1,1) was selected as a
safer default.
@kw = $form->form
Returns the current setting as a sequence of key/value pairs. Note that keys might be repeated,
which means that some values might be lost if the return values are assigned to a hash.
In scalar context this method returns the number of key/value pairs generated.
$form->dump
Returns a textual representation of current state of the form. Mainly useful for debugging. If
called in void context, then the dump is printed on STDERR.
INPUTS
An "HTML::Form" objects contains a sequence of inputs. References to the inputs can be obtained with
the $form->inputs or $form->find_input methods.
Note that there is not a one-to-one correspondence between input objects and <input> elements in the
HTML document. An input object basically represents a name/value pair, so when multiple HTML
elements contribute to the same name/value pair in the submitted form they are combined.
The input elements that are mapped one-to-one are "text", "textarea", "password", "hidden", "file",
"image", "submit" and "checkbox". For the "radio" and "option" inputs the story is not as simple:
All <input type="radio"> elements with the same name will contribute to the same input radio object.
The number of radio input objects will be the same as the number of distinct names used for the
<input type="radio"> elements. For a <select> element without the "multiple" attribute there will be
one input object of type of "option". For a <select multiple> element there will be one input object
for each contained <option> element. Each one of these option objects will have the same name.
The following methods are available for the input objects:
$input->type
Returns the type of this input. The type is one of the following strings: "text", "password",
"hidden", "textarea", "file", "image", "submit", "radio", "checkbox" or "option".
$name = $input->name
$input->name( $new_name )
This method can be used to get/set the current name of the input.
$value = $input->value
$input->value( $new_value )
This method can be used to get/set the current value of an input.
If the input only can take an enumerated list of values, then it is an error to try to set it to
something else and the method will croak if you try.
You will also be able to set the value of read-only inputs, but a warning will be generated if
running under "perl -w".
$input->possible_values
Returns a list of all values that an input can take. For inputs that do not have discrete
values, this returns an empty list.
$input->other_possible_values
Returns a list of all values not tried yet.
$input->value_names
For some inputs the values can have names that are different from the values themselves. The
number of names returned by this method will match the number of values reported by
$input->possible_values.
When setting values using the value() method it is also possible to use the value names in place
of the value itself.
$bool = $input->readonly
$input->readonly( $bool )
This method is used to get/set the value of the readonly attribute. You are allowed to modify
the value of readonly inputs, but setting the value will generate some noise when warnings are
enabled. Hidden fields always start out readonly.
$bool = $input->disabled
$input->disabled( $bool )
This method is used to get/set the value of the disabled attribute. Disabled inputs do not
contribute any key/value pairs for the form value.
$input->form_name_value
Returns a (possible empty) list of key/value pairs that should be incorporated in the form value
from this input.
$input->check
Some input types represent toggles that can be turned on/off. This includes "checkbox" and
"option" inputs. Calling this method turns this input on without having to know the value name.
If the input is already on, then nothing happens.
This has the same effect as:
$input->value($input->possible_values[1]);
The input can be turned off with:
$input->value(undef);
$input->click($form, $x, $y)
Some input types (currently "submit" buttons and "images") can be clicked to submit the form.
The click() method returns the corresponding "HTTP::Request" object.
If the input is of type "file", then it has these additional methods:
$input->file
This is just an alias for the value() method. It sets the filename to read data from.
$filename = $input->filename
$input->filename( $new_filename )
This get/sets the filename reported to the server during file upload. This attribute defaults to
the value reported by the file() method.
$content = $input->content
$input->content( $new_content )
This get/sets the file content provided to the server during file upload. This method can be
used if you do not want the content to be read from an actual file.
@headers = $input->headers
input->headers($key => $value, .... )
This get/set additional header fields describing the file uploaded. This can for instance be
used to set the "Content-Type" reported for the file.
SEE ALSO
LWP, LWP::UserAgent, HTML::Parser
COPYRIGHT
Copyright 1998-2005 Gisle Aas.
This library is free software; you can redistribute it and/or modify it under the same terms as Perl
itself.
perl v5.8.8 2005-12-07 HTML::Form(3)
|