Free foo software for linux

Video::Info::FOO is a Perl module for video information.

Video::Info::FOO - what is it useful for? an example list:

-video codec
-audio codec
-frame height
-frame width
-frame count
and more!

SYNOPSIS

use Video::Info::FOO;

my $video;

$video->vcodec; #video codec
$video->acodec; #audio codec
...

What does the module do? What are its limitations? Is it built on top of other code? If so, what are the details and where can I get it?

rconftool is a reimplementation of Sam Varshavchiks sysconftool in Ruby. Its purpose is to keep configuration files "fresh" when upgrading an application from one version to another, ensuring that all necessary settings are present and obsolete ones removed.

To use it, application writers need to distribute their config files marked up with some simple metadata in comments, and arrange for the make install or make install-configure target to invoke rconftool.

rconftool can be called as a library function or from the command line. It can also install groups of files recursively from one directory tree into another.

rconftool is distributed under the MIT licence.

Installation

You can just use rconftool.rb from the current directory, or copy it anywhere into Rubys library search path. The following command will do this for you:

# ruby install.rb

Usage

(1) As a command-line tool

# ./rconftool.rb foo.dist

Installs foo.dist to foo (option --strip-suffix .dist is the default)

# ./rconftool.rb --strip-suffix .orig --add-suffix .txt *.orig

Installs files foo.orig and bar.orig as foo.txt and bar.txt

# ./rconftool.rb --recursive --targetdir /etc/foo .

Installs all files in the current directory and its subdirectories into /etc/foo recursively. (Suffix .dist is still stripped off by default, unless you specify --strip-suffix ""). /etc/foo itself must exist, but subdirectories are created if necessary.

(2) As a library

require rconftool

# install single files
Rconftool::install(foo.dist, foo)
Rconftool::install(foo.dist, nil, nil, :strip_regexp=>/.dist$/)
Rconftool::install(foo.orig, foo.txt)
Rconftool::install(bar.orig, nil, nil, :strip_regexp=>/.orig$/,
:add_suffix=>.txt)

# using the command-line interface
argv = [--recursive,--targetdir,/etc/foo,.]
rct = Rconftool::Processor.new(argv)
rct.run(argv)

Config::Sofu is a simple Sofu configuration file parser.

SYNOPSIS

use vars qw/%CONFIG/;
use Config::Sofu "config.sofu";
if ($CONFIG{FOOBAR}) {
...
}
if ($CONFIG{Bar}->[7]->{Foo} eq "Foobar") {
...
}
Save the new configuration:
$CONFIG{FOOBAR}="Bar times Foo";
Config::Sofu::save;
or
Config::Sofu::save(%CompletlyNewConfig)

SYNTAX

This class exports the hash %CONFIG by default which contains all the information of the file which is given to the use statement.

Rose::Object is a simple object base class.

SYNOPSIS

package MyObject;

use Rose::Object;
our @ISA = qw(Rose::Object);

sub foo { ... }
sub bar { ... }
...

my $o = MyObject->new(foo => abc, bar => 5);
...

Rose::Object is a generic object base class. It provides very little functionality, but a healthy dose of convention.

METHODS

new PARAMS

Constructs a new, empty, hash-based object based on PARAMS, where PARAMS are name/value pairs, and then calls init (see below), passing PARAMS to it unmodified.

init PARAMS

Given a list of name/value pairs in PARAMS, calls the object method of each name, passing the corresponding value as an argument. The methods are called in the order that they appear in PARAMS. For example:

$o->init(foo => 1, bar => 2);

is equivalent to the sequence:

$o->foo(1);
$o->bar(2);

WWW::Google::Video is a fetch the Google Video Information.

SYNOPSIS

use WWW::Google::Video;

$foo=new WWW::Google::Video;

