Free merges files software for linux

mergelog provides a fast tool to merge HTTP log files by date.
mergelog is a small and fast C program, which merges HTTP log files by date in Common Log Format (Apache default log format) from Web servers, behind round-robin DNS.
It has been designed to easily process huge logs from highly stressed servers, and can manage gzipped files.
Enhancements:
- dont abort anymore on corrupted log lines
- set BUFFER_SIZE value to 32Ko
- fixed a major bug on a broken month initialization
- corrections on manpages
- fix in configure.in to abort if zlib is not present
- fixed a potential segmentation fault on malformed log lines
- autoconf compliant thanks to Igor Genibel

Submerge project is subcommanders visual diff and merge tool for text files.
Main features:
- line based difference of text files.
- an easy to understand display of differences with just one color (three colors in merge case).
- mousewheel support to quickly scroll to the next or previous difference.
- two way or three way merge.
- shows whitespaces and linefeeds in a lighter color to keep the focus on the text.
- option to ignore whitespace differences.
- supports a wide range of different file encodings (like utf8, latin1 or cp932 and shift_jis (japanese encodings)).
- supports copy & paste, copy from the source files, copy from & paste to the merged file.
- a merge editor to edit the merged file.
- based on subversions diff library.

QArchive.org web files checker is an extension which allows people to check web files for any malware.

The add-on allowing people to check web files for any malware (viruses, trojans, worms, adware, spyware and other unwanted things) inclusions. Install this plug-in to your browser, reload it. Then click the web file link by right mouse button and choose a "Check files with QArchive.org".

Then follow web site instructions. The usual way: your file will be enqueued. Refresh the report page to get completete antivirus report. That will show you all web files part checking and a summary as well. If you are a web master you can you the useful feature.

Taking the code of received report and placed it on your web site you can inform people about a concrete file safety. The web forums code version exists as well.

Hash::Merge Perl module merges arbitrarily deep hashes into a single hash.

SYNOPSIS

use Hash::Merge qw( merge );
my %a = (
foo => 1,
bar => [ qw( a b e ) ],
querty => { bob => alice },
);
my %b = (
foo => 2,
bar => [ qw(c d) ],
querty => { ted => margeret },
);

my %c = %{ merge( %a, %b ) };

Hash::Merge::set_behavior( RIGHT_PRECEDENT );

# This is the same as above

Hash::Merge::specify_behavior(
{
SCALAR => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ $_[0], @{$_[1]} ] },
HASH => sub { $_[1] },
},
ARRAY => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ @{$_[0]}, @{$_[1]} ] },
HASH => sub { $_[1] },
},
HASH => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ values %{$_[0]}, @{$_[1]} ] },
HASH => sub { Hash::Merge::_merge_hashes( $_[0], $_[1] ) },
},
},
My Behavior,
);

TMHarvest provides a tool which harvests topicmaps from structured datasources.
The TMHarvest library is based on TM4J and provides a convenient way to automatically generate topic maps from different data sources. A rules files with embedded templates (written in XML) defines from which data sources topic map constructs should be taken into account, as well how new or existent topics should be associated.
Main features:
- TMHarvest creates topic maps from existing data sources. Currently it supports the following source-types: SQL-Databases, CSV-Files, XPath-Queries. In addition it is possible to integrate custom model-providers, written in Java. See for details.
- The harvesting is driven by a model-file. The model may be processed as often as you like. Since the data sources are queried at processing time, it is possible to build topic paps periodically in order to reflect changing content.
- The model-file has a modular setup. The resulting topic map is populated step by step from distinct templateActions. The static parts of the topic map (the structural parts, for example the topics that define the ontology of the topic map) may be merged from static files and therefore seperated from the actual harvest.
Pros and Cons
The process which creates the topic map is serialized in the model-file. Once the process is defined, it runs as often as you like. This enables the creation of topic maps, that are refreshed periodically in an automated way.
Working with the templates leads to a certain interactive experience. Shaping the model, letting TMHarvest run, revisiting the results, reshape the model... let you converge the final form
The fact that the model-file must be written by hand, excludes many users, which lack the necessary technical affinity. The development of graphical interfaces or wizards would be really helpful.

File::Sort is a Perl module to sort a file or merge sort multiple files.

SYNOPSIS

use File::Sort qw(sort_file);
sort_file({
I => [qw(file_1 file_2)],
o => file_new, k => 5.3,5.5rn, -t => |
});

sort_file(file1, file1.sorted);

This module sorts text files by lines (or records). Comparisons are based on one or more sort keys extracted from each line of input, and are performed lexicographically. By default, if keys are not given, sort regards each input line as a single field. The sort is a merge sort. If you dont like that, feel free to change it.

Options

The following options are available, and are passed in the hash reference passed to the function in the format:

OPTION => VALUE

Where an option can take multiple values (like I, k, and pos), values may be passed via an anonymous array:

OPTION => [VALUE1, VALUE2]

Where the OPTION is a switch, it should be passed a boolean VALUE of 1 or 0.
This interface will always be supported, though a more perlish interface may be offered in the future, as well. This interface is basically a mapping of the command-line options to the Unix sort utility.

I INPUT

Pass in the input file(s). This can be either a single string with the filename, or an array reference containing multiple filename strings.

c

Check that single input fle is ordered as specified by the arguments and the collating sequence of the current locale. No output is produced; only the exit code is affected.

m

Merge only; the input files are assumed to already be sorted.

o OUTPUT

Specify the name of an OUTPUT file to be used instead of the standard output.

u

Unique: Suppresses all but one in each set of lines having equal keys. If used with the c option check that there are no lines with consecutive lines with duplicate keys, in addition to checking that the input file is sorted.

