Free 0.14 software for linux

VCS project is a Perl library for generic Version Control System access in Perl.

SYNOPSIS

use VCS;
$file = VCS::File->new($ARGV[0]);
print $file->url, ":n";
for $version ($file->versions) {
print $version->version,
was checked in by ,
$version->author,
"n";
}

VCS is an API for abstracting access to all version control systems from Perl code. This is achieved in a similar fashion to the DBI suite of modules. There are "container" classes, VCS::Dir, VCS::File, and VCS::Version, and "implementation" classes, such as VCS::Cvs::Dir, VCS::Cvs::File, and VCS::Cvs::Version, which are subclasses of their respective "container" classes.
The container classes are instantiated with URLs. There is a URL scheme for entities under version control. The format is as follows:

vcs://localhost/VCS::Cvs/fs/path/?query=1

The "query" part is ignored for now. The path must be an absolute path, meaningful to the given class. The class is an implementation class, such as VCS::Cvs.

The "container" classes work as follows: when the new method of a container class is called, it will parse the given URL, using the VCS->parse_url method. It will then call the new of the implementations appropriate container subclass, and return the result. For example,

VCS::Version->new(vcs://localhost/VCS::Cvs/fs/path/file/1.2);

will return a VCS::Cvs::Version.

An implementation class is recognised as follows: its name starts with VCS::, and require "VCS/Classname.pm" will load the appropriate implementation classes corresponding to the container classes.

VCS METHODS

VCS->parse_url

This returns a four-element list:

($hostname, $classname, $path, $query)

For example,

VCS->parse_url(vcs://localhost/VCS::Cvs/fs/path/file/1.2);

will return

(
localhost,
VCS::Cvs,
/fs/path/file/1.2,

)

This is mostly intended for use by the container classes, and its interface is subject to change.

VCS->class_load

This loads its given implementation class.

This is mostly intended for use by the container classes, and its interface is subject to change.

Want is a Perl module created to implement the `want command.

SYNOPSIS

use Want;
sub foo :lvalue {
if (want(qwLVALUE ASSIGN)) {
print "We have been assigned ", want(ASSIGN);
lnoreturn;
}
elsif (want(LIST)) {
rreturn (1, 2, 3);
}
elsif (want(BOOL)) {
rreturn 0;
}
elsif (want(qwSCALAR !REF)) {
rreturn 23;
}
elsif (want(HASH)) {
rreturn { foo => 17, bar => 23 };
}
return
}

This module generalises the mechanism of the wantarray function, allowing a function to determine in some detail how its return value is going to be immediately used.

...

EXAMPLES

use Carp croak;
use Want howmany;
sub numbers {
my $count = howmany();
croak("Cant make an infinite list") if !defined($count);
return (1..$count);
}
my ($one, $two, $three) = numbers();


use Want want;
sub pi () {
if (want(ARRAY)) {
return [3, 1, 4, 1, 5, 9];
}
elsif (want(LIST)) {
return (3, 1, 4, 1, 5, 9);
}
else {
return 3;
}
}
print pi->[2]; # prints 4
print ((pi)[3]); # prints 1


sub backstr :lvalue {
if (want(qwLVALUE ASSIGN)) {
my ($a) = want(ASSIGN);
$_[0] = reverse $a;
return undef;
}
elsif (want(RVALUE)) {
my $t = scalar reverse $_[0];
}
else {
carp("Not in ASSIGN context");
}
return
}

print "foo -> ", backstr("foo"), "n"; # foo -> oof
backstr(my $robin) = "nibor";
print "$robin is now $robinn"; # $robin is now robin

MQS (Minimalist Queue Services) is a minimalist queueing system in Free Software. The main purpose is to provide a set of basic methods in order to offer asynchronous messaging for program/application.
Applications can use this type of services in order to store and retrieve message to dedicated queue in the queue services. This permits to prevent direct connection between applications and provides a simple asynchronous communication system.
The MQS Daemon provides a simple set of XML-RPC methods for pushing and getting messages in a specific queue (so you can use the system with any application that can talk XML-RPC). The storing of the queue is in a database (e.g. MySQL, Postgresql...) or in dedicated file(s) (e.g. QDBM). QDBM is the preferred storage.
Enhancements:
- RELEASE 0.0.14
- Fixd the typo error in the Empty queue error
- Updated the required package in the documentation
- Changed the perl interpreter call to /bin/env perl

BNR is a news reader software specifically tailored for binary articles. BNR downloads and decodes binary articles and saves them on your hard drive to the directory of your choice.BNR can download and decode only binary articles and can save them to the hard drive.. BNR can also download text articles, but other news readers are probably better suited to this task. BNR will run on PC hardware running either Windows or Linux operating systems.
Main features:
- support for multiple news servers simultaneously
- checking for file existence before you start downloading an article
- plugin support
- article download optimization
- header download optimization
- connect-on-demand
- internal JPEG viewer
- newsgroup-specific settings
- customizable interface
Version restrictions:
- does not support reply threads
- does not (at least for now) support article posting

Cire is a Free and Open-Source Program for keeping an Electronic Journal or Diary.
It is designed to run on Linux and other Unixes.
Main features:
- Keep a Personal Diary
- Keep a Log of Progress on a Programming Project
- Encrypt Messages to Friends (Put the Message in a Diary File, encrypt it, send friend the diary file, have them decrypt it.)
Cire is open-source, under the GPL currently, so can be changed in any way permitted by the GPL.
Use:
Start Cire with the UI of your choice. Use Cire. Its that simple!
You can use:
cire -g < diary filename > to Start GTK Interface,
cire -n < diary filename > to Start Ncurses Interface,
cire -t < diary filename > to Start Text Interface
Enhancements:
- Makefile.am: Andrew put a list of all source files in /Makefile.am as well as /src/Makefile.am. Ive fixed this.

Hdup 2.0 is an evolution from hdup 1.6. Hdup 2.0 is more solid and has even more features, it supports a nobackup keyword, if a special file is found in a directory - that directory is not backed up. Also the include/exclude mechanism is more powerfull and more robust.
Hdup should run and compile on all Unixes out there. hdup does depend on Gnu tar for the backups. It also needs glib-dev if you compile it yourself. Also for building it you need Gnu Make.
Hdup 2.0 offers a much better include/exclude mechanism and can see nobackup keywords in directories. But because of some limitation in the current stable version of Gnu tar this means that not all directory information is included in the archive. You need a Gnu tar version > 1.3.25, pref. one of the newer stable releases (1.15.x or greater).
I currently have a SOLUTION for this. This involves patching tar and running hdup with the -P (patched_tar) option. This patch makes tar and hdup include the directory information in the archives once again.
Main features:
- simple to use,
- small and versatile backup program,
- support for incremental backups,
- support for backups over the network (with ssh),
- support for network restore (with ssh),
- support for encrypted backups (using mcrypt, gnupg),
- support for split up archives (called chunks),
- support for .nobackup files (to exclude certain directories),
- flexible regular expression based include/exclude mechanism,
- designed to be run from cron.
Enhancements:
- Files specified with the "dir" keyword are now also seperated with NULLs in the filelist.

AcidRip is a Gtk2::Perl application for ripping and encoding DVDs. It neatly wraps MPlayer and MEncoder, which I think is pretty handy, seeing as MPlayer is by far the best bit of video playing kit around for Linux.
As well as creating a simple Graphical Interface for those scared of getting down and dirty with MEncoders command line interface, It also automates the process in a number of ways:
- Parses DVD into contents tree
- Finds longest title
- Calculate video bitrate for given filesize
- Finds black bands and crops them
- Gives suggestions for improved performance
- Other stuff!
Acidrip is *NOT* an encoding program. It does not do a single bit of encoding by itself. It can not do anything complicated that MEncoder can not do, e.g. output to VCD format etc... Feature requests are always welcome but please be very sure that is within the "jurisdiction" of my program.