Free extract data from xml software for linux

AnyData::Format::XML is a Perl module for tiedhash and DBI access to XML.

SYNOPSIS

# access XML data via a multi-dimensional tied hash
# see AnyData.pod for full details
#
use AnyData;
my $table = adTie( XML, $file, $mode, $flags );

OR

# convert data to and from XML
# see AnyData.pod for full details
#
use AnyData;
adConvert( XML, $file1, $any_other_format, $file2, $flags );
adConvert( $any_other_format, $file1, XML, $file2, $flags );

OR

# access the data via DBI and SQL
# see DBD::AnyData.pod for full details
#
use DBI;
my $dbh = DBI->connect( dbi:AnyData );
$dbh->func(mytable,XML,$file,$flags,ad_catalog);
See below for a description of the optional flags that apply to all of these examples.

This module allows you to create, search, modify and/or convert XML data and files by treating them as databases without having to actually create separate database files. The data can be accessed via a multi-dimensional tiedhash using AnyData.pm or via DBI and SQL commands using DBD::AnyData.pm. See those modules for complete details of usage.

The module is built on top of Michel Rodriguezs excellent XML::Twig which means that the AnyData interfaces can now include information from DTDs, be smarter about inferring data structure, reduce memory consumption on huge files, and provide access to many powerful features of XML::Twig and XML::Parser on which it is based.

Importing options allow you to import/access/modify XML of almost any length or complexity. This includes the ability to access different subtrees as separate or joined databases.
Exporting and converting options allow you to take data from almost any source (a perl array, any DBI database, etc.) and output it as an XML file. You can control the formating of the resulting XML either by supplying a DTD listing things like nesting of tags and which columns should be output as attributes and/or you can use XML::Twig pretty_print settings to generate half a dozen different levels of compactness or whitespace in how the XML looks.
The documentaion below outlines the special flags that can be used in either of the interfaces to fine-tune how the XML is treated.

The flags listed below define the relationship between tags and attributes in the XML document and columns in the resulting database. In many cases, you can simply accept the defaults and the database will be built automatically. However, you can also fine tune the generation of the database by specifying which tags and attributes you are interested in and their relationship with database columns.

libextractor is a library that is used to extract meta-data from files of arbitrary type. It is designed to use helper-libraries to perform the actual extraction, and to be trivially extendable by linking against external extractors for additional file types. libextractor is part of the GNU project. Our official GNU website can be found at http://www.gnu.org/software/libextractor/. libextractor can be downloaded from this site or the GNU mirrors.
The goal is to provide developers of file-sharing networks or WWW-indexing bots with a universal library to obtain simple keywords to match against queries. libextractor contains a shell-command "extract" that, similar to the well-known "file" command, can extract meta-data from a file an print the results to stdout.
Currently, libextractor supports the following formats: HTML, PDF, PS, OLE2 (DOC, XLS, PPT), OpenOffice (sxw), StarOffice (sdw), DVI, MAN, MP3 (ID3v1 and ID3v2), OGG, WAV, JPEG, GIF, PNG, TIFF, DEB, RPM, TAR(.GZ), ZIP, ELF, REAL, RIFF (AVI), MPEG, QT and ASF.
Also, various additional MIME types are detected.
libextractor is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
Enhancements:
- This release fixes various build problems and a crash with recent versions of libgsf.
vAn incomplete manual was added.

Data2XML is a quick JAXB-based tool for parsing simple-to-moderately-complex input data into a flat XML representation.
It is meant to replace simple String.substring() operations and keyword searches in Java by an easy-to-use XML-configured parser.
It is initialized with an XML configuration file that dictates the parsing rules, and can then be used to convert an input data stream into XML. It can search for the occurrence of certain substrings and cut the data into smaller "Tokens" using various conditions like offset definitions.
After a value is read, it can be validated against a set of OR- and AND-connected tests that check for the occurrence or non-occurrence of certain strings, check values, etc.
Enhancements:
- Long-overdue regexp valueValidator support was added.

Obscure-Extractor-GTK can extract data from simple and unusual archives as used by games, e.g. Neverwinter Nights, Homeworld 2, BloodRayne.

Mostly a framework where I can easily add new modules when I want to have a look at the inner workings of games, though the Delphi version has some more advanced stuff like support for old InstallShield archives that would need to be ported.

XML::Generator::PerlData is a Perl extension for generating SAX2 events from nested Perl data structures.

SYNOPSIS

use XML::Generator::PerlData;
use SomeSAX2HandlerOrFilter;

## Simple style ##

# get a deeply nested Perl data structure...
my $hash_ref = $obj->getScaryNestedDataStructure();

