Config::Crontab reads and writes (and pretty-prints) your crontab(5)
files. It is compatible with Vixie-style crontabs (and all subsets,
including Solaris' SysV-style crontabs).

Config::Crontab has a simple, object-oriented syntax. Crontab files are
broken into "blocks" (paragraphs, each separated by two or more
newlines); the Block is the basic unit of a Config::Crontab object.

You can re-order entire blocks within a crontab file, re-order lines
within blocks (there are three types of lines: comments, environment
settings, and crontab commands or events), remove blocks or lines
within blocks, add new blocks or lines within blocks, etc. See the
Config::Crontab manpage for full details.

This module opens a config file and parses its contents for you. The new
method requires one parameter which needs to be a filename. The method
getall returns a hash which contains all options and its associated values
of your config file.

The format of config files supported by Config::General is inspired by the
well known apache config format, in fact, this module is 100%
read-compatible to apache configs, but you can also just use simple
name/value pairs in your config files.

In addition to the capabilities of a apache config file it supports some
enhancements such as here-documents, C-style comments or multiline options.
It is also possible to save the config back to disk, which makes the module
a perfect backend for configuration interfaces.

It is possible to use variables in config files and there exists also
support for object oriented access to the configuration.

The DBD::CSV module is yet another driver for the DBI (Database independent
interface for Perl). This one is based on the SQL "engine" SQL::Statement
and the abstract DBI driver DBD::File and implements access to so-called
CSV files (Comma Separated Values). Such files are often used for exporting
MS Access and MS Excel data.

IO::Pager is lightweight and can be used to locate an available pager
and set $ENV{PAGER} (see "NOTES") or as a factory for creating objects
defined elsewhere such as IO::Pager::Buffered and
IO::Pager::Unbuffered.

List::MoreUtils provides some trivial but commonly needed functionality
on lists which is not going to go into List::Util.

`Path::Class' is a module for manipulation of file and directory
specifications (strings describing their locations, like
`'/home/ken/foo.txt'' or `'C:\Windows\Foo.txt'') in a cross-platform
manner. It supports pretty much every platform Perl runs on, including
Unix, Windows, Mac, VMS, Epoc, Cygwin, OS/2, and NetWare.

The well-known module `File::Spec' also provides this service, but it's
sort of awkward to use well, so people sometimes avoid it, or use it in
a way that won't actually work properly on platforms significantly
different than the ones they've tested their code on.

In fact, `Path::Class' uses `File::Spec' internally, wrapping all the
unsightly details so you can concentrate on your application code.
Whereas `File::Spec' provides functions for some common path
manipulations, `Path::Class' provides an object-oriented model of the
world of path specifications and their underlying semantics.
`File::Spec' doesn't create any objects, and its classes represent the
different ways in which paths must be manipulated on various platforms
(not a very intuitive concept). `Path::Class' creates objects
representing files and directories, and provides methods that relate
them to each other.

The SQL::Statement module implements a pure Perl SQL parsing and execution
engine. While it by no means implements full ANSI standard, it does support
many features including column and table aliases, built-in and user-defined
functions, implicit and explicit joins, complex nested search conditions,
and other features.

DelimMatch is a Perl 5 module that provides functions for locating
delimited substrings with proper nesting.

UNIVERSAL::require - require() modules from a variable

This module provides a Perl interface to the libsyck data serialization
library. It exports the Dump and Load functions for converting Perl data
structures to YAML strings, and the other way around.
NOTE: If you are working with other language's YAML/Syck bindings (such as
Ruby), please set $YAML::Syck::ImplicitTyping to 1 before calling the
Load/Dump functions. The default setting is for preserving
backward-compatibility with YAML.pm.

PVM is a software system that enables a collection of heterogeneous
computers to be used as a coherent and flexible concurrent
computational resource.

The individual computers may be shared- or local-memory
multiprocessors, vector supercomputers, specialized graphics engines,
or scalar workstations, that may be interconnected by a variety of
networks, such as ethernet, FDDI. User programs written in C, C++ or
Fortran access PVM through library routines.

After installation you find in /usr/share/doc/packages/pvm/ the
documentation as PostScript file pvm-book.ps. Furthermore some
examples are packed together in two tar archives. Those archives
should be extracted into your HOME directory which leads to
~/pvm3/examples/ or ~/pvm3/gexamples/ in your HOME directory. The call
`aimk all' (see manual page aimk(1)) e.g. in ~/pvm3/examples/ compiles
the examples for the PVM system.

The PVM web home page is at http://www.epm.ornl.gov/pvm/pvm_home.html .

The SCGI protocol is a replacement for the Common Gateway Interface
(CGI) protocol. It is a standard for applications to interface with
HTTP servers. It is similar to FastCGI but is designed to be easier to
implement.

This package contains the python bindings.

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

* Ruby features:

- Simple Syntax

- *Normal* Object-Oriented features (class, method calls, for
example)

- *Advanced* Object-Oriented features(Mix-in, Singleton-method, for
example)

- Operator Overloading

- Exception Handling

- Iterators and Closures

- Garbage Collection

- Dynamic Loading of Object Files (on some architectures)

- Highly Portable (works on many UNIX machines; DOS, Windows, Mac,
BeOS, and more)

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.

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.

Racc (Ruby yACC) is a LALR(1) parser generator for Ruby. Version 1.4.x
is stable release.·

Parsers generated by Racc requires "Racc Runtime Module". Ruby 1.8.x
comes with this runtime.

'abstract.rb' is a library which enable you to define abstract method
in Ruby.

Simplifies the creation of mail service classes that uses Action View
(from Action Pack) to render the body templates.

Simplifies the creation of mail service classes that uses Action View
(from Action Pack) to render the body templates.

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.

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.

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.

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