Net::Whois::Raw queries WHOIS servers about domains. The module supports
recursive WHOIS queries. Also queries via HTTP is supported for some TLDs.

Setting the variables $OMIT_MSG and $CHECK_FAIL will match the results against
a set of known patterns. The first flag will try to omit the copyright
message/disclaimer, the second will attempt to determine if the search failed
and return undef in such a case.

IMPORTANT: these checks merely use pattern matching; they will work on several
servers but certainly not on all of them.

Author:
-------
Ariel Brosh schop@cpan.org
Gabor Szabo gabor@perl.org.il
Corris Randall corris@cpan.org
Walery Studennikov despair@cpan.org

A big part of good API design is that we should be able to be flexible in the
ways that we take parameters.

Params::Coerce attempts to encourage this, by making it easier to take a
variety of different arguments, while adding negligable additional complexity
to your code.

Author:
-------
Adam Kennedy

'Params::Util' provides a basic set of importable functions that makes
checking parameters a hell of a lot easier

While they can be (and are) used in other contexts, the main point behind
this module is that the functions *both* Do What You Mean, and Do The Right
Thing, so they are most useful when you are getting params passed into your
code from someone and/or somewhere else and you can't really trust the
quality.

Thus, 'Params::Util' is of most use at the edges of your API, where params
and data are coming in from outside your code.

The functions provided by 'Params::Util' check in the most strictly correct
manner known, are documented as thoroughly as possible so their exact
behaviour is clear, and heavily tested so make sure they are not fooled by
weird data and Really Bad Things.

To use, simply load the module providing the functions you want to use as
arguments (as shown in the SYNOPSIS).

To aid in maintainability, 'Params::Util' will *never* export by default.

You must explicitly name the functions you want to export, or use the
':ALL' param to just have it export everything (although this is not
recommended if you have any _FOO functions yourself with which future
additions to 'Params::Util' may clash)

This is a lightweight module which provides 'Junction' operators, the most
commonly used being 'any' and 'all'.

Inspired by the Perl6 design docs, the
http://dev.perl.org/perl6/doc/design/exe/E06.html manpage.

Provides a limited subset of the functionality of the
Quantum::Superpositions manpage, see the /"SEE ALSO" manpage for comment.

Notice in the the /SYNOPSIS manpage above, that if you want to match
against a regular expression, you must use '==' or '!='. *Not* '=~' or
'!~'. You must also use a regex object, such as 'qr/\d/', not a plain regex
such as '/\d/'.

When using the Pod::Coverage manpage in combination with the Moose manpage,
it will report any method imported from a Role. This is especially bad when
used in combination with the Test::Pod::Coverage manpage, since it takes
away its ease of use.

To use this module in combination with the Test::Pod::Coverage manpage, use
something like this:

use Test::Pod::Coverage;
all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::Moose'});

POE is a framework for cooperative, event driven multitasking and networking in
Perl. Other languages have similar frameworks. Python has Twisted. TCL has "the
event loop".

POE originally was developed as the core of a persistent object server and
runtime environment. It has since evolved into something much more generic and
widely useful.

POE provides a unified interface for several other event loops, including
select(), IO::Poll, Glib, Gtk, Tk, Wx, Gtk2, and so on. Check the CPAN for the
full list of POE::Loop modules.

POE is designed in layers, each building atop the lower level ones. Programs
are free to use POE at any level of abstraction, and different levels can be
mixed and matched seamlessly within a single program.

POE's bundled abstraction layers are the tip of a growing iceberg. Sprocket,
POE::Stage, and other CPAN distributions build upon this work. You're
encouraged to look around.

No matter how high you go, though, it all boils down to calls to POE::Kernel.
So your down-to-earth code can easily cooperate with stratospheric systems.

POE::Test::Loops contains one function, generate(), which will generate all
the loop tests for one or more POE::Loop subclasses.

The "SYNOPSIS" example is a version of poe-gen-tests, which is a
stand-alone utility to generate the actual tests. poe-gen-tests also
documents the POE::Test::Loops system in more detail.

'Test::LeakTrace' provides several functions that trace memory leaks. This
module scans arenas, the memory allocation system, so it can detect any
leaked SVs in given blocks.

*Leaked SVs* are SVs which are not released after the end of the scope they
have been created. These SVs include global variables and internal caches.
For example, if you call a method in a tracing block, perl might prepare a
cache for the method. Thus, to trace true leaks, 'no_leaks_ok()' and
'leaks_cmp_ok()' executes a block more than once.

This module provides some drop-in replacements for the string comparison
functions of Test::More, but which are more suitable when you test against long
strings. If you've ever had to search for text in a multi-line string like an
HTML document, or find specific items in binary data, this is the module for
you.

The perl-Test-NoWarnings package

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

According to the *Test::More* documentation, it is recommended to run
'use_ok()' inside a 'BEGIN' block, so functions are exported at
compile-time and prototypes are properly honored.

That is, instead of writing this:

use_ok( 'Some::Module' );
use_ok( 'Other::Module' );

One should write this:

BEGIN { use_ok( 'Some::Module' ); }
BEGIN { use_ok( 'Other::Module' ); }

However, people often either forget to add 'BEGIN', or mistakenly group
'use_ok' with other tests in a single 'BEGIN' block, which can create
subtle differences in execution order.

With this module, simply change all 'use_ok' in test scripts to 'use ok',
and they will be executed at 'BEGIN' time. The explicit space after 'use'
makes it clear that this is a single compile-time action.

Text::CSV provides facilities for the composition and decomposition of
comma-separated values using the Text::CSV_XS manpage or its pure Perl
version.

An instance of the Text::CSV class can combine fields into a CSV string and
parse a CSV string into fields.

The module accepts either strings or files as input and can utilize any
user-specified characters as delimiters, separators, and escapes so it is
perhaps better called ASV (anything separated values) rather than just CSV.

This module provides bare bones 'try'/'catch'/'finally' statements that are
designed to minimize common mistakes with eval blocks, and NOTHING else.

This is unlike the TryCatch manpage which provides a nice syntax and avoids
adding another call stack layer, and supports calling 'return' from the try
block to return from the parent subroutine. These extra features come at a
cost of a few dependencies, namely the Devel::Declare manpage and the
Scope::Upper manpage which are occasionally problematic, and the additional
catch filtering uses the Moose manpage type constraints which may not be
desirable either.

The main focus of this module is to provide simple and reliable error
handling for those having a hard time installing the TryCatch manpage, but
who still want to write correct 'eval' blocks without 5 lines of
boilerplate each time.

This module converts strings from and to 2-byte Unicode UCS2 format. All
mappings happen via 2 byte UTF16 encodings, not via 1 byte UTF8 encoding.
To transform these use Unicode::String.

For historical reasons this module coexists with Unicode::Map8. Please use
Unicode::Map8 unless you need to care for two byte character sets, e.g.
chinese GB2312. Anyway, if you stick to the basic functionality (see
documentation) you can use both modules equivalently.

Practically this module will disappear from earth sooner or later as
Unicode mapping support needs somehow to get into perl's core. If you like
to work on this field please don't hesitate contacting Gisle Aas!

This module can't deal directly with utf8. Use Unicode::String to convert
utf8 to utf16 and vice versa.

Character mapping is according to the data of binary mapfiles in
Unicode::Map hierarchy. Binary mapfiles can also be created with this
module, enabling you to install own specific character sets. Refer to
mkmapfile or file REGISTRY in the Unicode::Map hierarchy.

This module implements a bare-bones class specifically for the purpose of
capturing data from the XML::Writer module. XML::Writer expects an IO::Handle
object and writes XML data to the specified object (or STDOUT) via it's print()
method. This module simulates such an object for the specific purpose of
providing the required print() method.

It is recommended that $writer->end() is called prior to calling $s->value() to
check for well-formedness.

Pygobjects is an extension module for python that gives you access to
GLib's GObjects.

A mod_python handler that uses instances of subclasses of class Servlet (thus
its name) to respond to HTTP GET and POST requests. For each request a series
of methods are called on the instance, the output of such being sent to the
client as the response. This handler was inspired by WebWare.

Pygobjects is an extension module for python that gives you access to
GLib's GObjects.

rungetty might be the getty you were looking for when you want to run any
program, not just login. If a different program than login is used it usually
is run as nobody:nogroup, or the user/group specified on the commandline.
rungetty can even be configured to autologin, under certain circumstances.
See the manual page for more information.

You have to change some lines in /etc/inittab for having any effect after
installing the package. rungetty is based on mingetty and therefore not
suitable for serial use.

Semantik (previously Kdissert) is a mindmapping-like tool to help students
to produce complicated documents very quickly and efficiently :
presentations, dissertations, thesis, reports.

While targetted mostly at students, Kdissert can also help teachers,
decision maker, engineers and businessmen.

This package contains the dictionary conversion tools which can convert
dictionaries of DICT, wquick, mova and pydict to stardict format.

Stellarium is a free software available for Windows, Linux/Unix and MacOSX. It renders 3D photo-realistic skies in real time. With stellarium, you really see what you can see with your eyes, binoculars or a small telescope.

Supybot is a robust, user and programmer friendly IRC bot written in
Python. It aims to be an adequate replacement for most existing IRC
bots. It includes a very flexible and powerful ACL system for
controlling access to commands, as well as more than 50 builtin plugins
providing around 400 actual commands.

Tux Paint" is a drawing program for young children. It has a simple
interface and fixed canvas size, and provides access to previous images
using a thumbnail browser (it provides no access to the underlying
filesystem).

Unlike popular drawing programs such as "The GIMP," it has a very
limited toolset. However, it provides a much simpler interface, and has
entertaining, child-oriented additions such as sound effects.

Authors:
--------
Bill Kendrick