Free well formed software for linux

Resizeable Form Fields is an extension which allows you to resize HTML form fields, including textareas, select boxes and more.

Resize HTML form fields, including textareas, select boxes, text fields, and iframes.

WWW::Form is a module for handling the world-wide-web form process. The project enables generating forms, filling them from user input, verifying them, and re-displaying them in case something is wrong.

Tie::Form is a Perl module to access a machine readable database file that minics a hardcopy form.

SYNOPSIS

require Tie::Form;

#####
# Using support methods and file handle with
# the file subroutines such as open(), readline()
# print(), close()
#
tie *FORM_FILEHANDLE, Tie::Form, @options
$form = tied *FORM_FILEHANDLE;

#####
# Using support methods only, no file subroutines
#
$form = Tie::Form->new(@options);

$encoded_fields = $form->decode_record($record);
@fields = $form->decode_field($encoded_fields);

$encoded_fields = $form->encode_field (@fields);
$record = $form->encode_record($encoded_fields);

$record = $form->get_record();

####
# Subroutine interface
#
$encoded_fields = decode_record($record);
@fields = decode_field($encoded_fields);

$encoded_fields = encode_field (@fields);
$record = encode_record($encoded_fields);

If a subroutine or method will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}.

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.

Contact Form Killer is a free tool you can use to generate contact forms for your site, or let your web site visitors add contact forms themselves.
Contact Form Killer script takes care of messy form validation with both JavaScript and PHP, just in case they have JavaScript disabled. The contact forms it generates are nicely formatted and can be further edited to match the look and feel of your site.
Main features:
- Easy to install. Just unzip and upload, or if youre using it on a local server, just unzip!
- Quick generation of contact forms that usually take hours to code.
- JavaScript validation of each input for ultimate usability.
- PHP validation to make sure JavaScript-disablers dont slip the radar.
- Over 10 inputs to pick and choose from.
- Form generation is really easy, just click the checkboxes next to the inputs you want, click submit and youre done!

Wheatblog is blogware: its a web-based content management system for maintaining online blogs, journals, news pages, and about anything else you can think of writing down.
WheatBlog allows reader interaction with a comment system, and generates valid RSS 2.0 feeds. It is powered by PHP and is compatible with the MySQL and SQLite database systems.
Main features:
- Simple, straightforward installation and use.
- All pages are dynamically created using PHP and a database.
- Posts can be assigned to categories and viewed by category or title.
- Permanent URLs, or permalinks, provide a unique, unchanging link
- to each post, and are readily indexed by search engines.
- All posts allow reader comments, but can be locked by the administrator at any time.
- A post can be marked visible or hidden at any time, allowing multiple revisions before publishing.
- All post dates are arbitrary (not based on timestamps) and therefore completely controllable by the author.
- Generates valid, well-formed RSS 2.0 feeds of your visible posts for effortless syndication.
- Valid XHTML makes customization as easy as modifying one CSS file.
- Best of all, its open source! You can hack it to suit your needs!
Enhancements:
- This release includes comment spam protection (via a simple CAPTCHA implementation) and improves RSS feeds.

Test::XML::Order is a Perl module to compare the order of XML tags in perl tests.

SYNOPSIS

use Test::XML::Order tests => 3;
is_xml_in_order( , ); # PASS
is_xml_in_order( , ); # FAIL
isnt_xml_in_order( , ); # PASS

This module contains generic XML testing tools. See below for a list of other modules with functions relating to specific XML modules.

FUNCTIONS

is_xml_in_order ( GOT, EXPECTED [, TESTNAME ] )

This function compares GOT and EXPECTED, both of which are strings of XML. The comparison works only on the order of the tags, attributes are ignored.

Returns true or false, depending upon test success.

isnt_xml_in_order( GOT, MUST_NOT_BE [, TESTNAME ] )

This function is similar to is_xml_in_order(), except that it will fail if GOT and MUST_NOT_BE have elements in the same order.

NOTES

Please note the following about Test::XML::Order.

The package does not check that the input is well formed XML. You should use Test::XML or a similar package if you want to make sure the XML is well formed.
Only the order of tags are checked, so

is_xml_in_order(< a a="b"/ >x< b >< /b >, < a/ >< b a="c" >asdf< /b >);

passes as the inputs have the same order: < a/ >< b/ >.

The tree structure is tested so the the test below passes.

isnt_xml_in_order(< a >< b/ >< /a >, < a/ >< b/ >);