Fix some junk; Cleaner doesn't take an object.

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

diff --git a/perl-sax/XML/TemplateSAX.pm b/perl-sax/XML/TemplateSAX.pm
index a0555ec7df7dd7cca89e1615ff806dbdb12d0225..b473dd05cfe910b8343d474c25248c1359fe8872 100644 (file)
--- a/perl-sax/XML/TemplateSAX.pm
+++ b/perl-sax/XML/TemplateSAX.pm
@@ -3,7 +3,7 @@
 #
 # SAX version of XML::Template. Advantages over DOM: Doesn't have to load
 # the entire thing into memory, and you can chain filters. Disadvantages:
-# Slightly kludgier interface.
+# Slightly kludgier interface, and you won't get a DOM tree out.
 #
 # Differences from the DOM version:
 # 
@@ -11,10 +11,14 @@
 #   in the stream, usually between a parser and a writer (ie.
 #   parser -> XML::TemplateSAX::Handler -> writer). process_file works as
 #   before, but it returns a _string_, not a DOM tree.
-# - You can no longer insert a DOM tree. Instead, what you have is -- FIXME:
-#   figure out this :-)
+# - You can no longer insert a DOM tree, naturally. Instead, you can set up
+#   an XML::TemplateSAX::Buffer, let it gobble up your data, and send it
+#   in the way you'd insert a DOM tree. process_file_to_buffer does this
+#   transparently for you, returning a buffer you can give in.
 #
 
+use strict;
+use warnings;
 use XML::SAX::Expat;
 use XML::SAX::Writer;
 use XML::TemplateSAX::Buffer;
@@ -30,20 +34,57 @@ sub process_file {
        my ($writer, $cleaner, $filter, $parser);
        my $str = '';
 
-       # FIXME: hardcoding expat = not good?
        $writer = XML::SAX::Writer->new(Output => \$str);
 
        if ($clean) {
-               $cleaner = XML::TemplateSAX::Cleaner->new(Handler => $writer, Content => $obj);
+               $cleaner = XML::TemplateSAX::Cleaner->new(Handler => $writer);
                $filter = XML::TemplateSAX::Handler->new(Handler => $cleaner, Content => $obj);
        } else {
                $filter = XML::TemplateSAX::Handler->new(Handler => $writer, Content => $obj);
        }
 
+       # FIXME: hardcoding expat = not good?
        $parser = XML::SAX::Expat->new(Handler => $filter);
        $parser->parse_file($filename);
 
        return $str;
 }
 
+sub process_file_to_buffer {
+       my ($filename, $obj, $clean) = @_;
+       $clean = 1 unless (defined($clean));
+
+       my ($buffer, $cleaner, $filter, $parser);
+
+       $buffer = XML::TemplateSAX::Buffer->new;
+
+       if ($clean) {
+               $cleaner = XML::TemplateSAX::Cleaner->new(Handler => $buffer);
+               $filter = XML::TemplateSAX::Handler->new(Handler => $cleaner, Content => $obj);
+       } else {
+               $filter = XML::TemplateSAX::Handler->new(Handler => $buffer, Content => $obj);
+       }
+
+       # FIXME: hardcoding expat = not good?
+       $parser = XML::SAX::Expat->new(Handler => $filter);
+       $parser->parse_file($filename);
+
+       return $buffer;
+}
+
+sub alternate {
+       my ($tag, $array, @elems) = @_;
+
+       my $i = 0;
+       my $num = scalar @elems;
+
+       for my $ref (@$array) {
+               if (defined($ref)) {
+                       $ref->{$tag} = $elems[$i++ % $num];
+               }
+       }
+
+       return $array;
+}
+
 1;