Ticket #15: XimbiotPluginDiff.pm

package XimbiotPluginDiff;

use strict;

use vars qw($VERSION @ISA);

use CGI::Wiki::Plugin::Diff;
use Params::Validate::Dummy ();
use Module::Optional qw(Params::Validate 
        validate validate_pos SCALAR SCALARREF ARRAYREF HASHREF UNDEF);

@ISA = qw(CGI::Wiki::Plugin::Diff);
$VERSION = 0.01;

=head1 NAME

XimbiotPluginDiff - Implementation of CGI::Wiki::Plugin::Diff which caches
the retrieved node data for use by the caller.

=head1 REQUIRES

Subclasses CGI::Wiki::Plugin::Diff

=head1 SYNOPSIS

See CGI::Wiki::Plugin::Diff

=head1 METHODS

=over 4

=item B<differences>

Like the parent method of the same name, except if either left_version or
right_version is found to be a reference, it is assumed to be cached
revision information as returned by the CGI::Wiki::Database::retrieve_node
method.  Also, two extra fields will be present in the output hash,
left_revision & right_revision, which will contain references to the hashes
returned by retrieve node for each version (the same ones passed into the
function, when such is passed).

=cut

sub differences
{
    my $self = shift;
    my %args = validate (@_, {node          => {type => SCALAR},
                              left_version  => {type => SCALAR | HASHREF},
                              right_version => {type => SCALAR | HASHREF},
                              meta_include  => {type => ARRAYREF,
                                                optional => 1},
                              meta_exclude  => {type => ARRAYREF,
                                                optional => 1}});

    my ($node, $v1, $v2)  = @args{qw(node left_version right_version)};
    my $store = $self->datastore;
    my $fmt = $self->formatter;

    $v1 = {$store->retrieve_node (name => $node, version => $v1)}
        unless ref $v1;
    $v2 = {$store->retrieve_node (name => $node, version => $v2)}
        unless ref $v2;

    my $verstring1 = "Version " . $v1->{version};
    my $verstring2 = "Version " . $v2->{version};

    my $el1 = VCS::Lite->new
        ($verstring1, undef,
         $self->content_escape ($v1->{content})
         . $self->{metadata_separator}
         . $self->serialise_metadata ($v1->{metadata},
                                      @args{qw(meta_include meta_exclude)}));
    my $el2 = VCS::Lite->new
        ($verstring2, undef,
         $self->content_escape ($v2->{content})
         . $self->{metadata_separator}
         . $self->serialise_metadata ($v2->{metadata},
                                    @args{qw(meta_include meta_exclude)}));

    my %pag;
    $pag{left_version} = $verstring1;
    $pag{right_version} = $verstring2;
    $pag{left_revision} = $v1;
    $pag{right_revision} = $v2;
    $pag{content} = $fmt->format ($v1->{content});
    my $dlt = $el1->delta ($el2)
        or return %pag;

    my @out;
    
    for ($dlt->hunks)
    {
        my ($lin1, $lin2, $out1, $out2);
        for (@$_)
        {
            my ($ind, $line, $text) = @$_;
            if ($ind ne '+')
            {
                $lin1 ||= $line;
                $out1 .= $text;
            }
            if ($ind ne '-')
            {
                $lin2 ||= $line;
                $out2 .= $text;
            }
        }
        push @out, {left => $self->line_number ($lin1), 
                    right => $self->line_number ($lin2)};
        my ($text1,$text2) = $self->intradiff ($out1, $out2);
        push @out, {left => $text1, right => $text2};
    }

    $pag{diff} = \@out;
    return %pag;
}