# create an instance of a handler class to forward events to...
my $handler = SomeSAX2HandlerOrFilter->new();

# create an instance of the PerlData driver...
my $driver = XML::Generator::PerlData->new( Handler => $handler );

# generate XML from the data structure...
$driver->parse( $hash_ref );

## Or, Stream style ##

use XML::Generator::PerlData;
use SomeSAX2HandlerOrFilter;

# create an instance of a handler class to forward events to...
my $handler = SomeSAX2HandlerOrFilter->new();

# create an instance of the PerlData driver...
my $driver = XML::Generator::PerlData->new( Handler => $handler );

# start the event stream...
$driver->parse_start();

# pass the data through in chunks
# (from a database handle here)
while ( my $array_ref = $dbd_sth->fetchrow_arrayref ) {
$driver->parse_chunk( $array_ref );
}

# end the event stream...
$driver->parse_end();
and youre done...

XML::Generator::PerlData provides a simple way to generate SAX2 events from nested Perl data structures, while providing finer-grained control over the resulting document streams.
Processing comes in two flavors: Simple Style and Stream Style:

In a nutshell, simple style is best used for those cases where you have a a single Perl data structure that you want to convert to XML as quickly and painlessly as possible. Stream style is more useful for cases where you are receiving chunks of data (like from a DBI handle) and you want to process those chunks as they appear. See PROCESSING METHODS for more info about how each style works.

XML From Plain Text (xfpt) is a program that reads a file of plain text that contains relatively simple markup, and outputs an XML file. It is intended to simplify the management of XML data.
The project is not a program that attempts to turn a plain text document into XML. Markup within text is introduced by ampersand characters, but is otherwise "soft". You can define what follows the ampersand, for example, &" to generate a "quote" element. There is also a macro facility that allows for higher level concepts such as chapters, displays, tables, etc.
Enhancements:
- The macro library has been extended to include preface, appendix, colophon, footnote, figure, and table.
- The program has one new directive to enable it to handle "nested" sections such as footnotes.

Data::Phrasebook::Loader::XML Perl module can abstract your phrases with XML.

SYNOPSIS

use Data::Phrasebook;

my $q = Data::Phrasebook->new(
class => Fnerk,
loader => XML,
file => phrases.xml,
dict => Dictionary, # optional
);

OR

my $q = Data::Phrasebook->new(
class => Fnerk,
loader => XML,
file => {
file => phrases.xml,
ignore_whitespace => 1,
}
);

# simple keyword to phrase mapping
my $phrase = $q->fetch($keyword);

# keyword to phrase mapping with parameters
$q->delimiters( qr{ [% s* (w+) s* %] }x );
my $phrase = $q->fetch($keyword,{this => that});

DBD::AnyData is a DBI access to XML, CSV and other formats.

SYNOPSIS

use DBI;
my $dbh = DBI->connect(dbi:AnyData(RaiseError=>1):);
$dbh->func( trains, CSV, /users/joe/cars.csv, ad_catalog);
$dbh->func( bikes, XML, [$xml_str], ad_import);
$dbh->func( cars, DBI, $mysql_dbh, ad_import);
#
# ... DBI/SQL methods to access/modify the tables cars,bikes,trains
#
print $dbh->func( cars, HTMLtable, ad_export);

or

use DBI;
my $dbh = DBI->connect(dbi:AnyData(RaiseError=>1):);
$dbh->func( Pipe, data.pipe, XML, data.xml, ad_convert);

or

(many combinations of a dozen other data formats, see below)

The DBD::AnyData module provides a DBI/SQL interface to data in many formats and from many sources.

Currently supported formats include general format flatfiles (CSV, Fixed Length, Tab or Pipe "delimited", etc.), specific formats (passwd files, web logs, etc.), a variety of other kinds of formats (XML, Mp3, HTML tables), and, for some operations, any DBI accessible database. The number of supported formats will continue to grow rapidly since there is an open API making it easy for any author to create additional format parsers which can be plugged in to AnyData.

Data in these various formats can come from local files, from remote files, or from perl data structures such as strings and arrays.

Regardless of the format or source of the data, it may be accessed and/or modified using all standard DBI methods and a subset of SQL syntax.

In addition to standard database access to files, the module also supports in-memory tables which allow you to create temporary views; to combine data from a number of sources; to quickly prototype database systems; and to display or save the data in any of the supported formats (e.g. to display data in a CSV file as an HTML table).

These in-memory tables can be created from any combination of DBI databases or files of any format. They may also be created from perl data structures which means its possible to quickly prototype a database system without any file access or rdbms backend.