This module implements some sane defaults for Perl programs, as defined
by two typical (or not so typical - use your common sense) specimens of
Perl coders. In fact, after working out details on which warnings and
strict modes to enable and make fatal, we found that we (and our code
written so far, and others) fully agree on every option, even though we
never used warnings before, so it seems this module indeed reflects a
"common" sense among some long-time Perl coders.

The basic philosophy behind the choices made in common::sense can be
summarised as: "enforcing strict policies to catch as many bugs as
possible, while at the same time, not limiting the expressive power
available to the programmer".

Two typical examples of how this philosophy is applied in practise is
the handling of uninitialised and malloc warnings:

*uninitialised*
"undef" is a well-defined feature of perl, and enabling warnings for
using it rarely catches any bugs, but considerably limits you in
what you can do, so uninitialised warnings are disabled.

*malloc*
Freeing something twice on the C level is a serious bug, usually
causing memory corruption. It often leads to side effects much later
in the program and there are no advantages to not reporting this, so
malloc warnings are fatal by default.

Unfortunately, there is no fine-grained warning control in perl, so
often whole groups of useful warnings had to be excluded because of a
single useless warning (for example, perl puts an arbitrary limit on the
length of text you can match with some regexes before emitting a
warning, making the whole "regexp" category useless).

What follows is a more thorough discussion of what this module does, and
why it does it, and what the advantages (and disadvantages) of this
approach are.

Config::IniFiles provides a way to have readable configuration files
outside your Perl script. Configurations can be imported (inherited,
stacked,...), sections can be grouped, and settings can be accessed from a
tied hash.

Convert::ASN1 encodes and decodes ASN.1 data structures using BER/DER
rules.

Convert::BER is a Perl object class implementation for encoding and
decoding objects as described by ITU-T standard X.209 (ASN.1) using
Basic Encoding Rules (BER).

WARNING this module is no longer supported, See Convert::ASN1

Perl module to read TNEF files

A Perl interface to the uulib library

Many online services that are centered around CPAN attempt to associate
multiple uploads by extracting a distribution name from the filename of the
upload. For most distributions this is easy as they have used
ExtUtils::MakeMaker or Module::Build to create the distribution, which
results in a uniform name. But sadly not all uploads are created in this
way.

'CPAN::DistnameInfo' uses heuristics that have been learnt by the
http://search.cpan.org/ manpage to extract the distribution name and
version from filenames and also report if the version is to be treated as a
developer release

The constructor takes a single pathname, returning an object with the
following methods

* cpanid

If the path given looked like a CPAN authors directory path, then this
will be the the CPAN id of the author.

* dist

The name of the distribution

* distvname

The file name with any suffix and leading directory names removed

* filename

If the path given looked like a CPAN authors directory path, then this
will be the path to the file relative to the detected CPAN author
directory. Otherwise it is the path that was passed in.

* maturity

The maturity of the distribution. This will be either 'released' or
'developer'

* extension

The extension of the distribution, often used to denote the archive type
(e.g. 'tar.gz')

* pathname

The pathname that was passed to the constructor when creating the object.

* properties

This will return a list of key-value pairs, suitable for assigning to a
hash, for the known properties.

* version

The extracted version

CPAN::Mini provides a simple mechanism to build and update a minimal mirror
of the CPAN on your local disk. It contains only those files needed to
install the newest version of every distribution. Those files are:

* *

01mailrc.txt.gz

* *

02packages.details.txt.gz

* *

03modlist.data.gz

* *

the last non-developer release of every dist for every author

Blowfish is capable of strong encryption and can use key sizes up to 56
bytes (a 448 bit key). You're encouraged to take advantage of the full key
size to ensure the strongest encryption possible from this module.

This module is a Perl-only implementation of the cryptographic cipher block
chaining mode (CBC). In combination with a block cipher such as DES or
IDEA, you can encrypt and decrypt messages of arbitrarily long length. The
encrypted messages are compatible with the encryption format used by the
*OpenSSL* package.

The module implements the Crypt::CBC interface, which has the following
methods

* blocksize
=item keysize
=item encrypt
=item decrypt

This module implements the Rijndael cipher, which has just been selected as
the Advanced Encryption Standard.

The Crypt::SaltedHash module provides an object oriented interface to
create salted (or seeded) hashes of clear text data. The original
formalization of this concept comes from RFC-3112 and is extended by the
use of different digital agorithms.

CSS::Tiny is a perl class to read and write .css stylesheets with as little
code as possible, reducing load time and memory overhead. CSS.pm requires
about 2.6 meg or ram to load, which is a large amount of overhead if you
only want to do trivial things. Memory usage is normally scoffed at in
Perl, but in my opinion should be at least kept in mind.

Curses is the interface between Perl and your system's curses(3) library.
For descriptions on the usage of a given function, variable, or constant,
consult your system's documentation, as such information invariably varies
(:-) between different curses(3) libraries and operating systems. This
document describes the interface itself, and assumes that you already know
how your system's curses(3) library works.

LONG DESCRIPTION
GOES
HERE

Hashes are great for storing named data, but if you want more than one
entry for a name, you have to use a list of pairs. Even then, this is
really boring to write:

$values = [
foo => undef,
bar => undef,
baz => undef,
xyz => { ... },
];

Just look at all those undefs! Don't worry, we can get rid of those:

$values = [
map { $_ => undef } qw(foo bar baz),
xyz => { ... },
];

Aaaauuugh! We've saved a little typing, but now it requires thought to
read, and thinking is even worse than typing.

With Data::OptList, you can do this instead:

$values = Data::OptList::mkopt([
qw(foo bar baz),
xyz => { ... },
]);

This works by assuming that any defined scalar is a name and any
reference following a name is its value.

Author: Ricardo SIGNES,

Data::Peek started off as 'DDumper' being a wrapper module over the
Data::Dumper manpage, but grew out to be a set of low-level data
introspection utilities that no other module provided yet, using the lowest
level of the perl internals API as possible.

Data::Section provides an easy way to access multiple named chunks of line-
oriented data in your module's DATA section. It was written to allow
modules to store their own templates, but probably has other uses.

ShowTable.pm is a Perl 5 module which defines subroutines to print
arrays of data in nicely formatted listings. It uses one of four
possible formats: simple table, boxed table, list style, and
HTML-formatting.