Text::Glob implements glob(3) style matching that can be used to match against text, rather than fetching names from a filesystem. If you want to do full file globbing use the File::Glob module instead.

XML::Dumper dumps Perl data to XML format. XML::Dumper can also read
XML data that was previously dumped by the module and convert it back
to Perl. You can use the module read the XML from a file and write the
XML to a file. Perl objects are blessed back to their original
packaging; if the modules are installed on the system where the perl
objects are reconstituted from xml, they will behave as expected.
Intuitively, if the perl objects are converted and reconstituted in the
same environment, all should be well. And it is.

This is a short and simple class allowing simple object access to a
parsed XML::LibXML tree, with methods for fetching children and
attributes in as clean a manner as possible.

sendxmpp is a perl-script to send xmpp (jabber), similar to
what mail(1) does for mail.

GNU cfengine is an abstract programming language for system
administrators of huge heterogeneous networks. With cfengine, system
administrators have an easy and elegant way to maintain complicated
networks.

This module/script gets the CDDB info for an audio cd. You need LINUX,
SUNOS or *BSD, a cdrom drive and an active internet connection in order
to do that.

CGI-Session is a Perl5 library that provides an easy, reliable and
modular session management system across HTTP requests. Persistency is
a key feature for such applications as shopping carts,
login/authentication routines, and application that need to carry data
across HTTP requests. CGI::Session does that and many more.

'Config::Tiny' is a perl class to read and write .ini style configuration
files with as little code as possible, reducing load time and memory
overhead. Most of the time it is accepted that Perl applications use a lot
of memory and modules. The '::Tiny' family of modules is specifically
intended to provide an ultralight alternative to the standard modules.

This module is primarily for reading human written files, and anything we
write shouldn't need to have documentation/comments. If you need something
with more power move up to the Config::Simple manpage, the Config::General
manpage or one of the many other 'Config::' modules. To rephrase, the
Config::Tiny manpage does *not* preserve your comments, whitespace, or the
order of your config file.

This module is a compatibility wrapper around Date::Parse.

Author: Joshua Hoblitt (JHOBLITT)

This module provides a simple means for generating an RFC 2822 compliant
datetime string. (In case you care, they're not RFC 822 dates, because they
use a four digit year, which is not allowed in RFC 822.)

File::Find::Rule is a friendlier interface to File::Find. It allows you to build rules which specify the desired files and directories.

This module implements the Font::AFM class. Objects of this class are
initialized from an AFM file and allow you to obtain information about
the font and the metrics of the various glyphs in the font.

Perl bindings to the 2.x series of the Gtk+ widget set. This module
allows you to write graphical user interfaces in a perlish and
object-oriented way, freeing you from the casting and memory management
in C, yet remaining very close in spirit to original API.

This is a collection of modules that format HTML as plain text,
PostScript, or RTF.

HTML-Tree is a suite of Perl modules for making parse trees out of HTML
source. It consists of mainly two modules, whose documentation you should
refer to: HTML::TreeBuilder and HTML::Element.

HTML::TreeBuilder is the module that builds the parse trees. (It uses
HTML::Parser to do the work of breaking the HTML up into tokens.)

The tree that TreeBuilder builds for you is made up of objects of the class
HTML::Element.

If you find that you do not properly understand the documentation for
HTML::TreeBuilder and HTML::Element, it may be because you are unfamiliar
with tree-shaped data structures, or with object-oriented modules in
general. Sean Burke has written some articles for _The Perl Journal_
('www.tpj.com') that seek to provide that background. The full text of
those articles is contained in this distribution, as:

* HTML::Tree::AboutObjects

"User's View of Object-Oriented Modules" from TPJ17.

* HTML::Tree::AboutTrees

"Trees" from TPJ18

* HTML::Tree::Scanning

"Scanning HTML" from TPJ19

Readers already familiar with object-oriented modules and tree-shaped data
structures should read just the last article. Readers without that
background should read the first, then the second, and then the third.

new
Redirects to HTML::TreeBuilder::new

new_from_file
Redirects to HTML::TreeBuilder::new_from_file

new_from_content
Redirects to HTML::TreeBuilder::new_from_content

The Image::Size library is based upon the "wwwis" script written by
Alex Knowles *(alex@ed.ac.uk)*, a tool to examine HTML and add 'width'
and 'height' parameters to image tags. The sizes are cached internally
based on the file name, so multiple calls on the same file name (images
used in bulleted lists, for example) do not result in repeated
computations.

The IO::Socket::Multicast module subclasses IO::Socket::INET to enable
you to manipulate multicast groups. With this module (and an operating
system that supports multicasting), you will be able to receive
incoming multicast transmissions and generate your own outgoing
multicast packets.

This module implements an interface to the Linux 2.6.13 and later
Inotify file/directory change notification sytem.

Simple platform independent e-mail from your perl script.

Math::Calc::Units is a simple calculator that keeps track of units. It
currently handles combinations of byte sizes and duration only, although adding
any other multiplicative types is easy. Any unknown type is treated as a unique
user type (with some effort to map English plurals to their singular forms).

The primary intended use is via the ucalc script that prints out all of the
"readable" variants of a value. For example, "3 bytes" will only produce "3
byte", but "3 byte / sec" produces the original along with "180 byte / minute",
"10.55 kilobyte / hour", etc.

Nagios::Plugin and its associated Nagios::Plugin::* modules are a family of perl modules to streamline writing Nagios plugins. The main end user modules are Nagios::Plugin, providing an object-oriented interface to the entire Nagios::Plugin::* collection, and Nagios::Plugin::Functions, providing a simpler functional interface to a useful subset of the available functionality.

The purpose of the collection is to make it as simple as possible for developers to create plugins that conform the Nagios Plugin guidelines (http://nagiosplug.sourceforge.net/developer-guidelines.html).

It intends to provide a cleaner, simpler, and complete implementation
of a RIPE Database client.

Number::Compare compiles a simple comparison to an anonymous subroutine,
which you can call with a value to be tested again.

Now this would be very pointless, if Number::Compare didn't understand
magnitudes.

The target value may use magnitudes of kilobytes ('k', 'ki'), megabytes
('m', 'mi'), or gigabytes ('g', 'gi'). Those suffixed with an 'i' use the
appropriate 2**n version in accordance with the IEC standard:
http://physics.nist.gov/cuu/Units/binary.html

Pango is a library for laying out and rendering text, with an emphasis on
internationalization. Pango can be used anywhere that text layout is
needed, but using Pango in conjunction with L and/or L
provides a complete solution with high quality text handling and graphics
rendering.

Dynamically loaded modules handle text layout for particular
combinations of script and font backend. Pango provides a wide selection
of modules, including modules for Hebrew, Arabic, Hangul, Thai, and a
number of Indic scripts. Virtually all of the world's major scripts are
supported.

In addition to the low level layout rendering routines, Pango includes
Pango::Layout, a high level driver for laying out entire blocks of text,
and routines to assist in editing internationalized text.

This module provides an intuitive, Perl-ish way to write forking
programs by letting you use blocks to illustrate which code section
executes in which fork. The code for the parent, child, retry handler
and error handler are grouped together in a "fork block". The clauses
may appear in any order, but they must be consecutive (without any
other statements in between).