Free legal terms defined software for linux

Latemp project (a play on "Template") is a content management system based on Website Meta Language, a powerful framework for generating static HTML.
Latemp allows one to create attractive, themable sites, which are very usable, accessible and fully standards compliant. Latemp is open-source software, fully usable, modifiable and distributable under the terms of the MIT X11 license.
Main features:
- Generates Static HTML Files.
- Allows sites to have a common look and feel.
- Supports setting up navigation menus, breadcrumbs trails, navigation links ("Up", "Next" and "Previous"), site maps with sophisticated site flow.
- Makes use of Web Meta Language and so has all of its power (including extending its functionality by using embedded Perl).
- Themable. Three themes (perl-begin-1, better-scm, and sinorca-2.0) are supplied in the distribution. More can be written by the user. (and contributed).
- Open Source. Distributed under the MIT X11 License, which allows for free distribution, use, modification and re-licensing.
- Can generate valid XHTML 1.0 Transitional, XHTML 1.0 Strict or XHTML 1.1.
- Has pre-defined insertion points for including a breadcrumbs trail, a navigation menu, various HTML < head > elements, a logo, navigation links buttons, affiliation buttons, a license, a webmaster contact, a time stamp, and a foot image.
- Supports generating plain pages (without any additional content or layout aside from the body).
- Supported < head > elements: < title > tag, "author", "description" and "keywords" < meta > elements, Stylesheets (screen and print), favicon, Mozilla/Opera-style navigation links, and customizable user-defined text to be inserted there.
- Supports a unified management of news items with navigation menu entries, a news box, an RSS Feed, and news page entries.
Enhancements:
- This release adds support for preprocessing files using Template Toolkit (for CSS, etc.).
- It adds an experimental CSS Zen Garden-compatible theme and an image-based navigation links module.

Term::ReadLine::Gnu is a Perl extension for the GNU Readline/History Library.

SYNOPSIS

use Term::ReadLine;
$term = new Term::ReadLine ProgramName;
while ( defined ($_ = $term->readline(prompt>)) ) {
...
}

This is an implementation of Term::ReadLine using the GNU Readline/History Library.

For basic functions object oriented interface is provided. These are described in the section "Standard Methods" and "Term::ReadLine::Gnu Functions".

This package also has the interface with the almost all functions and variables which are documented in the GNU Readline/History Library Manual. They are documented in the section "Term::ReadLine::Gnu Functions" and "Term::ReadLine::Gnu Variables" briefly. For more detail of the GNU Readline/History Library, see GNU Readline Library Manual and GNU History Library Manual.

The sample programs under eg/ directory and test programs under t/ directory in the Term::ReadLine::Gnu distribution include many example of this module.

Mailfilter is a flexible utility for Unix (-like) operating systems to get rid of unwanted spam mails, before having to go through the trouble of downloading them into the local computer. Mailfilter offers support for one or many POP accounts and is especially useful for dialup connections via modem, ISDN, etc.
Mailfilter connects to any POP mail box and compares part of its content to a set of user defined filter rules. That way the spam gets deleted directly on the mail server.
With Mailfilter you can define your own filters (rules) to determine which e-mails should be delivered and which are considered waste. Rules are regular expressions, so you can make use of familiar options from other mail delivery programs such as e.g. procmail.
Mailfilter is released under the terms of the GNU General Public License. For more information, see the README and COPYING documents provided with the Mailfilter program.
Main features:
- Checks one or many POP accounts for spam and other unwanted e-mails, before you have to download the junk
- Very flexible configuration of filter rules to determine spam
- Very flexible configuration of friends lists to determine friendly e-mails
- Mailfilter does not interfere with your current e-mail environment as it is an independent application
- Works especially well as stand-alone application, as a cron job, or with programs like fetchmail
- Keeps log files of deleted message headers
- Available in different languages (English, French, German, Italian, Polish, Portuguese, Russian, Spanish)
- Its small, efficient and runs on many different platforms
- Its free and open
Enhancements:
- Code overhaul to introduce a more object oriented design
- Temporarily disabled gettext and the outdated translations
- (Hopefully) fixed bugs #238273 and #238273 in Debian bug database

Baseball::Sabermetrics is a baseball statistics module.

SYNOPSIS

