Module::Build is a system for building, testing, and installing Perl
modules. It is meant to be an alternative to ExtUtils::MakeMaker.
Developers may alter the behavior of the module through subclassing in a
much more straightforward way than with MakeMaker. It also does not require
a make on your system - most of the Module::Build code is pure-perl and
written in a very cross-platform way. In fact, you don't even need a shell,
so even platforms like MacOS (traditional) can use it fairly easily. Its
only prerequisites are modules that are included with perl 5.6.0, and it
works fine on perl 5.005 if you can install a few additional modules.

This module offers some high level convinience functions for accessing
web pages on SSL servers (for symmetry, same API is offered for
accessing http servers, too), a sslcat() function for writing your own
clients, and finally access to the SSL api of SSLeay/OpenSSL package
so you can write servers or clients for more complicated applications.

Developers hate writing documentation. They'd hate it even more if their
computer tattled on them, but maybe they'll be even more thankful in the
long run. Even if not, perlmodstyle tells you to, so you must obey.

This module provides a mechanism for determining if the pod for a given
module is comprehensive.

This module provides things that are useful in decoding Pod E(...)
sequences. Presumably, it should be used only by Pod parsers and/or
formatters.

Pod::Simple is a Perl library for parsing text in the Pod ("plain old
documentation") markup language that is typically used for writing
documentation for Perl and for Perl modules.

Socket::MsgHdr provides advanced socket messaging operations via
sendmsg and recvmsg.

Authors:
--------
Michael J. Pomraning

Like Tcl's uplevel() function, but not quite so dangerous. The
idea is just to fool caller(). All the really naughty bits of
Tcl's uplevel() are avoided.

This module provides a few convenience methods for testing exception
based code. It is built with Test::Builder and plays happily with
Test::More and friends.

In general, your tests shouldn't produce warnings. This module causes any
warnings to be captured and stored. It automatically adds an extra test
that will run when your script ends to check that there were no warnings.
If there were any warings, the test will give a "not ok" and diagnostics of
where, when and what the warning was, including a stack trace of what was
going on when the it occurred.

Perl module for checking for POD errors in files.

Checks for POD coverage in files for your distribution.

If you have written a test module based on Test::Builder then Test::Tester
allows you to test it with the minimum of effort.

This module provides a few convenience methods for testing warning
based code.

This module includes a number of smaller modules suited for
manipulation of time and date strings with Perl. In particular, the
Date::Format and Date::Parse modules can display and read times and
dates in various formats, providing a more reliable interface to
textual representations of points in time.

This class encapsulates/makes/manipulates objects that represent nodes
in a tree structure. The tree structure is not an object itself, but
is emergent from the linkages you create between nodes. This class
provides the methods for making linkages that can be used to build up
a tree, while preventing you from ever making any kinds of linkages
which are not allowed in a tree (such as having a node be its own
mother or ancestor, or having a node have two mothers).

The YAML.pm module implements a YAML Loader and Dumper based on the
YAML 1.0 specification. http://www.yaml.org/spec/
YAML is a generic data serialization language that is optimized for
human readability. It can be used to express the data structures of
most modern programming languages, including Perl.
For information on the YAML syntax, please refer to the YAML
specification.

Ruby is the interpreted scripting language for quick and easy
object-oriented programming. It has many features to process text
files and to do system management tasks (as in Perl). It is simple,
straight-forward, and extensible.

FastCGI is a language independent, scalable, open extension to CGI that
provides high performance without the limitations of server specific
APIs.

This package provides bindings for the ruby language.

Authors:
--------
Tatsuki Sugiura (sugi@nemui.org)

This is the MySQL API module for Ruby. It provides the same functions for
Ruby programs that the MySQL C API provides for C programs.

Makes it trivial to test and deliver emails sent from a single service layer.

Eases web-request routing, handling, and response as a half-way front, half-way
page controller. Implemented with specific emphasis on enabling easy
unit/integration testing that doesn't require a browser.

Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database
tables and classes together for business objects, like Customer or
Subscription, that can find, save, and destroy themselves without resorting to
manual SQL.

Wraps web resources in model classes that can be manipulated through XML over REST.

Utility library which carries commonly used classes and goodies from the Rails framework

Daemons provides an easy way to wrap existing ruby scripts (for example
a self-written server) to be run as a daemon and to be controlled by
simple start/stop/restart commands.

If you want, you can also use daemons to run blocks of ruby code in a
daemon process and to control these processes from the main
application.

Besides this basic functionality, daemons offers many advanced features
like exception backtracing and logging (in case your ruby script
crashes) and monitoring and automatic restarting of your processes if
they crash.

Daemons includes the daemonize.rb script written by Travis Whitton to
do the daemonization process.

Authors:
--------
Thomas Uehlinger (th.uehlinger@gmx.ch)