Free compares software for linux

Ctcompares project purpose is to allow you to compare several sets of C code trees on a token basis, rather than on a line by line basis. The programs help to identify similarities between snippets of code in both trees.
Enhancements:
- The comparison method has been completely rewritten.
- A database is now used to hold 16-token "tuples" as keys; the result attached to each key is the list of source files which have that tuple.
- Tuples with multiple files from different source trees indicate potential code similarity.
- These are then fully tested to find actual code similarity.

Schema-compare is a script that will compares two database schema and show the differences side-by-side.
Schema-compare can also generate SQL statements that will alter the old database to match the schema of the new database.
The comparisons are correct, but the SQL statements at the bottom are not quite right, they are close to what is necessary, but probably not exactly right.
To install simply ungzip/untar the file wherever you want to put it in your web folder and then edit the include/config.inc.php file with the information needed to connect to the two databases you want to compare. Both databases need to be on the same database server and use the same username and password to connect to them.
Enhancements:
- This is the first release of schema-compare. It compares the database schema just fine, but the sql alter statements it creates could use some work.

SYNOPSIS

use Array::Compare;

my $comp1 = Array::Compare->new;
$comp->Sep(|);
$comp->Skip({3 => 1, 4 => 1});
$comp->WhiteSpace(0);
$comp->Case(1);

my $comp2 = Array::Compare->new(Sep => |,
WhiteSpace => 0,
Case => 1,
Skip => {3 => 1, 4 => 1});

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

$comp1->compare(@arr1, @arr2);
$comp2->compare(@arr1, @arr2);

If you have two arrays and you want to know if they are the same or different, then Array::Compare will be useful to you.
All comparisons are carried out via a comparator object. In the simplest usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(@arr1, @arr2)) {
print "Arrays are the samen";
} else {
print "Arrays are differentn";
}

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using join to turn both arrays into strings and comparing the strings using eq. In the joined strings, the elements of the original arrays are separated with the ^G character. This can cause problems if your array data contains ^G characters as it is possible that two different arrays can be converted to the same string.

To avoid this, it is possible to override the default separator character, either by passing and alternative to the new function

my $comp = Array::Compare->new(Sep => |);

or by changing the seperator for an existing comparator object

$comp->Sep(|);

In general you should choose a separator character that wont appear in your data.

You can also control whether or not whitespace within the elements of the arrays should be considered significant when making the comparison. The default is that all whitespace is significant. The alternative is for all consecutive white space characters to be converted to a single space for the pruposes of the comparison. Again, this can be turned on when creating a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in the comparison. The default is that the case of data is taken into account. This can be changed in the standard ways when creating a new comparator object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if the arrays are the same and false if theyre different) there is also a full comparison which returns a list containing the indexes of elements which differ between the two arrays. If the arrays are the same it returns an empty list. In scalar context the full comparison returns the length of this list (i.e. the number of elements that differ). You can access the full comparision in two ways. Firstly, there is a DefFull attribute. If this is true then a full comparison if carried out whenever the compare method is called.

my $comp = Array::Compare->new(DefFull => 1);
$comp->compare(@arr1, @arr2); # Full comparison

$comp->DefFull(0);
$comp->compare(@arr1, @arr2); # Simple comparison

$comp->DefFull(1);
$comp->compare(@arr1, @arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(@arr1, @arr2);

For symmetry, there is also a direct method to use to call the simple comparison.

$comp->simple_compare(@arr1, @arr2);

The final complication is the ability to skip elements in the comparison. If you know that two arrays will always differ in a particular element but want to compare the arrays ignoring this element, you can do it with Array::Compare without taking array slices. To do this, a comparator object has an optional attribute called Skip which is a reference to a hash. The keys in this hash are the indexes of the array elements and the values should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
my @a = (0, 1, 2, 3, 4, 5);
my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => %skip);

$comp->compare(@a, @b);

This should return true, as we are explicitly ignoring the columns which differ.

Of course, having created a comparator object with no skip hash, it is possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
$comp->Skip(%skip);