y MAX_SORT_RECORDS

Maximum number of lines (records) read before writing to temp file. Default is 200,000. This may eventually change to be kbytes instead of lines. Lines was easier to implement. Can also specify with MAX_SORT_RECORDS environment variable.

F MAX_SORT_FILES

Maximum number of temp files to be held open at once. Default to 40, as older Windows ports had quite a small limit. Can also specify with MAX_SORT_FILES environment variable. No temp files will be used at all if MAX_SORT_RECORDS is never reached.

D

Send debugging information to STDERR. Behavior subject to change.
The following options override the default ordering rules. When ordering options appear independent of any key field specifications, the requested field ordering rules are applied globally to all sort keys. When attached to a specific key (see k), the specified ordering options override all global ordering options for that key.

d

Specify that only blank characters and alphanumeric characters, according to the current locale setting, are significant in comparisons. d overrides i.

f

Consider all lower-case characters that have upper-case equivalents, according to the current locale setting, to be the upper-case equivalent for the purposes of comparison.

i

Ignores all characters that are non-printable, according to the current locale setting.

n

Does numeric instead of string compare, using whatever perl considers to be a number in numeric comparisons.

r

Reverse the sense of the comparisons.

b

Ignore leading blank characters when determining the starting and ending positions of a restricted sort key. If the b option is specified before the first k option, it is applied to all k options. Otherwise, the b option can be attached indepently to each field_start or field_end option argument (see below).

t STRING

Use STRING as the field separator character; char is not considered to be part of a field (although it can be included in a sort key). Each occurrence of char is significant (for example, delimits an empty field). If t is not specified, blank characters are used as default field separators; each maximal non-empty sequence of blank characters that follows a non-blank character is a field separator.

X STRING

Same as t, but STRING is interpreted as a Perl regular expression instead. Do not escape any characters (/ characters need to be escaped internally, and will be escaped for you).

The string matched by STRING is not included in the fields themselves, unless demanded by perls regex and split semantics (e.g., regexes in parentheses will add that matched expression as an extra field). See perlre and "split" in perlfunc.

R STRING

Record separator, defaults to newline.

k pos1[,pos2]

The keydef argument is a restricted sort key field definition. The format of this definition is:

field_start[.first_char][type][,field_end[.last_char][type]]

where field_start and field_end define a key field restricted to a portion of the line, and type is a modifier from the list of characters b, d, f, i, n, r. The b modifier behaves like the b option, but applies only to the field_start or field_end to which it is attached. The other modifiers behave like the corresponding options, but apply only to the key field to which they are attached; they have this effect if specified with field_start, field_end, or both. If any modifier is attached to a field_start or a field_end, no option applies to either.

Occurrences of the k option are significant in command line order. If no k option is specified, a default sort key of the entire line is used. When there are multiple keys fields, later keys are compared only after all earlier keys compare equal.
Except when the u option is specified, lines that otherwise compare equal are ordered as if none of the options d, f, i, n or k were present (but with r still in effect, if it was specified) and with all bytes in the lines significant to the comparison. The order in which lines that still compare equal are written is unspecified.

pos +pos1 [-pos2]

Similar to k, these are mostly obsolete switches, but some people like them and want to use them. Usage is:

+field_start[.first_char][type] [-field_end[.last_char][type]]

Where field_end in k specified the last position to be included, it specifes the last position to NOT be included. Also, numbers are counted from 0 instead of 1. pos2 must immediately follow corresponding +pos1. The rest should be the same as the k option.

Mixing +pos1 pos2 with k is allowed, but will result in all of the +pos1 pos2 options being ordered AFTER the k options. It is best if you Dont Do That. Pick one and stick with it.

Here are some equivalencies:

pos => +1 -2 -> k => 2,2
pos => +1.1 -1.2 -> k => 2.2,2.2
pos => [+1 -2, +3 -5] -> k => [2,2, 4,5]
pos => [+2, +0b -1] -> k => [3, 1b,1]
pos => +2.1 -2.4 -> k => 3.2,3.4
pos => +2.0 -3.0 -> k => 3.1,4.0

Algorithm::Merge is a Perl module package that provides three-way merge and diff.

SYNOPSIS

use Algorithm::Merge qw(merge diff3 traverse_sequences3);

@merged = merge(@ancestor, @a, @b, {
CONFLICT => sub { }
});

@merged = merge(@ancestor, @a, @b, {
CONFLICT => sub { }
}, $key_generation_function);

$merged = merge(@ancestor, @a, @b, {
CONFLICT => sub { }
});

$merged = merge(@ancestor, @a, @b, {
CONFLICT => sub { }
}, $key_generation_function);

@diff = diff3(@ancestor, @a, @b);

@diff = diff3(@ancestor, @a, @b, $key_generation_function);

$diff = diff3(@ancestor, @a, @b);

$diff = diff3(@ancestor, @a, @b, $key_generation_function);

@trav = traverse_sequences3(@ancestor, @a, @b, {
# callbacks
});

@trav = traverse_sequences3(@ancestor, @a, @b, {
# callbacks
}, $key_generation_function);

$trav = traverse_sequences3(@ancestor, @a, @b, {
# callbacks
});

$trav = traverse_sequences3(@ancestor, @a, @b, {
# callbacks
}, $key_generation_function);

USAGE

This module complements Algorithm::Diff by providing three-way merge and diff functions.

In this documentation, the first list to diff3, merge, and traverse_sequences3 is called the `original list. The second list is the `left list. The third list is the `right list.

The optional key generation arguments are the same as in Algorithm::Diff. See Algorithm::Diff for more information.