XML::Validate::LibXML - Interface to LibXML validator

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

# XML::Validate::LibXML

package XML::Validate::LibXML;

use strict;
use XML::Validate::Base;
use XML::LibXML;
use Carp;

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

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::LibXML", $self);
	
	return $self;
}

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

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

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

	my $parser = XML::LibXML->new();
	$parser->line_numbers(1) if $parser->can('line_numbers'); # (XML::LibXML > 1.56)
	$parser->load_ext_dtd(1);
	$parser->expand_entities(1);
	
	my $doc = eval { $parser->parse_string($xml) };

	if ($@) {
		TRACE("We have a parsing error: $@");
		$self->add_error({message => $@});
		return;
	}
	
	TRACE("We have a doctype") if $doc->internalSubset;
	
	if ($self->options->{strict_validation} && $doc->internalSubset) {
		TRACE("Parsing with strict validation");
		$parser->validation(1);
		DUMP("Base uri",$self->options->{base_uri});
		$doc = eval { $parser->parse_string($xml,$self->options->{base_uri}) };
		if ($@) {
			TRACE("We have a validation error: $@");
			$self->add_error({message => $@});
			return;
		}
	}
	
	$self->{dom} = $doc;
	return 1;
}

sub last_dom {
	my $self = shift;
	return $self->{dom};	
}

# 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;

__END__