Free from simple software for linux

JOpt Simple is a simple, test-driven command line parser for Java programs. JOpt Simple supports POSIX getopt() and GNU getopt_long().
What command line switch syntax does JOpt Simple support?
As closely as possible, JOpt Simple attempts to adhere to the rules of POSIX getopt() and GNU getopt_long(). You can find a brief summary of these rules in the javadoc for class OptionParser.
Enhancements:
- Minor internal changes.

HTML::Simple is a simple, dependency free module for generating HTML (and XML).

SYNOPSIS

Note: It turns out that TOMC owns the HTML::Simple namespace so Ive moved development of this module to HTML::Tiny. Please use HTML::Tiny in preference to this module.

use HTML::Simple;

my $h = HTML::Simple->new;

# Generate a simple page
print $h->html(
[
$h->head( $h->title( Sample page ) ),
$h->body(
[
$h->h1( { class => main }, Sample page ),
$h->p( Hello, World, { class => detail }, Second para )
]
)
]
);

# Outputs
< html>
< head>
< title>Sample page< /title>
< /head>
< body>
< h1 class="main">Sample page< /h1>
< p>Hello, World< /p>
< p class="detail">Second para< /p>
< /body>
< /html>

Blog::Simple is a Perl extension for the creation of a simple weblog (blogger) system.

SYNOPSIS

use Blog::Simple;

my $sbO = Blog::Simple->new(); $sbO->create_index(); #generally only needs to be called once

my $content="

blah blah blah in XHTM"p"

Better when done in XHTM"p""; my $title = some title; my $author = a.n. author; my $email = anaouthor@somedomain.net; my $smmry = blah blah; $sbO->add($title,$author,$email,$smmry,$content);

$sbO->render_current(blog_test.xsl,3); $sbO->render_all(blog_test.xsl);

$sbO->remove(08);

Repository::Simple is a simple hierarchical repository for Perl.

SYNOPSIS

use Repository::Simple;

my $repository = Repository::Simple->attach(
FileSystem => root => /home/foo
);

NOTICE: This software is still in development and the interface WILL CHANGE.
This is the main module of a hierarchical repository system, which is loosely based upon the File::System module Ive written combined with ideas from the JSR 170, a.k.a. Content Repository API for the Java API Specification.

The goal of this package is to provide a content repository system with a similar feature set. I think it would be a good goal to aim for loose compatibility, but it is not my intent to adhere to the strict letter of that standard.

Getopt::Simple is a Perl module that provides a simple wrapper around Getopt::Long.

SYNOPSIS

use Getopt::Simple;

# Or ...
# use Getopt::Simple qw($switch);

my($options) =
{
help =>
{
type => ,
env => -,
default => ,
# verbose => , # Not needed on every key.
order => 1,
},
username =>
{
type => =s, # As per Getopt::Long.
env => $USER, # Help text.
default => $ENV{USER} || RonSavage, # In case $USER is undef.
verbose => Specify the username on the remote machine,
order => 3, # Help text sort order.
},
password =>
{
type => =s,
env => -,
default => password,
verbose => Specify the password on the remote machine,
order => 4,
},
};

my($option) = Getopt::Simple -> new();

if (! $option -> getOptions($options, "Usage: testSimple.pl [options]") )
{
exit(-1); # Failure.
}

print "username: $$option{switch}{username}. n";
print "password: $$option{switch}{password}. n";

# Or, after use Getopt::Simple qw($switch); ...
# print "username: $$switch{username}. n";
# print "password: $$switch{password}. n";

Getopt::Simple is a pure Perl module.

The Getopt::Simple module provides a simple way of specifying:

Command line switches

Type information for switch values

Default values for the switches

Help text per switch

IPC::Run::Simple is a simple system() wrapper.

SYNOPSIS

# Run a command and check whether it failed
use IPC::Run::Simple;
run("echo Hello, O Cruel World")
or die "Command failed";

# Describe the failure
use IPC::Run::Simple qw($ERR);
run("echo Hello, O Cruel World")
or die "Command failed: $ERR";

# Use the :all tag instead of explicitly requesting $ERR
use IPC::Run::Simple qw(:all);
run("echo Hello, O Cruel World")
or die "Command failed: $ERR";

# Die with error message if command does not return 0
use IPC::Run::Simple qw(:Fatal);
run("echo Hello, O Cruel World");

# Allow other exit values without dying
use IPC::Run::Simple qw(:Fatal);
run(command => [ "echo", "Hello, O Cruel World!" ],
allowed => [ 1, 2, 5 ]);

This module is intended to be a very simple, straightforward wrapper around the system() call to make it behave more like other builtins.

run() will return a true value if the command was executed and return a successful status code, and false otherwise. The reason for the failure will be stored in the $IPC::Run::Simple::ERR variable (which is just $ERR if you import either $ERR or :all). The description of the reason was pulled almost directly from the system() documentation.
Optionally, you can import the :Fatal tag, which will cause run() to die() with an appropriate message if the command fails for any reason.

If you wish to allow nonzero exit values but still want to trap unexpected errors, you may use an expanded call syntax. Call run() with a set of key=>value pairs. The two implemented keys are command (an array reference containing the command to run) and allowed (an array reference of exit values that are allowed without causing run() to return false or throw an exception.)

Simple Log is a small library that does logging very simply and requires you to do almost nothing (other than actually logging) to get log output to happen. Simple Log is much simpler to use than a logging framework, especially in terms of configuration.
It doesnt attempt to solve every logging problem in one package, but contains enough features to be a viable alternative for most applications that need logging. This tool will handle the logging needs of most small- to large-sized projects, but with an almost non-existent learning curve.
Enhancements:
- This release is primarily about the addition of log rolling (by time of day, file size, or custom strategy), the inclusion of a small but humorous user guide, the fixing of a raft of minor bugs, and the inclusion of a few other small features increasing flexibility.