XML::Validate::Xerces - Interface to Xerces validator

	my $validator = new XML::Validate::Xerces(%options);
	if ($doc = $validator->validate($xml)) {
		... Do stuff with $doc ...
	} else {
		print "Document is invalid\n";
	}

package XML::Validate::Xerces;

use strict;
use XML::Validate::Base;
use XML::Xerces;

use vars qw($VERSION $CATCH_ERROR @ISA);
$VERSION = sprintf"%d.%03d", q$Revision: 1.21 $ =~ /: (\d+)\.(\d+)/;
@ISA = qw(XML::Validate::Base);

# This should happen in the XML::Xerces INIT block, but we expect this module to
# be dynamically loaded, so the INIT block probably won't happen.
XML::Xerces::XMLPlatformUtils::Initialize();

my $VALID_OPTIONS = {
	strict_validation => 1,
	base_uri => '',
};

sub new {
	my $class = shift;
	my %options = @_;
	my $self = {};
	bless ($self, $class);
	
	$self->clear_errors();
	$self->set_options(\%options,$VALID_OPTIONS);
	
	DUMP("Instantiating XML::Validate::Xerces", $self);
	
	return $self;
}

sub version {
	return XML::Xerces->VERSION;
}

sub validate {
	my $self = shift;
	my ($xml) = @_;
	TRACE("Validating with Xerces. XML => " . defined($xml) ? $xml : 'undef' );
	
	$self->clear_errors();
	$self->{DOMParser} = undef;

	die "validate called with no data to validate\n" unless defined $xml and length $xml > 0;

	my $DOMparser = new XML::Xerces::XercesDOMParser;
	# set various validation arguments based on argument
	$self->_set_validation($DOMparser, $self->options->{strict_validation});

	# error handler
	my $ErrorHandler = XML::Validate::Xerces::ErrorHandler->new($self);
	$DOMparser->setErrorHandler($ErrorHandler);

	# Use Memory buffer input source to read the XML string
	my $input = XML::Xerces::MemBufInputSource->new($xml,$self->options->{base_uri});

	$DOMparser->parse($input);

	if ($self->last_error) {
		TRACE("Exception found",$self->last_error);
		return;
	}
	
	$self->{DOMParser} = $DOMparser;
	return 1;
}

sub last_dom {
	my $self = shift;
	return undef unless defined $self->{DOMParser};
	return $self->{DOMParser}->getDocument();
}

sub _set_validation {
	my $self = shift;
	my $DOMparser = shift;
	my $strict = shift;
	
	TRACE("_set_validation called");
	
	if ($strict) {
		TRACE("Using strict validation");
		$DOMparser->setValidationScheme("$XML::Xerces::AbstractDOMParser::Val_Auto");
		$DOMparser->setIncludeIgnorableWhitespace(0);
		$DOMparser->setDoSchema(1);
		$DOMparser->setDoNamespaces(1);
		$DOMparser->setValidationSchemaFullChecking(1);
		$DOMparser->setLoadExternalDTD(1);
		$DOMparser->setExitOnFirstFatalError(1);
		$DOMparser->setValidationConstraintFatal(1);
	} else {
		TRACE("Using no validation");
		$DOMparser->setValidationScheme("$XML::Xerces::AbstractDOMParser::Val_Never");
		$DOMparser->setDoSchema(0);
		$DOMparser->setDoNamespaces(0);
		$DOMparser->setValidationSchemaFullChecking(0);
		$DOMparser->setLoadExternalDTD(0);
	}
}

# Note: Our use of TRACE and DUMP here is a bit weird. We explicitly pass to
# the TRACE and DUMP in the superclass (XML::Validate::Base) because we expect
# to be dynamically loaded and we assume that the calling class will have dealt
# with Base but not this module. (Note that Log::Trace now has some support for
# dynamic loading. It doesn't play well with some modules in 5.6.1, but it seems
# fine in 5.8. So someday this won't be necessary.)

sub TRACE { XML::Validate::Base::TRACE(@_) }
sub DUMP  { XML::Validate::Base::DUMP(@_)  }

1;

# Override XML::Xerces errors into warnings we can catch
package XML::Validate::Xerces::ErrorHandler;

use vars '@ISA';
@ISA = qw(XML::Xerces::PerlErrorHandler);

sub new {
	my $class = shift;
	my ($validator) = @_;
	my $self = {
		validator => $validator,
	};
	return bless($self,$class)
}

sub warning {
	my ($self, $exception) = @_;
	$self->add_error($exception,"Warning");
}

sub error {
	my ($self, $exception) = @_;
	$self->add_error($exception,"Invalid XML");
}

sub fatal_error {
	my ($self, $exception) = @_;
	$self->add_error($exception,"XML error");
}

sub add_error {
	my $self = shift;
	my ($exception,$message_prefix) = @_;
	my $error = {
		line    => $exception->getLineNumber,
		column  => $exception->getColumnNumber,
		message => "$message_prefix: " . $exception->getMessage,
	};
	$self->{validator}->add_error($error);
}

1;

__END__