Spreadsheet::Read tries to transparently read *any* spreadsheet and return
its content in a universal manner independent of the parsing module that
does the actual spreadsheet scanning.

For OpenOffice this module uses Spreadsheet::ReadSXC

For Microsoft Excel this module uses Spreadsheet::ParseExcel or
Spreadsheet::XLSX

For CSV this module uses Text::CSV_XS (0.29 or up required, 0.73 or up
preferred) or Text::CSV_PP (1.05 or up required).

For SquirrelCalc there is a very simplistic built-in parser

Spreadsheet::ReadSXC extracts data from OpenOffice 1.x spreadsheet files
(.sxc). It exports the function read_sxc() which takes a filename and an
optional reference to a hash of options as arguments and returns a
reference to a hash of references to two-dimensional arrays. The hash keys
correspond to the names of worksheets in the OpenOffice workbook. The
two-dimensional arrays correspond to rows and cells in the respective
spreadsheets. If you don't like this because the order of sheets is not
preserved in a hash, read on. The 'OrderBySheet' option provides an array
of hashes instead.

If you prefer to unpack the .sxc file yourself, you can use the function
read_xml_file() instead and pass the path to content.xml as an argument. Or
you can extract the XML string from content.xml and pass the string to the
function read_xml_string(). Both functions also take a reference to a hash
of options as an optional second argument.

This module is a (quick and dirty) emulation of Spreadsheet::ParseExcel for
Excel 2007 (.xlsx) file format. It supports styles and many of Excel's
quirks, but not all. It populates the classes from Spreadsheet::ParseExcel
for interoperability; including Workbook, Worksheet, and Cell.

Determine if words are reserved by ANSI/ISO SQL standard.

This documentation covers the API for SQL::Translator. For a more general
discussion of how to use the modules and scripts, please see
SQL::Translator::Manual.

This module provides basic functions used in descriptive statistics. It has
an object oriented design and supports two different types of data storage
and calculation objects: sparse and full. With the sparse method, none of
the data is stored and only a few statistical measures are available. Using
the full method, the entire data set is retained and additional functions
are available.

rewrite strings based on a set of known prefixes

Sub::Exporter provides a sophisticated alternative to Exporter.pm. It allows
for renaming, currying/sub-generation, and other cool stuff. Read its own
documentation.

The biggest benefit of Sub::Exporter over existing exporters
(including the ubiquitous Exporter.pm) is its ability to build new coderefs
for export, rather than to simply export code identical to that found
in the exporting package.

Author: Ricardo Signes,

Sub::Identify allows you to retrieve the real name of code references.
For this, it uses perl's introspection mechanism, provided by the
B module.

This module makes it easy to install subroutines into packages without the
unslightly mess of no strict or typeglobs lying about where just anyone
can see them.

Author: Ricardo Signes,

This module has only one function, which is also exported by default:

subname NAME, CODEREF

Assigns a new name to referenced sub. If package specification is omitted in
the name, then the current package is used. The return value is the sub.

The name is only used for informative routines (caller, Carp, etc). You won't
be able to actually invoke the sub by the given name. To allow that, you need
to do glob-assignment yourself.

Note that for anonymous closures (subs that reference lexicals declared outside
the sub itself) you can name each instance of the closure differently, which
can be very useful for debugging.

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.

When subclassing a class, you occasionally want to dispatch control to the
superclass -- at least conditionally and temporarily. The Perl syntax for
calling your superclass is ugly and unwieldy:

SVG is a 100% Perl module which generates a nested data structure
containing the DOM representation of an SVG (Scalable Vector Graphics)
image. Using SVG, you can generate SVG objects, embed other SVG instances
into it, access the DOM object, create and access javascript, and generate
SMIL animation content.

The Switch.pm module implements a generalized case mechanism that covers
most (but not all) of the numerous possible combinations of switch and case
values described above.

The module augments the standard Perl syntax with two new control
statements: 'switch' and 'case'. The 'switch' statement takes a single
scalar argument of any type, specified in parentheses. 'switch' stores this
value as the current switch value in a (localized) control variable. The
value is followed by a block which may contain one or more Perl statements
(including the 'case' statement described below). The block is
unconditionally executed once the switch value has been cached.

Symbol::Table allows the user to manipulate Perl's symbol table

The Template Toolkit is a collection of modules which implement a
fast, flexible, powerful, and extensible template processing system.
It was originally designed and remains primarily useful for generating
dynamic web content, but it can be used equally well for processing
any other kind of text based documents: HTML, XML, POD, PostScript,
LaTeX, and so on.

It can be used as a stand-alone Perl module or embedded within an
Apache/mod_perl server for generating highly configurable dynamic web
content. A number of Perl scripts are also provided which can greatly
simplify the process of creating and managing static web content and
other offline document systems.

This module, ReadKey, provides ioctl control for terminals and Win32 consoles
so the input modes can be changed (thus allowing reads of a single character at
a time), and also provides non-blocking reads of stdin, as well as several
other terminal related features, including retrieval/modification of the screen
size, and retrieval/modification of the control characters.

This module lets you ask the user for a password in the traditional
way, from the keyboard, without echoing.

This is not intended for use over the web; user authentication over the
web is another matter entirely. Also, this module should generally be
used in conjunction with Perl's crypt() function, sold separately.

If you don't know anything about automated testing in Perl then you should
probably read about Test::Simple and Test::More before preceding.
Test::Deep uses the Test::Builder framework.
Test::Deep gives you very flexible ways to check that the result you got
is the result you were expecting. At it's simplest it compares two
structures by going through each level, ensuring that the values match,
that arrays and hashes have the same elements and that references are
blessed into the correct class. It also handles circular data structures
without getting caught in an infinite loop.

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.

This is another framework for writing test scripts. It is loosely inspired
by Test::More, and has most of it's functionality, but it is not a drop-in
replacement.

Test::Output provides a simple interface for testing output sent to STDOUT
or STDERR. A number of different utilities are included to try and be as
flexible as possible to the tester.

Originally this module was designed not to have external requirements,
however, the features provided by the Sub::Exporter manpage over what the
Exporter manpage provides is just to great to pass up.

Test::Output ties STDOUT and STDERR using Test::Output::Tie.