$foo->fetch(http://video.google.com/videoplay?docid=1808273720725631796);
# The Google Video Page URL, such as http://video.google.com/videoplay?docid=blahblahblah

print $foo->{url},"n"; # Google Video FLV Original File URL !!
print $foo->{length},"n"; # Video Length Information
print $foo->{name},"n"; # Video Name Information

foreach(@{ $foo->{pic} }){ # By using Reference to an Array
print $_,"n"; # To show the preview pictures.
}

The WWW::Google::Video is a class implementing a interface for fetch the Google Video Information.

To use it, you should create WWW::Google::Video object and use its method fetch(), to fetch the information of Video.

It uses LWP::Simple for making request to Google.

Clone is a Perl module that can recursively copy Perl datatypes.

SYNOPSIS

use Clone;

push @Foo::ISA, Clone;

$a = new Foo;
$b = $a->clone();

# or

use Clone qw(clone);

$a = { foo => bar, move => zig };
$b = [ alpha, beta, gamma, vlissides ];
$c = new Foo();

$d = clone($a);
$e = clone($b);
$f = clone($c);

This module provides a clone() method which makes recursive copies of nested hash, array, scalar and reference types, including tied variables and objects.

clone() takes a scalar argument and an optional parameter that can be used to limit the depth of the copy. To duplicate lists, arrays or hashes, pass them in by reference. e.g.

my $copy = clone (@array);

# or

my %copy = %{ clone (%hash) };

For a slower, but more flexible solution see Storables dclone().

Symbol is a Perl module created to manipulate Perl symbols and their names.

SYNOPSIS

use Symbol;

$sym = gensym;
open($sym, "filename");
$_ = ;
# etc.

ungensym $sym; # no effect

# replace *FOO{IO} handle but not $FOO, %FOO, etc.
*FOO = geniosym;

print qualify("x"), "n"; # "Test::x"
print qualify("x", "FOO"), "n" # "FOO::x"
print qualify("BAR::x"), "n"; # "BAR::x"
print qualify("BAR::x", "FOO"), "n"; # "BAR::x"
print qualify("STDOUT", "FOO"), "n"; # "main::STDOUT" (global)
print qualify(*x), "n"; # returns *x
print qualify(*x, "FOO"), "n"; # returns *x

use strict refs;
print { qualify_to_ref $fh } "foo!n";
$ref = qualify_to_ref $name, $pkg;

use Symbol qw(delete_package);
delete_package(Foo::Bar);
print "deletedn" unless exists $Foo::{Bar::};

Symbol::gensym creates an anonymous glob and returns a reference to it. Such a glob reference can be used as a file or directory handle.

For backward compatibility with older implementations that didnt support anonymous globs, Symbol::ungensym is also provided. But it doesnt do anything.

Symbol::geniosym creates an anonymous IO handle. This can be assigned into an existing glob without affecting the non-IO portions of the glob.

Symbol::qualify turns unqualified symbol names into qualified variable names (e.g. "myvar" -> "MyPackage::myvar"). If it is given a second parameter, qualify uses it as the default package; otherwise, it uses the package of its caller. Regardless, global variable names (e.g. "STDOUT", "ENV", "SIG") are always qualified with "main::".

Qualification applies only to symbol names (strings). References are left unchanged under the assumption that they are glob references, which are qualified by their nature.

Symbol::qualify_to_ref is just like Symbol::qualify except that it returns a glob ref rather than a symbol name, so you can use the result even if use strict refs is in effect.

Symbol::delete_package wipes out a whole package namespace. Note this routine is not exported by default--you may want to import it explicitly.

whouses Perl module is an impact analysis in a clearmake build environment.

SYNOPSIS

Run this script with the -help option for usage details. Here are some additional sample usages with explanations:

whouses foobar.h

Shows all DOs that make use of any file matching /foobar.h/.

whouses -recurse foobar.h

Same as above but follows the chain of derived files recursively.

whouses -exact foobar.h

Shows all DOs that make use of the specified file. The -exact flag suppresses pattern matching and shows only DOs which reference the exact file.

Whouses provides a limited form of "impact analysis" in a clearmake build environment. This is different from traditional impact analysis (see TRUE CODE ANALYSIS COMPARED below for details). In particular, it operates at the granularity of files rather than language elements.

Whouses is best described by example. Imagine you have a VOB /vobs_sw in which you build the incredibly simple application foo from foo.c. You have a Makefile which compiles foo.c to foo.o and then links it to produce foo. And lets further assume youve just done a build using clearmake.

Thus, foo is a derived object (DO) which has a config record (CR) showing how it was made. Whouses analyzes that CR and prints the data in easy-to-read indented textual format. For instance:

% whouses -do foo foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo.o

The -do foo points to the derived object from which to extract and analyze the CR; it will be implicit in the remaining examples. The output indicates that foo.o uses foo.c, or in other words that foo.c is a contributor to foo.o. If we add the -recurse flag:

% whouses -r foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo.o
/vobs_sw/src/foo

We see all files to which foo.c contributes, indented according to how many generations removed they are. If we now add -terminals

% whouses -r -t foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo

Intermediate targets such as foo.o are suppressed so we see only the "final" targets descended from foo.c.

We can also go in the other direction using -backward:

% whouses -b -e foo
/vobs_sw/src/foo<<less