To reset the comparator so that no longer skips elements, set the skip hash to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e. they contain the same elements but in a different order.

if ($comp->perm(@a, @b) {
print "Arrays are permsn";
else {
print "Nope. Arrays are completely differentn";
}

In this case the values of WhiteSpace and Case are still used, but Skip is ignored for, hopefully, obvious reasons.

File::DirCompare is a Perl module to compare two directories using callbacks.

SYNOPSIS

use File::DirCompare;

# Simple diff -r --brief replacement
use File::Basename;
File::DirCompare->compare($dir1, $dir2, sub {
my ($a, $b) = @_;
if (! $b) {
printf "Only in %s: %sn", dirname($a), basename($a);
} elsif (! $a) {
printf "Only in %s: %sn", dirname($b), basename($b);
} else {
print "Files $a and $b differn";
}
});

# Version-control like Deleted/Added/Modified listing
my (@listing, @modified); # use closure to collect results
File::DirCompare->compare(old_tree, new_tree), sub {
my ($a, $b) = @_;
if (! $b) {
push @listing, "D $a";
} elsif (! $a) {
push @listing, "A $b";
} else {
if (-f $a && -f $b) {
push @listing, "M $b";
push @modified, $b;
} else {
# One file, one directory - treat as delete + add
push @listing, "D $a";
push @listing, "A $b";
}
}
});

File::DirCompare is a perl module to compare two directories using a callback, invoked for all files that are different between the two directories, and for any files that exist only in one or other directory (unique files).
File::DirCompare has a single public compare() method, with the following signature:

File::DirCompare->compare($dir1, $dir2, $sub, $opts);

The first three arguments are required - $dir1 and $dir2 are paths to the two directories to be compared, and $sub is the subroutine reference called for all unique or different files. $opts is an optional hashref of options - see OPTIONS below.

The provided subroutine is called for all unique files, and for every pair of different files encountered, with the following signature:

$sub->($file1, $file2)

where $file1 and $file2 are the paths to the two files. For unique files i.e. where a file exists in only one directory, the subroutine is called with the other argument undef i.e. for:

$sub->($file1, undef)
$sub->(undef, $file2)

the first indicates $file1 exists only in the first directory given ($dir1), and the second indicates $file2 exists only in the second directory given ($dir2).

SpamBayes is a Bayesian anti-spam classifier written in Python. The major difference between this and other, similar projects is the emphasis on testing newer approaches to scoring messages.

While most anti-spam projects are still working with the original graham algorithm, we found that a number of alternate methods yielded a more useful response.

Thats great, but whats SpamBayes?

SpamBayes will attempt to classify incoming email messages as spam, ham (good, non-spam email) or unsure. This means you can have spam or unsure messages automatically filed away in a different mail folder, where it wont interrupt your email reading. First SpamBayes must be trained by each user to identify spam and ham. Essentially, you show SpamBayes a pile of email that you like (ham) and a pile you dont like (spam). SpamBayes will then analyze the piles for clues as to what makes the spam and ham different. For example; different words, differences in the mailer headers and content style. The system then uses these clues to examine new messages.

For instance, the word "Nigeria" appears often in spam, so you could use a spam filter which identifies anything with that word in it as spam. But what if your business involves writing a guidebook on Nigerian Wildlife Conservation? Clearly a more flexible approach is necessary. Additionally spammers will adapt their content over time and will no longer use the word "Nigeria" (or the words "Lose Weight Fast", or any number of other common lines). Ideally the software will be able to adapt as the spam changes.

So, that is what SpamBayes does. It compares the spam and the ham and calculates probabilities. For instance, for me, the word "weight" almost never occurs in legitimate email, but it occurs all the time in lose weight fast spam. SpamBayes can then look at incoming email, extract the most significant clues and combine the probabilities to produce an overall rating of "spamminess". It flags the messages so that your mailer can handle the different message types. You might set it up so that ham goes straight through untouched, spam goes to a folder that you ignore (or delete without checking) and the unsure messages go to another folder which you can review for errors.

Gnome Specimen project is a simple tool to view and compare fonts installed on your system.
Main features:
- A list of all fonts available (the left pane)
- A list of font previews (the right pane)
- Configurable preview text and font size
- Configurable foreground and background colors used in the preview pane
- A Dutch translation

XCruiser project is a filesystem vizualization utility for X.
XCruiser (formerly known as XCruise) is a filesystem visualization utility which compares a filesystem to a 3D-formed universe and allows you to "cruise" within it.
It constructs a universe from directory trees, and you can navigate with a mouse.
Enhancements:
- The code was rewritten almost entirely.
New features:
- Xt is supported.
- Easy customization of button bindings / colors / accelaration.
- Keyboard support (but inconvenient).
- A new rendering algorithm. (still incomplete!)
- Monochrome mode is dismissed.

Template::Tools::ttree module can process entire directory trees of templates.

SYNOPSIS
ttree [options] [files]

The ttree script is used to process entire directory trees containing template files. The resulting output from processing each file is then written to a corresponding file in a destination directory. The script compares the modification times of source and destination files (where they already exist) and processes only those files that have been modified. In other words, it is the equivalent of make for the Template Toolkit.

It supports a number of options which can be used to configure behaviour, define locations and set Template Toolkit options. The script first reads the .ttreerc configuration file in the HOME directory, or an alternative file specified in the TTREERC environment variable. Then, it processes any command line arguments, including any additional configuration files specified via the -f (file) option.

The .ttreerc Configuration File

When you run ttree for the first time it will ask you if you want it to create a .ttreerc file for you. This will be created in your home directory.

$ ttree

Do you want me to create a sample .ttreerc file for you?

(file: /home/abw/.ttreerc) [y/n]: y
/home/abw/.ttreerc created. Please edit accordingly and re-run ttree

The purpose of this file is to set any global configuration options that you want applied every time ttree is run. For example, you can use the ignore and copy option to provide regular expressions that specify which files should be ignored and which should be copied rather than being processed as templates. You may also want to set flags like verbose and recurse according to your preference.

A minimal .ttreerc:

# ignore these files
ignore = b(CVS|RCS)b
ignore = ^#
ignore = ~$

# copy these files
copy = .(gif|png|jpg|pdf)$

# recurse into directories
recurse

# provide info about whats going on
verbose

In most cases, youll want to create a different ttree configuration file for each project youre working on. The cfg option allows you to specify a directory where ttree can find further configuration files.

cfg = /home/abw/.ttree

The -f command line option can be used to specify which configuration file should be used. You can specify a filename using an absolute or relative path:

$ ttree -f /home/abw/web/example/etc/ttree.cfg
$ ttree -f ./etc/ttree.cfg
$ ttree -f ../etc/ttree.cfg

If the configuration file does not begin with / or . or something that looks like a MS-DOS absolute path (e.g. C:etcttree.cfg) then ttree will look for it in the directory specified by the cfg option.

$ ttree -f test1 # /home/abw/.ttree/test1

The cfg option can only be used in the .ttreerc file. All the other options can be used in the .ttreerc or any other ttree configuration file. They can all also be specified as command line options.

Remember that .ttreerc is always processed before any configuration file specified with the -f option. Certain options like lib can be used any number of times and accumulate their values.

For example, consider the following configuration files:
/home/abw/.ttreerc:

cfg = /home/abw/.ttree
lib = /usr/local/tt2/templates

/home/abw/.ttree/myconfig:

lib = /home/abw/web/example/templates/lib

When ttree is invoked as follows:

$ ttree -f myconfig

the lib option will be set to the following directories:

/usr/local/tt2/templates
/home/abw/web/example/templates/lib

Any templates located under /usr/local/tt2/templates will be used in preference to those located under /home/abw/web/example/templates/lib. This may be what you want, but then again, it might not. For this reason, it is good practice to keep the .ttreerc as simple as possible and use different configuration files for each ttree project.