This is a little module made for CGI scripting. It encodes the parameters to
be passed to a CGI. It does nothing more, so it's much smaller and loads more
quickly.
CGI::Ex provides a suite of utilities to make writing CGI scripts more
enjoyable. Although they can all be used separately, the main functionality of
each of the modules is best represented in the CGI::Ex::App module. CGI::Ex::App
takes CGI application building to the next step. CGI::Ex::App is not quite a
framework (which normally includes pre-built html) instead CGI::Ex::App is an
extended application flow that dramatically reduces CGI build time in most
cases. It does so using as little magic as possible. See CGI::Ex::App.
The main functionality is provided by several other modules that may be used
separately, or together through the CGI::Ex interface.
Converts a CGI query into structured data using a dotted name convention
similar to TT2.
expand_cgi works with CGI.pm, Apache::Request or anything with an appropriate
"param" method. Or you can use expand_hash directly.
If you prefer to use a different flattening convention then CGI::Expand can
be subclassed.
This module implement RPC::ExtDirect gateway for CGI environment.
It was successfully tested in Apache CGI and
HTTP::Server::Simple::CGI applications.
CGI::Fast is a subclass of the CGI object created by CGI.pm. It is specialized
to work with the FCGI module, which greatly speeds up CGI scripts by turning
them into persistently running server processes. Scripts that perform
time-consuming initialization processes, such as loading large modules or
opening persistent database connections, will see large performance
improvements.
The goal of CGI::FormBuilder (FormBuilder) is to provide an easy way
for you to generate and process entire CGI form-based applications.
Its main features are:
* Field Abstraction
Viewing fields as entities (instead of just params), where the HTML
representation, CGI values, validation, and so on are properties of
each field.
* DWIMmery
Lots of built-in "intelligence" (such as automatic field typing),
giving you about a 4:1 ratio of the code it generates versus what
you have to write.
* Built-in Validation
Full-blown regex validation for fields, even including JavaScript
code generation.
* Template Support
Pluggable support for external template engines, such as
HTML::Template, Text::Template, Template Toolkit, and
CGI::FastTemplate.
Plus, the native HTML generated is valid XHTML 1.0 Transitional.
CGI::Framework is a simple and lightweight framework for building web-based CGI
applications. It features complete code-content separation (templating) by
utilizing the HTML::Template library, stateful file or database-based sessions
by utilizing the CGI::Session library, form parsing by utilizing the CGI
library, (optional) multi-lingual templates support, and an extremely easy to
use methodology for the validation, pre-preparation and post-cleanup associated
with each template. It also provides easy logging mechanisms, graceful fatal
error handling, including special templates and emails to admins.
CGI::Pager performs the "dirty work" necessary to program paginated
data display in a web application.
Based on given resultset size, page size, and offset value sensed from
current URI, it constructs links for navigation between results pages.
It can be used conveniently from a templating system, has both OO and
functional interface, and can optionally generate necessary HTML
itself.
The core of every CGI application seems to be roughly the same:
- analyze the incoming parameters, cookies, and URLs to determine the
state of the application (let's call this "dispatch").
- based on the current state, analyze the incoming parameters to respond
to any form submitted ("respond").
- from there, decide what response page should be generated, and produce
it ("render").
CGI::Prototype creates a Class::Prototyped engine for doing all this,
with the right amount of callback hooks to customize the process.
CGI::SSI is meant to be used as an easy way to filter shtml through CGI
scripts in a loose imitation of Apache's mod_include. If you're using
Apache, you may want to use either mod_include or the Apache::SSI module
instead of CGI::SSI. Limitations in a CGI script's knowledge of how the
server behaves make some SSI directives impossible to imitate from a CGI
script.