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( $html_document, $base_uri
)
- @forms = HTML::Form->parse( $html_document, base =>
$base_uri, %opt )
- @forms = HTML::Form->parse( $response, %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 required arguments is the HTML document to parse ($html_document) and
the URI used to retrieve the document ($base_uri). The base URI is needed
to resolve relative action URIs. The provided HTML document should be a
Unicode string (or US-ASCII).
By default HTML::Form assumes that the original document was UTF-8 encoded
and thus encode forms that don't specify an explicit accept-charset
as UTF-8. The charset assumed can be overridden by providing the
"charset" option to parse(). It's a good idea to be
explicit about this parameter as well, thus the recommended simplest
invocation becomes:
my @forms = HTML::Form->parse(
Encode::decode($encoding, $html_document_bytes),
base => $base_uri,
charset => $encoding,
);
If the document was retrieved with LWP then the response object provide
methods to obtain a proper value for "base" and
"charset":
my $ua = LWP::UserAgent->new;
my $response = $ua->get("http://www.example.com/form.html");
my @forms = HTML::Form->parse($response->decoded_content,
base => $response->base,
charset => $response->content_charset,
);
In fact, 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(),
base() and content_charset() method with similar behaviour
as "HTTP::Response" will do.
Additional options might be passed in to control how the parse method
behaves. The following are all the options currently recognized:
- "base => $uri"
- This is the URI used to retrive the original document. This
option is not optional ;-)
- "charset => $str"
- Specify what charset the original document was encoded in.
This is used as the default for accept_charset. If not provided this
defaults to "UTF-8".
- "verbose => $bool"
- Warn (print messages to STDERR) about any bad HTML form
constructs found. You can trap these with $SIG{__WARN__}. The default is
not to issue warnings.
- "strict => $bool"
- Initialize any form objects with the given strict
attribute. If the strict is turned on the methods that change values of
the form will croak if you try to set illegal values or modify readonly
fields. The default is not to be strict.
- $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".
- $accept = $form->accept_charset
- $form->accept_charset( $new_accept )
- This method gets/sets the list of charset encodings that
the server processing the form accepts. Current implementation supports
only one-element lists. Default value is "UNKNOWN" which we
interpret as a request to use document charset as specified by the
'charset' parameter of the parse() method.
- $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;
- $bool = $form->strict
- $form->strict( $bool )
- Gets/sets the strict attribute of a form. If the strict is
turned on the methods that change values of the form will croak if you try
to set illegal values or modify readonly fields. The default is not to be
strict.
- @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( $selector )
- $input = $form->find_input( $selector, $type )
- $input = $form->find_input( $selector, $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 $selector is specified, then the input's name, id, class attribute must
match. A selector prefixed with '#' must match the id attribute of the
input. A selector prefixed with '.' matches the class attribute. A
selector prefixed with '^' or with no prefix matches the name attribute.
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( $selector )
- $form->value( $selector, $new_value )
- The value() method can be used to get/set the value
of some input. If strict is enabled and 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 basically 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( $selector )
- $request = $form->click( $x, $y )
- $request = $form->click( $selector, $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 $selector is specified, we will click on the first clickable input
matching the selector, and the method will croak if no matching clickable
input is found. If $selector 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. See
description of the find_input() method above for how the $selector
is specified.
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.
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.
- $input->id
- $input->class
- These methods can be used to get/set the current id or
class attribute for the input.
- $input->selected( $selector )
- Returns TRUE if the given selector matched the input. See
the description of the find_input() method above for a description
of the selector syntax.
- $value = $input->value
- $input->value( $new_value )
- This method can be used to get/set the current value of an
input.
If strict is enabled and 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.
For security reasons this field will never be initialized from the parsing
of a form. This prevents the server from triggering stealth uploads of
arbitrary files from the client machine.
- $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-2008 Gisle Aas.
This library is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.