Free tag 1.05 software for linux

TxSig project is a small signature rotator.
It can randomly pick from a directory of files containing fortunes or quotes. It offers a variety of features such as compatibility with files from fortune. Users can generate their own quote files.
Main features:
- Quotes chosen based on length
- Quotes chosen based on rating
- Multiple configuration files
- Multiple quote/fortune files
- 100% Compatability with standard fortune files
- Drop-in compatability with pine V 4.44
- Optional apending of .signature (or any other file)
- Uses only standard perl modules
- Tastes Good
- Possibly Sexy
Enhancements:
- fixed a problem with creating and updating the data.cnt file

Peng project consists of an AOL Linux dialer.

Peng is a free program for Linux that sets up a PPP, cable, or DSL connection for AOL or other providers by using a reverse engineered version of the AOL protocol.

It can be used from the command line and is known to work in several countries.

NetCARD Config project helps linux users to configure network cards for two ip one for DSL network one for Local Network.

Pod::TOC is a Perl module to extract a table of contents from a Pod file.

SYNOPSIS

This is a Pod::Simple subclass, so it can do the same things.
use Pod::TOC;

my $parser = Pod::TOC->new;

my $toc;
open my($output_fh), ">", $toc;

$parser->output_fh( $output_fh );

$parser->parse_file( $input_file );

This is a Pod::Simple subclass to extract a table of contents from a pod file. It has the same interface as Pod::Simple, and only changes the internal bits.

Data::Walker is a tool for navigating through Perl data structures.

SYNOPSIS

Without any explicit objects:

use Data::Walker;
Data::Walker->cli( $data_structure );

Object-style invocation:

use Data::Walker;
my $w = new Data::Walker;
$w->walk( $data_structure );
$w->ls("-al");
$w->pwd;
$w->cli;

Importing methods into the current package:

use Data::Walker qw(:direct);
walk $data_structure;
ls "-al";
pwd;
cli;

This module allows you to "walk" an arbitrary Perl data structure in the same way that you can walk a directory tree from a UNIX command line. It reuses familiar unix commands (such as "ls", "cd", "pwd") and applies these to data structures.

It has a command-line interface which behaves like a UNIX shell. You can also use object-style sytax to invoke the CLI commands from outside the CLI. Data::Walker objects are encapsulated, so that you can hop into and out of a CLI without losing state, and you can have several Data::Walker objects pointing at different structures.

The main functions can also be imported and used directly from within the Perl debuggers CLI.

GTag is a music tag editor for gtk+ 2.4.

GTag is a music tag editor for gtk+ 2.4. It supports ogg, mp3 and flac audio files. It uses the taglib library and also requires libglade.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.