Free summarizes software for linux

Mail::Summary is a Perl module that can scan read your mail!

SYNOPSIS

my $ms = Mail::Summary->new({ maildir => /home/mwk/Maildir });

my @mail_summaries = $ms->summaries;

Too busy to read your mail? Subscribe to too many mailing lists? Take two folders into the shower? Well, for the busy on the go geek of today, here is the answer! Get all your messages summarised, to save you having to read them, or to read them by which summary looks better!

new

my $ms = Mail::Summary->new({ maildir => /home/mwk/Maildir });

This will make a new Mail::Summary object.

maildir

my $maildir = $ms->maildir;

This is the mail directory as defined by the user.

summaries

my @mail_summaries = $ms->summaries;

This will return a list, with every entry in the list being a summary of an individual message.

URI is Uniform Resource Identifiers (absolute and relative). This module implements the URI class. Objects of this class represent "Uniform Resource Identifier references" as specified in RFC 2396 (and updated by RFC 2732).

A Uniform Resource Identifier is a compact string of characters that identifies an abstract or physical resource. A Uniform Resource Identifier can be further classified as either a Uniform Resource Locator (URL) or a Uniform Resource Name (URN). The distinction between URL and URN does not matter to the URI class interface. A "URI-reference" is a URI that may have additional information attached in the form of a fragment identifier.

An absolute URI reference consists of three parts: a scheme, a scheme-specific part and a fragment identifier. A subset of URI references share a common syntax for hierarchical namespaces. For these, the scheme-specific part is further broken down into authority, path and query components. These URIs can also take the form of relative URI references, where the scheme (and usually also the authority) component is missing, but implied by the context of the URI reference. The three forms of URI reference syntax are summarized as follows:

< scheme >:< scheme-specific-part >#< fragment >
< scheme >://< authority >< path >?< query >#< fragment >
< path >?< query >#< fragment >

The components into which a URI reference can be divided depend on the scheme. The URI class provides methods to get and set the individual components. The methods available for a specific URI object depend on the scheme.

Scriptalicious Perl module can make scripts more delicious to SysAdmins.

SYNOPSIS

use Scriptalicious
-progname => "pu";

our $VERSION = "1.00";

my $url = ".";
getopt getconf("u|url" => $url);

run("echo", "doing something with $url");
my $output = capture("svn", "info", $url);

__END__

=head1 NAME

pu - an uncarved block of wood

=head1 SYNOPSIS

pu [options] arguments

=head1 DESCRIPTION

This scripts function is to be a blank example that many
great and simple scripts may be built upon.

Remember, you cannot carve rotten wood.

=head1 COMMAND LINE OPTIONS

=over

=item B< -h, --help >

Display a program usage screen and exit.

=item B< -V, --version >

Display program version and exit.

=item B< -v, --verbose >

Verbose command execution, displaying things like the
commands run, their output, etc.

=item B< -q, --quiet >

Suppress all normal program output; only display errors and
warnings.

=item B< -d, --debug >

Display output to help someone debug this script, not the
process going on.

=back

This module helps you write scripts that conform to best common practices, quickly. Just include the above as a template, and your script will accept all of the options that are included in the manual page, as well as summarising them when you use the -h option.

(Unfortunately, it is not possible to have a `use dependency automatically add structure to your POD yet, so you have to include the above manually. If you want your help message and Perldoc to be meaningful, that is.)

Shortcuts are provided to help you abort or die with various error conditions; all of which print the name of the program running (taken from $0 if not passed). The motive for this is that "small" scripts tend to just get written and forgotten; so, when you have a larger system that is built out of lots of these pieces it is sometimes guesswork figuring out which script a printed message comes from!

For instance, if your program is called with invalid arguments, you may simply call abort with a one-line message saying what the particular problem was. When the script is run, it will invite the person running the script to try to use the --help option, which gives them a summary and in turn invites them to read the Perldoc. So, it reads well in the source;

@ARGV and abort "unexpected arguments: @ARGV";
$file or abort "no filename supplied";

And in the output;

somescript: no filename supplied!
Try `somescript --help for a summary of options

On the other hand, if you call barf, then it is considered to be a hard run-time failure, and the invitation to read the --help page to get usage not given. Also, the messages are much tidier than you get with die et al.

open FOO, "<<less