Baseball::Sabermetrics provides an easy interface for calculating baseball statistics, given a data importer. In this package, Ive written CPBL.pm for (Chinese Professional Baseball League, http://www.cpbl.com.tw).

use Baseball::Sabermetrics;
use Baseball::Sabermetrics::CPBL;

my $league = Baseball::Sabermetrics->new(league => CPBL);

# Actually these are predefined.
# Those data with p_ or _allowed here are for seperating pitchers
# and batters.

$league->define(
rc => ab * obp,
babip => (h_allowed - hr_allowed) / (p_pa - h_allowed - p_so - p_bb - hr_allowed,
# what started with $ will be reserved.
# Players have team and league predefined, and team has league.
formula1 => hr / $_->team->hr;
formula2 => hr / $_->league->hr;
complex => sub {
print "You can write a sub directlyn";
$_->slg - $_->ba;
},
...
);

# Some formulas can be applied to players, teams, and league, depend on what
# columns are used in the formula. For example, ab and obp are defined for
# players, teams, and league, so that rc is available for all of them.

# top 5 obp of teams
$_->print qw/ team name ba obp slg isop / for $league->top(teams, 5, obp);

# top 10 obp of players
$_->print qw/ team name ba obp slg isop / for $league->top(players, 10, obp);

# show a players information
$league->players(Chien-Ming Wang)->print qw/ win lose ip so bb whip go_ao /;
$league->teams(Yankees)->players(Chien-Ming Wang)->print qw/ win lose ip so bb whip go_ao /;

# show team statistics data (accumulated from players)
$league->{Yankees}->print qw/ win lose ip so bb whip go_ao /;

# give a brief report for pitchers/batters of the team
$league->{Yankees}->report_pitchers qw/ name ip p_so p_bb whip go_ab /;
$league->{Yankees}->report_batters qw/ name ba obp slg isop /;

$league->report_teams qw/ name win lose era obp /;

# show all available formula
print join , $league->formula_list;

Data Structure

Baseball::Sabermetrics is aimed for providing a base class of your interested teams (a league, for example). Youll need to provide a data retriever to pull data out. The following example shows how you have to fill data into this structure.

$league = {
teams => {
Yankees => {
players => {
"Chien-Ming Wang" => {
bio => {
bats => right, # coule be left, switch
throws => right,
},
ip => 57.33333333333,
game => 9,
...
fielding => {
p => {
tc => 43,
pop => 4,
...
},
# b1 => { }, b2 => { }, b3 => { },
# first, second and thrid baseman should be
# b1, b2, and b3 respectively for convenient in
# fielding context. Because the initial of the
# name of subroutine cant be a number in perl.
},
};
...
}
},
Athletics => {
...
},
},
};

TERMS

Available terms of players (including teams and league, which are accumulated from players and could be treated as an abstract player) are:

# pitching
p_game win lose tie gs sv bs hld cg sho ip p_pa np h_allowed
hr_allowed sh_allowed sf_allowed p_bb p_ibb hb p_so wp bk ra er

# batting
pa ab rbi r h 1b 2b 3b hr tb dp sh sf ibb bb hbp so sb cs
tc po a e f_dp ppo tp pb c_cs c_sb

# fielding
pos fgame tc po a e f_dp tp pb c_cs c_sb

And there are additional terms for team:

game win lose tie

Term::GDBUI is a fully-featured shell-like command line environment.

SYNOPSIS

use Term::GDBUI;
my $term = new Term::GDBUI(commands => get_commands());
# (see below for the code to get_commands)
$term->run();

Term::GDBUI uses the history and autocompletion features of Term::ReadLine to present a sophisticated command-line interface to the user. It tries to make every feature you would expect to see in a fully interactive shell trivial to implement. You simply declare your command set and let GDBUI take care of the heavy lifting.

Bio::Ontology::GOterm is a representation of GO terms.

SYNOPSIS

$term = Bio::Ontology::GOterm->new
( -go_id => "GO:0016847",
-name => "1-aminocyclopropane-1-carboxylate synthase",
-definition => "Catalysis of ...",
-is_obsolete => 0,
-comment => "" );

$term->add_definition_references( @refs );
$term->add_secondary_GO_ids( @ids );
$term->add_aliases( @aliases );

foreach my $dr ( $term->each_definition_reference() ) {
print $dr, "n";
}

# etc.

This is "dumb" class for GO terms (it provides no functionality related to graphs). Implements Bio::Ontology::TermI.