Free flat file extractor software for linux

Flat File Extractor can be used for reading different flat file structures and printing them in different formats. ffe is a command line tool developed in GNU/Linux environment and it is distributed under GNU General Public License 2 or later.
Main areas of use are:
- Extracting particular fields or records from a flat file
- Converting data from one format to an other, e.g. from CSV to fixed length
- Verifying a flat file structure
- Testing tool for flat file development
- Displaying flat file content in human readable form
Main features:
- Command-line tool
- Reads standard input and writes to standard output as default
- One input file can contain several types of records (lines)
- Fields in a flat file can be fixed length or separated
- Input file structure and output definitions are independent, meaning one output format can be used with several input files
- Input file structure and output format are freely configurable, they are not predefined
- Output can be formatted e.g. as: fixed length, separated, tokenized, XML, SQL,...
- ffe tries to guess the input format, user needs not to give it as a parameter
Enhancements:
- Configuration keyword const has been added

Archive::SelfExtract is a Perl module to bundle compressed archives with Perl code.

SYNOPSIS

use Archive::SelfExtract;

# writes output script to STDOUT
Archive::SelfExtract::createExtractor( "perlcode.pl", "somefiles.zip" );

# with various options:
Archive::SelfExtract::createExtractor( "perlcode.pl", "somefiles.zip",
perlbin => "/opt/perl58/bin/perl",
output_fh => $someFileHandle,
);
See also the command line tool, mkselfextract.

Archive::SelfExtract allows you create Perl programs out of compressed zip archives. Given a piece of code and an archive, it creates a single file which, when run, unpacks the archive and then runs the code.

This module provides a function for creating a self-extractor script, a function to unpack the archive, and utility functions for wrapped programs

Tie::FlatFile::Array is a Perl extension which treats a flatfile database as an array of arrays.

This module allows the programmer to treat a flatfile database as as array of arrays. For example, lets say you have a datafile that has fixed-length records like so:

Field-name Type
URL ASCII characters, length 30
Referals Integer, 4 bytes, binary in network order

If you were going to use pack to create a record like this, youd use a format string of A30N. Since Tie::FlatFile::Array does the packing and unpacking behind the scenes, you would use that pack format string in the call to tie:

tie @flat, Tie::FlatFile::Array, data.file,
O_RDWR | O_CREAT, 0644, { packformat => A30N }
or die("Tie failure: $!");

To insert an item into the data file, you would assign an array reference to one of the arrays elements like so:

$flat[0] = [ www.yahoo.com, 3601 ];

FLAT::Legacy::FA::RE is a regular expression base class.

SYNOPSIS

use FLAT::Legacy::FA::RE;
use FLAT::Legacy::FA::NFA;
my $re = RE->new();
$re->set_re(a|b|(hi)*);
my $nfa = $re->to_nfa();
print $nfa->info(); # see stuff on NFA
my $dfa = $nfa->to_dfa();
print $dfa->info(); # see stuff on DFA
my @removed = $dfa->minimize();
print $dfa->info(); # see stuff on minimized DFA
print "Removed ".($#removed+1)." statesn";

This module implements a regular expression parser, and supports the conversion of a RE to a deterministic finite automata. A homegrown recursive descent parser is used to build the parse tree, and the method used to conver the regular expression to a DFA uses no intermediate NFA.
Recursive Descent-safe Regex Grammar:

R -> O

O -> CO

O -> | CO | epsilon

C -> SC

C -> .SC | epsilon

S -> LS

S -> *S | epsilon

L -> a | b | c |..| 0 | 1 | 2 |..| (R) | epsilon

Terminal symbols: a,b,c,..,z,0,1,2,..,9,|,*,(,)

NOTE: Concatenation operator, ., is not a terminal symbol and should not be included in the regex

FAQ: Q: Does this support Perl regular expressions?
A: No, just the regular expression using the terminal symbols listed above.

Office Tournament project is a tool for keeping track of office tournaments, such as foosball.

You may enter data from the command line or from the CGI Web interface. It outputs all kinds of stats and even a nice chart if you use the Imager::Graph::Pie Perl library available from CPAN.

It currently requires no database to run, but there are plans to migrate the text (flat file db) to MySQL.

Flatworm project is a Java library intended to allow a developer to describe the format of a flat file using an XML definition file, and then to be able to automatically read lines from that file, and have one or more beans be instantiated for each logical record.

There are a few powerful features in Flatworm worth mentioning. For one thing, a record may consist of one or more physical lines in the file. A record may contain more than one bean once decoded. A flat file may contain more than one type of record, and Flatworm can use line length and substring matching to determine which type of record a line begins.

Besides fielded buffer flat files, Flatworm also supports text files where the different fields are separated by a separator character, e.g. CSV (comma separated values) files.

Last but not least, Flatworm is able to produce flat files from beans and the same definition file.

File::Tabular can search and edit flat tabular files.

SYNOPSIS

use File::Tabular;
my $f = new File::Tabular($filename);

my $row = $f->fetchrow;
print $row->{field1}, $row->{field2};

$row = $f->fetchrow(where => someWord);
$row = $f->fetchrow(where => field1 > 4 AND field2 >= "01.01.2001");
$row = $f->fetchrow(where => qr/somes+(complexs*)?(regex|regular expression)/i);

$f->rewind;
my $rows = $f->fetchall(where => someField =~ ^[abc]+);
print $_->{someField} foreach @$rows;

$f->rewind;
$rows = $f->fetchall(where => +field1:someWord -field2:otherWord,
orderBy => field3, field6:num, field5:-alpha);

$f->rewind;
my $hashRows = $f->fetchall(where => foo AND NOT bar,
key => someField);
print $hashRows->{someKey}{someOtherField};

# open for updates, and remember the updates in a journal file
$f = new File::Tabular("+>$journalFile"});

# updates at specific positions (line numbers)
$f->splices(4 => 2, undef, # delete 2 lines from position 4
7 => 1, {f1 => $v1, f2 => $v2, ...}, # replace line 7
9 => 0, { ...}, # insert 1 new line at position 9
22 => 0, [{...}, {...}, ...] # insert several lines at pos. 22
...
-1 => 0, [{...}, {...}, ...] # append at the end
);

# shorthand to add new data at the end
$f->append({f1 => $v1, f2 => $v2, ...});
# same thing, but use the "Hash::Type" associated to the file
$f->append($f->ht->new($v1, $v2, ...));


$f->clear; # removes all data (but keeps the header line)

# updates at specific keys, corresponding to @keyFields
$f->writeKeys({key1 => {f1 => $v1, f2 => $v2, ...}, # add or update
key2 => undef, # remove
...
}, @keyFields);


# replay the updates on a backup file
my $bck = new File::Tabular("+<<less