import Template::Patch 0.02 from CPAN

git-cpan-module: Template::Patch
git-cpan-version: 0.02

Changes

@@ -1,5 +1,11 @@
 Revision history for Template-Patch
 
+0.02    2006-03-23
+        * If the IN template fails to match, don't clobber the output with
+          a measly version of the OUT template and nothing else. Instead,
+          passthrough the input cleanly.
+        * `metapatch --version`.
+
 0.01    2006-03-20
         First version, released on an unsuspecting world.
 

bin/metapatch

@@ -7,7 +7,9 @@ use Getopt::Long;
 
 use Template::Patch;
 
-GetOptions \our %Conf, qw(patch|p=s);
+GetOptions \our %Conf, qw(patch|p=s version);
+
+version(), exit 0 if $Conf{version};
 
 my $p = Template::Patch->new_from_file($Conf{patch});
 
@@ -20,6 +22,10 @@ $p->print;
 exit 0;
 
 sub slurp_in { local $/; <> }
+sub version {
+    (my $me = $0) =~ s,^.*/|\\,,;
+    print "$me ", Template::Patch->VERSION, "\n";
+}
 
 # vim: ts=4 et :
 

lib/Template/Patch.pm

@@ -8,10 +8,10 @@ use Template;
 
 use base 'Class::Accessor::Ref';
 
-our $VERSION = '0.01';
+our $VERSION = '0.02';
 
 BEGIN {
-    my @accs = (qw/ inp outp vars output _ext _tt conf/); 
+    my @accs = (qw/ inp outp vars routput rinput _ext _tt conf/); 
     __PACKAGE__->mk_accessors(@accs);
     __PACKAGE__->mk_refaccessors(@accs);
  }
@@ -50,7 +50,8 @@ sub new_from_file {
 
     die "$0: must supply --patch arg" unless defined $pfile;
 
-    my $self = $class->new( { vars => {}, conf => {} } );
+    my $self = $class->new( { vars => {},
+            conf => {}, routput => do{\my $output_port} } );
 
     open my $fh, "<", $pfile or die "$0: open: $pfile: $!";
     while (<$fh>) {
@@ -95,16 +96,28 @@ sub extract {
             $input,             # actual data to parse
             $self->vars,        # dictionary for extracted data
         );
+    # we need to keep a ref to input around for the case where no extraction
+    # was successful.
+    $self->rinput(\$input);
     #::YY($self->vars);
 }
 
 sub patch {
     my($self) = @_;
+
+    # if the dictionary is empty, extract didn't find anything.
+    # copy over the input, so we don't emit just a broken template.
+    # XXX: copy or ref?
+    if (0 == keys %{ $self->vars }) {
+        $self->routput( $self->rinput );
+        return;
+    }
+
     $self->_tt( Template->new );
-    $self->_tt->process( \$self->outp, $self->vars, $self->_ref_output )
+    $self->_tt->process( \$self->outp, $self->vars, $self->routput )
 }
 
-sub print { print $_[0]->output }
+sub print { print ${ $_[0]->routput } }
 
 sub ::Y  { require YAML::Syck; YAML::Syck::Dump(@_) }
 sub ::YY { require Carp; Carp::confess(::Y(@_)) }

t/01-basic.t

@@ -1,40 +1,60 @@
 #!perl -T
 
+use strict;
+use warnings;
+
 use File::Spec;
 use Test::Exception;
 
-use Test::More tests => 7;
+use Test::More tests => 9;
 
 our $FS = "File::Spec";
 
 BEGIN {
     use_ok( 'Template::Patch' );
 }
 
-diag( "Testing Template::Patch $Template::Patch::VERSION, Perl $], $^X" );
-
 dies_ok { Template::Patch->new_from_file("no_such_file") }
         "can't read from metapatch file that doesn't exist";
 
-my $tp;
+{
+    my $tp;
 
-lives_ok { $tp = Template::Patch->new_from_file($FS->catfile(qw/t basic1.mp/)); }
-        "construct patch object with .mp file";
+    lives_ok { $tp = Template::Patch->new_from_file($FS->catfile(qw/t basic1.mp/)); }
+            "construct patch object with .mp file";
 
-isa_ok $tp, "Template::Patch", "has correct type";
+    isa_ok $tp, "Template::Patch", "has correct type";
 
-my $doc = <<'.';
+    my $doc = <<'.';
 I went to the doctor and guess what he told me.
 
 Say AAAHHH!
 .
 
-lives_ok { $tp->extract($doc) } "patch extraction lives";
+    lives_ok { $tp->extract($doc) } "patch extraction lives";
+    lives_ok { $tp->patch($doc) }   "patch application lives";
+
+    (my $expected = $doc) =~ s/AAA/BBB/;
+
+    is ${$tp->routput}, $expected, "patch applied correctly";
+}
+
 
-lives_ok { $tp->patch($doc) }   "patch application lives";
+{
+    my $tp = Template::Patch->new_from_file($FS->catfile(qw/t basic1.mp/));
+    isa_ok $tp, "Template::Patch", "has correct type - 2";
 
-(my $expected = $doc) =~ s/AAA/BBB/;
+    my $doc = my $expected = <<'.';
+This document contains no triple As.
+
+The patch application should not change anything in it.
+.
+
+    $tp->extract($doc);
+    $tp->patch($doc);
+
+    is ${$tp->routput}, $expected, "patch applied correctly (did not ruin original)";
+}
 
-is $tp->output, $expected, "patch applied correctly";
 
-# vim: ts=4 et :
+# vim: ts=4 et ft=perl :