File Coverage

blib/lib/XML/Filter/Merger.pm

Criterion	Covered	Total	%
statement	82	90	91.1
branch	22	24	91.6
condition	17	21	80.9
subroutine	16	21	76.1
pod	13	13	100.0
total	150	169	88.7

package XML::Filter::Merger;
{
  $XML::Filter::Merger::VERSION = '0.46';
}

# ABSTRACT: Assemble multiple SAX streams in to one document


use base qw( XML::SAX::Base );

use strict;
use Carp;
use XML::SAX::EventMethodMaker qw( sax_event_names compile_missing_methods );

sub _logging() { 0 };


sub new {
    my $self = shift->SUPER::new( @_ );
    $self->reset;
    return $self;
}


sub reset {
    my $self = shift;
    $self->{DocumentDepth}           = 0;
    $self->{DocumentCount}           = 0;
    $self->{TailEvents}              = undef;
    $self->{ManifoldDocumentStarted} = 0;
    $self->{Cutting}                 = 0;
    $self->{Depth}                   = 0;
    $self->{RootEltSeen}             = 0;
    $self->{AutoReset}               = 0;
}


sub start_manifold_document {
    my $self = shift;
    $self->reset;
    $self->{ManifoldDocumentStarted} = 1;

## A little fudging here until XML::SAX::Base gets a new release
$self->{Methods} = {};
}


sub _log {
    my $self = shift;

    warn "MERGER: ",
        $self->{DocumentCount}, " ",
        "| " x $self->{DocumentDepth},
        ". " x $self->{Depth},
        @_,
        "\n";
}


sub _cutting {
    my $self = shift;

#    if ( @_ ) {
#        my $v = shift;
#warn "MERGER: CUTTING ", $v ? "SET!!" : "CLEARED!!", "\n"
#   if ( $v && ! $self->{Cutting} ) || ( ! $v && $self->{Cutting} );
#        $self->{Cutting} = $v;
#    }

    my $v = shift;

    $v = 1
        if ! defined $v
            && ( $self->{DocumentCount} > 1
               || $self->{DocumentDepth} > 1
            )
            && ! $self->{Depth};


    $self->_log(
        $v ? () : "NOT ",
        "CUTTING ",
        do { my $c = (caller(1))[3]; $c =~ s/.*:://; $c },
        " (doccount=$self->{DocumentCount}",
        " docdepth=$self->{DocumentDepth}",
        " depth=$self->{Depth})"
    ) if _logging;
    return $v;

    return $self->{Cutting};
}


sub _saving {
    my $self = shift;

    return
        $self->{ManifoldDocumentStarted}
        && $self->{DocumentCount} == 1
        && $self->{DocumentDepth} == 1
        && $self->{RootEltSeen};
}


sub _push {
    my $self = shift;

    $self->_log( "SAVING ", $_[0] ) if _logging;

    push @{$self->{TailEvents}}, [ @_ ];

    return undef;
}


sub start_document {
    my $self = shift;

    $self->reset if $self->{AutoReset};

    push @{$self->{DepthStack}}, $self->{Depth};

    ++$self->{DocumentCount} unless $self->{DocumentDepth};
    ++$self->{DocumentDepth};
    $self->{Depth} = 0;

    $self->SUPER::start_document( @_ )
        unless $self->_cutting;

}

sub end_document {
    my $self = shift;

    my $r;

    unless ( $self->_cutting ) {
        if ( $self->_saving ) {
            $self->_push( "end_document", @_ );
        }
        else {
            $r = $self->SUPER::end_document( @_ );
        }
    }

    --$self->{DocumentDepth};
    $self->{Depth} = pop @{$self->{DepthStack}};

    return $r;
}


sub start_element {
    my $self = shift ;

    my $r;

    $r = $self->SUPER::start_element( @_ )
        unless $self->_cutting( $self->{IncludeAllRoots} ? 0 : () );

    ++$self->{Depth};

    return $r;
}


sub end_element {
    my $self = shift ;

    --$self->{Depth};
    $self->{RootEltSeen} ||= $self->{DocumentDepth} == 1 && $self->{Depth} == 0;

    return undef if $self->_cutting( $self->{IncludeAllRoots} ? 0 : () );

    return $self->_saving
        ? $self->_push( "end_element", @_ )
        : $self->SUPER::end_element( @_ );
}

compile_missing_methods __PACKAGE__, <<'TEMPLATE_END', sax_event_names;
sub  {
    my $self = shift;

    return undef if $self->_cutting;

    return $self->_saving
        ? $self->_push( "", @_ )
        : $self->SUPER::( @_ );
}
TEMPLATE_END


sub in_master_document {
    my $self = shift;

    return $self->{DocumentCount} == 1 && $self->{DocumentDepth} <= 1;
}


sub document_depth {
    shift->{DocumentDepth} - 1;
}




sub element_depth {
    shift->{Depth} - 1;
}



sub top_level_document_number {
    shift->{DocumentCount} - 1;
}






sub end_manifold_document {
    my $self = shift;

    my $r;
    if ( $self->{TailEvents} ) {
	for ( @{$self->{TailEvents}} ) {
	    my $sub_name = shift @$_;
            $self->_log( "PLAYING BACK $sub_name" ) if _logging;
            $sub_name = "SUPER::$sub_name";
	    $r = $self->$sub_name( @$_ );
	}
    }
    $self->{ManifoldDocumentStarted} = 0;
    $self->{AutoReset} = 1;
    return $r;
}


sub set_include_all_roots {
    my $self = shift;
    $self->{IncludeAllRoots} = shift;
}


1;

__END__