File Coverage

blib/lib/XAS/Lib/XML.pm

Criterion	Covered	Total	%
statement	4	6	66.6
branch			n/a
condition			n/a
subroutine	2	2	100.0
pod			n/a
total	6	8	75.0

package XAS::Lib::XML;

our $VERSION = '0.01';

use Try::Tiny;
use XML::LibXML;
use XML::LibXML::XPathContext;

use XAS::Class
  debug     => 0,
  version   => $VERSION,
  base      => 'XAS::Base',
  import    => 'class',
  accessors => 'parser schema doc xpc',
  utils     => ':validation dotid compress',
  constants => 'TRUE FALSE',
  vars => {
    PARAMS => {
      -xsd => { optional => 1, default => undef },
      -default_namespace => { optional => 1, default => 'def' },
    },
    XMLERR => '',
  }
;

# ----------------------------------------------------------------------
# Public Methods
# ----------------------------------------------------------------------

sub get_items {
    my $self = shift;
    my ($xpath) = validate_params(\@_, [1]);

    my @nodes;
    my $xpc  = $self->xpc;
    my $node = $self->doc->documentElement();

    if (my ($key) = $xpc->findnodes($xpath, $node)) {

        if ($key->hasChildNodes()) {

            @nodes = $key->childNodes();

        }

    }

    return wantarray ? @nodes : \@nodes;

}

sub get_item {
    my $self = shift;
    my ($xpath) = validate_params(\@_, [1]);

    my $value = '';
    my $xpc   = $self->xpc;
    my $node  = $self->doc->documentElement();

    if (my ($key) = $xpc->findnodes($xpath, $node)) {

        $value = $key->textContent();

    }

    return $value;

}

sub get_node {
    my $self = shift;
    my ($xpath) = validate_params(\@_, [1]);

    my $xpc   = $self->xpc;
    my $node  = $self->doc->documentElement();

    return $xpc->findnodes($xpath, $node);

}

sub is_valid {
    my $self = shift;

    my $doc = $self->doc;

    return TRUE unless (defined($self->{'schema'}));

    try {

        $self->schema->validate($doc);    # validate the document

    } catch {

        my $ex = $_;

        $self->class->var('XMLERR', $ex);

        $self->throw_msg(
            dotid($self->class) . '.is_valid',
            'xml_validate',
        );

    };

    return TRUE;

}

sub load {
    my $self = shift;
    my ($xml) = validate_params(\@_, [1]);

    try {

        # load and parse the document

        $self->{'doc'} = $self->parser->load_xml(string => $xml, {no_blanks => 1});

        # find and register all namespaces

        $self->_load_namespace();

    } catch {

        my $ex = $_;

        $self->throw_msg(
            dotid($self->class). '.parser',
            'xml_parser',
            $ex
        );

    };

}

sub xmlerr {
    my $class = shift;
    my ($value) = validate_params(\@_, [
        { optional => 1, default => undef }
    ]);

    if (defined($value)) {

        class->var('XMLERR', $value);

    }

    return class->var('XMLERR');

}

# ----------------------------------------------------------------------
# Private Methods
# ----------------------------------------------------------------------

sub init {
    my $class = shift;

    my $self = $class->SUPER::init(@_);

    $self->{'parser'} = XML::LibXML->new();
    $self->{'xpc'}    = XML::LibXML::XPathContext->new();

    if (defined($self->{'xsd'})) {

       $self->{'schema'} = XML::LibXML::Schema->new(location => $self->xsd);

    }

    return $self;

}

sub _load_namespace {
    my $self = shift;

    my $hash;
    my $doc = $self->doc;
    my $def = $self->default_namespace;

    foreach my $node ($doc->findnodes('//*/namespace::*')) {

        my $ns  = $node->getLocalName() || $def;
        my $uri = $node->getValue();

        $hash->{$ns} = $uri;   # filter multiple namespaces

    }

    while (my ($key, $value) = each(%$hash)) {

        $self->xpc->registerNs($key, $value);

    }

}

1;

__END__