Free xml validator software for linux

XML::Validator::Schema is a Perl module to validate XML against a subset of W3C XML Schema.

SYNOPSIS

use XML::SAX::ParserFactory;
use XML::Validator::Schema;

#
# create a new validator object, using foo.xsd
#
$validator = XML::Validator::Schema->new(file => foo.xsd);

#
# create a SAX parser and assign the validator as a Handler
#
$parser = XML::SAX::ParserFactory->parser(Handler => $validator);

#
# validate foo.xml against foo.xsd
#
eval { $parser->parse_uri(foo.xml) };
die "File failed validation: $@" if $@;

This module allows you to validate XML documents against a W3C XML Schema. This module does not implement the full W3C XML Schema recommendation (http://www.w3.org/XML/Schema), but a useful subset. See the SCHEMA SUPPORT section below.

IMPORTANT NOTE: To get line and column numbers in the error messages generated by this module you must install XML::Filter::ExceptionLocator and use XML::SAX::ExpatXS as your SAX parser. This module is much more useful if you can tell where your errors are, so using these modules is highly recommeded!

Bundle::W3C::Validator is a Perl bundle of modules required by the W3C Markup Validator.

SYNOPSIS

perl -MCPAN -e "install Bundle::W3C::Validator"

CONTENTS

CGI 2.81
Config::General 2.19
HTML::Parser 3.25
HTML::Template 2.6
LWP::UserAgent 1.90
Net::IP
Set::IntSpan
Text::Iconv
URI

Data::Validator::Item is a Factory Class to validate data items.

This is an attempt to create an object which will permit semi-automatic verification of a data value.

SYNOPSIS

use Data::Validator::Item;
my $item = Data::Validator::Item->new(); #Create a new Data::Validator::Item, called $item.

#Set values
$item->name(fred);
$item->values([1,2,3]); or $item->values(@array);
$item->missing(*); or $item->missing(); #undef is unlikely to be sensible!
$item->min(0); $item->max(100);
$item->verify($reference_to_subroutine); #Used in the $item->validate() function
$item->transform($reference_to_subroutine); #Used in the $item->put() function

#Get values
my $name = $item->name();
my @values = $item->values();
my $missing = $item->missing();
etc...

#Use it.. $item->validate(); #Returns 1 for success, 0 for failure $item->error(); #Returns the correct error message $item->put();

USAGE

Many people work with data organised as records, each containing (potentially many) variables. It is often necessary to process files of such records, and to test every variable within every record to ensure that each one is valid. I do this before putting data from very large flat files into my databases. For each variable I had a need to define specific, sometimes complex rules for validity, then implement them, and check them. This is what Data::Validator::Item is for.

Note carefully that Data::Validator::Item handles only one scalar vlaue at a time. This value could come from a file, a database, an array, a hash or your grannys parrot. Data::Validator::Item doesnt care.

I use Data::Validator::Item as follows. I create one for every named variable in my data file. In many real applications most of this setup can be done by looping over a list of variable names, creating many Data::Validator::Items each named for the corresponding variable. Common features, like missing values, and names can be set in this loop.

Specifics, like values(), min(), max(), verify() and so on can be set individually. I then create a hash to hold all of the Data::Validator::Items for a particular data source, The keys of this hash are the names of the variables, and the values are the Data:Validators themselves. Y.M.M.V.

XML-Parse library is a lightweight set of re-usable functions for general purpose parsing, checking, and creating xml files. It can support stream-oriented, SAX or DOM parsing styles, and includes an optional xsd schema validator and graphical schema generator.
It supports all valid XML, and includes checking for validity. This library has minimal dependencies, and is totally self-contained. XML Parse Library project is written in C and is both speed and memory efficient, and is simple to use. Primary core functions have been posted, and additional advanced and useful XML-related utilities will be added. Released under MIT License.
The XML-Parse library contains functions for parsing and/or creating xml files in a variety of ways. You should use whichever set makes sense for your needs. The functions support the following alternative ways of working with XML files:
- Read whole xml-files into a tokenized tree-structure in memory, and then operate on, traverse, access, or further decode values out of the tree. Your custom application code is usually required to access and operate on the tokenized-values.
- Read xml-files, parse and interpret them as they are being read. Your custom application-specific code can be interspersed with the re-usable parsing calls to interpret, convert, operate-on or store values immediately as input-stream is read, instead of storing in an intermediate tokenized-tree structure. This method reduce time and memory requirements, and supports streaming operations.
- Build xml-tree structures with convenient reusable routines from data in your application, and or modify values in read-in trees.
- Write-out valid xml-files automatically from xml-trees that were constructed or read-into memory by your application.
- Check xml-trees against an arbitrary xml schema definition (XSD).

XML::Atom is an Atom feed and API implementation.

SYNOPSIS

use XML::Atom;

Atom is a syndication, API, and archiving format for weblogs and other data. XML::Atom implements the feed format as well as a client for the API.

DBIx::XML::DataLoader contains a set of modules that are meant to work together. DBIx::XML::DataLoader.pm the core for this package DB.pm which contains the sql specific stuff MapIt.pm handles parsing the xml mapping file IsDefined.pm a simple module for making sure empty data sets are defined

dataloader uses a external map(see map instructions below) file written in xml to find its instructions for handling the data contained in the xml data files that will be imported.

SYNOPSIS

use DBIx::XML::DataLoader;

my $mapper=DBIx::XML::DataLoader->new(map=>"map.xml");
my $response=$mapper->processxml(xml=>"data.xml");

XML::DT is a package for down translation of XML files.

SYNOPSIS

use XML::DT;

%xml=( music => sub{"Music from: $cn"},
lyrics => sub{"Lyrics from: $v{name}n"},
title => sub{ uc($c) },
-default => sub{"$q:$c"} );

print dt($filename,%xml);

ABSTRACT

This module is a XML down processor. It maps tag (element) names to functions to process that element and respective contents.

This module processes XML files with an approach similar to OMNIMARK. As XML parser it uses XML::Parser or XML::LibXML module in an independent way. At configure stage, you should choose one of the back-ends.