Introduce a SAX cleaner.

[xml-template] / perl-sax / XML / TemplateSAX.pm

diff --git a/perl-sax/XML/TemplateSAX.pm b/perl-sax/XML/TemplateSAX.pm
index fce9ae21a155125cee64b894894c1e26ea80f1a0..18c8d6849b34f904de2cb59f5f51f6d92f70c325 100644 (file)
--- a/perl-sax/XML/TemplateSAX.pm
+++ b/perl-sax/XML/TemplateSAX.pm
@@ -17,6 +17,7 @@
 
 use XML::SAX::Expat;
 use XML::SAX::Writer;
+use Data::Dumper;
 
 package XML::TemplateSAX::Handler;
 use base qw(XML::SAX::Base);
@@ -27,6 +28,7 @@ sub new {
 
        my $self = {
                obj => $options{'Content'},
+               stack => [],
                Handler => $options{'Handler'}
        };
        bless($self, $class);
@@ -35,6 +37,92 @@ sub new {
 
 sub start_element {
        my ($self, $data) = @_;
+       my $obj = $self->{'obj'};
+
+       # within a replacement; just ignore everything  
+       return if (!defined($obj));
+
+       # substitution: see if this element matches anything. if so,
+       # descend down into the tree.
+       if (ref($obj) eq 'HASH') {
+               my $match = undef;
+               for my $key (keys %$obj) {
+                       if ($key =~ /^#(.*)$/) {
+                               if ($data->{'NamespaceURI'} eq 'http://template.sesse.net/' && $data->{'LocalName'} eq $1) {
+                                       $match = $obj->{$key};
+                                       last;
+                               }
+                       } else {
+                               if ($data->{'LocalName'} eq $key) {
+                                       $match = $obj->{$key};
+                                       last;
+                               }
+                       }
+               }
+
+               if (defined($match)) {
+                       $self->SUPER::start_element($data);
+
+                       push @{$self->{'stack'}}, [ $data->{'Name'}, $obj ];
+                       
+                       #
+                       # This is sort of ugly. We special-case replacement by outputting
+                       # the string immediately, and then just ignoring the rest of the
+                       # events until we get to the right end tag. It's not 100% technically
+                       # correct for the case where you replace an entire document by a
+                       # string, but that's nonsensical anyway.
+                       #
+                       if (!ref($match)) {
+                               $self->SUPER::characters({ Data => $match });
+                               $match = undef;
+                       }
+
+                       $self->{'obj'} = $match;
+                       return;
+               }
+       }
+       
+       $self->SUPER::start_element($data);
+}
+
+sub characters {
+       my ($self, $data) = @_;
+       return if (!defined($self->{'obj'}));
+       $self->SUPER::characters($data);
+}
+
+sub end_element {
+       my ($self, $data) = @_;
+
+       my $stack = $self->{'stack'};
+       if (scalar @$stack > 0) {
+               my $top = $stack->[$#stack];
+               
+               if ($data->{'Name'} eq $top->[0]) {
+                       $self->SUPER::end_element($data);
+                       $self->{'obj'} = $top->[1];
+                       pop @$stack;
+                       return;
+               }
+       }
+       
+       return if (!defined($self->{'obj'}));
+
+       $self->SUPER::end_element($data);
+}
+
+package XML::TemplateSAX::Cleaner;
+use base qw(XML::SAX::Base);
+
+sub start_element {
+       my ($self, $data) = @_;
+       my $attrs = $data->{'Attributes'};
+
+       for my $a (keys %$attrs) {
+               if ($attrs->{$a}->{'NamespaceURI'} eq 'http://template.sesse.net/') {
+                       delete $attrs->{$a};
+               }
+       }
 
        $self->SUPER::start_element($data);
 }
@@ -43,13 +131,22 @@ package XML::TemplateSAX;
 
 sub process_file {
        my ($filename, $obj, $clean) = @_;
+       $clean = 1 unless (defined($clean));
 
+       my ($writer, $cleaner, $filter, $parser);
        my $str = '';
 
        # FIXME: hardcoding expat = not good?
-       my $writer = XML::SAX::Writer->new(Output => \$str);
-       my $filter = XML::TemplateSAX::Handler->new(Handler => $writer, Content => $obj);
-       my $parser = XML::SAX::Expat->new(Handler => $filter);
+       $writer = XML::SAX::Writer->new(Output => \$str);
+
+       if ($clean) {
+               $cleaner = XML::TemplateSAX::Cleaner->new(Handler => $writer, Content => $obj);
+               $filter = XML::TemplateSAX::Handler->new(Handler => $cleaner, Content => $obj);
+       } else {
+               $filter = XML::TemplateSAX::Handler->new(Handler => $writer, Content => $obj);
+       }
+
+       $parser = XML::SAX::Expat->new(Handler => $filter);
        $parser->parse_file($filename);
 
        return $str;