File Coverage

blib/lib/XML/Filter/DOMFilter/LibXML.pm

Criterion	Covered	Total	%
statement	6	8	75.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	9	11	81.8

package XML::Filter::DOMFilter::LibXML;

use 5.006;
use strict;
our $VERSION = '0.04';

use XML::LibXML::SAX::Builder;
use XML::LibXML::SAX::Parser;
use base qw(XML::LibXML::SAX::Builder);

sub _match {
  my ($self,$ctxt) = @_;
  my $p = $self->{Process};
  if ($self->{XPathContext}) {
    $self->{XPathContext}->setContextNode($ctxt);
    $ctxt=$self->{XPathContext};
  }
  return unless ref($p);
  for (my $i=0; $i<$#$p; $i+=2) {
    if ($ctxt->find($p->[$i])) {
      $self->{Matched}=$p->[$i+1];
      return 1;
    }
  }
}

sub start_document {
  my $self = shift;
  $self->SUPER::start_document(@_);
  $self->{Handler}->start_document(@_) if defined($self->{Handler});
}

sub xml_decl {
  my $self = shift;
  $self->SUPER::xml_decl(@_);
  $self->{Handler}->xml_decl(@_) if defined($self->{Handler});
}

sub end_document {
  my $self = shift;
  $self->SUPER::end_document(@_);
  $self->{Handler}->end_document(@_) if defined($self->{Handler});
}

sub start_prefix_mapping {
  my $self = shift;
  $self->SUPER::start_prefix_mapping(@_);
  $self->{Handler}->start_prefix_mapping(@_) unless (!defined($self->{Handler}) ||
						     $self->{FULL_TREE});
}

sub end_prefix_mapping {
  my $self = shift;
  $self->SUPER::end_prefix_mapping(@_);
  $self->{Handler}->end_prefix_mapping(@_) unless (!defined($self->{Handler}) ||
						   $self->{FULL_TREE});
}

sub start_dtd {
  my $self = shift;
#  $self->SUPER::start_dtd(@_); # not implemented by Builder
  $self->{Handler}->start_dtd(@_) if defined($self->{Handler});
}

sub end_dtd {
  my $self = shift;
#  $self->SUPER::end_dtd(@_); # not implemented by Builder
  $self->{Handler}->end_dtd(@_) if defined($self->{Handler});
}

sub start_cdata {
  my $self = shift;
  $self->SUPER::start_cdata(@_);
  $self->{Handler}->start_cdata(@_) unless (!defined($self->{Handler}) ||
					    $self->{FULL_TREE});
}

sub end_cdata {
  my $self = shift;
  $self->SUPER::end_cdata(@_);
  $self->{Handler}->end_cdata(@_) unless (!defined($self->{Handler}) ||
					  $self->{FULL_TREE});
}


sub start_entity {
  my $self = shift;
  $self->SUPER::start_entity(@_);
  $self->{Handler}->start_entity(@_) unless (!defined($self->{Handler}) ||
					     $self->{FULL_TREE});
}

sub end_entity {
  my $self = shift;
  $self->SUPER::end_entity(@_);
  $self->{Handler}->end_entity(@_) unless (!defined($self->{Handler}) ||
					   $self->{FULL_TREE});
}


sub start_element {
  my ($self, $el) = @_;
  my $parent = $self->{Parent};

#  if ($self->{FULL_TREE}==0 and defined($parent)) {
#    foreach ($parent->childNodes()) {
#      $_->unbindNode();
#    }
#  }
  $self->SUPER::start_element($el);
  if ($self->{FULL_TREE}) {
    $self->{FULL_TREE}++;
  } else {
    if (defined($self->{DOM}) and
	$self->_match($parent || $self->{DOM})) {
      $self->{FULL_TREE}=1;
    } else {
      $self->{Handler}->start_element($el) if defined($self->{Handler});
    }
  }
}

sub end_element {
  my $self = shift;
  my $node=$self->{Parent};
  my $parent=$node->parentNode || $self->{DOM};
  $self->SUPER::end_element(@_);
  if ($self->{FULL_TREE} == 1) {
    if ($self->{Matched}) {
      # pass the result to Handler as SAX events
      if (ref($self->{Matched}) eq 'ARRAY') {
	# with parameters
	&{$self->{Matched}[0]}($node,@{$self->{Matched}}[1..$#{$self->{Matched}}]);
      } else {
	# simple callback
	&{$self->{Matched}}($node);
      }
      if ($self->{Handler}) {
	my $process=XML::LibXML::SAX::Parser->new(Handler => $self->{Handler});
	foreach my $n ($parent->childNodes) {
	  $process->process_node($n);
	  $n->unbindNode();
	}
      } else {
          $parent->removeChildNodes;
      }
    }
  }
  if ($self->{FULL_TREE}) {
    $self->{FULL_TREE}--;
  } else {
    $self->{Handler}->end_element(@_) if defined($self->{Handler});
  }
}

sub characters {
  my $self = shift;
  if ($self->{FULL_TREE}) {
    $self->SUPER::characters(@_);
  } else {
    $self->{Handler}->characters(@_) if defined($self->{Handler});
  }
}

sub comment {
  my $self = shift;
  if ($self->{FULL_TREE}) {
    $self->SUPER::comment(@_);
  } else {
    $self->{Handler}->comment(@_) if defined($self->{Handler});
  }
}

sub processing_instruction {
  my $self = shift;
  if ($self->{FULL_TREE}) {
    $self->SUPER::processing_instruction(@_);
  } else {
    $self->{Handler}->processing_instruction(@_) if defined($self->{Handler});
  }
}

1;
__END__