Subversion Repositories DevTools

###############################################################################

# Codestriker: Copyright (c) 2001, 2002, 2003 David Sitsky.

# All rights reserved.

# sits@users.sourceforge.net

#

# This program is free software; you can redistribute it and modify it under

# the terms of the GPL.

# Parser object for reading the output for a perforce describe command, such

# as:

#

# p4 describe -du <<changenumber>>

#

# Still need to handle binary files mentioned in the TOC.

package Codestriker::FileParser::PerforceDescribe;

use strict;

use Codestriker::FileParser::UnidiffUtils;

sub _make_chunk ($);

sub _retrieve_file ($$);

# Return the array of filenames, revision number, linenumber, whether its

# binary or not, and the diff text.

# Return () if the file can't be parsed, meaning it is in another format.

sub parse ($$$) {

    my ($type, $fh, $repository) = @_;

    # Skip initial whitespace.

    my $line = <$fh>;

    while (defined($line) && $line =~ /^\s*$/) {

	$line = <$fh>;

    }

    # Array of results found.

    my @result = ();

    # The table of contents entries.

    my @toc = ();

    # Assume the repository matches this diff, unless we find evidence to

    # the contrary.

    my $repmatch = 1;

    # Check if this is indeed output from a p4 describe command, by looking

    # first for the typical header present.

    return () unless defined($line);

    return () unless defined($line) && $line =~ /^Change \d+ by .* on .*/;

    # Skip the lines up to the table of contents.

    $line = <$fh>;

    while (defined($line) && $line !~ /^\.\.\./) {

	$line = <$fh>;

	return () unless defined $line;

    }

    # Now read the initial table of contents entries.  For added or

    # removed files, we actually need to fetch the text from the

    # repository, as it isn't included in the text of the diff,

    # unlike CVS.

    while (defined($line) && $line =~ /^\.\.\. (.*)\#(\d+) (.*)$/) {

	my $entry = {};

	$entry->{filename} = $1;

	$entry->{revision} = $2;

	$entry->{change_type} = $3;

	$entry->{repmatch} = 1;

	$entry->{old_linenumber} = 0;

	$entry->{new_linenumber} = 0;

	$entry->{text} = "";

	if ($entry->{change_type} eq 'add') {

	    _retrieve_file($entry, $repository);

	} elsif ($entry->{change_type} eq 'delete') {

	    # Need to retrieve the text of the previous revision number,

	    # as the current one is empty.

	    $entry->{revision}--;

	    _retrieve_file($entry, $repository);

	    $entry->{revision}++;

	} else {

	    # Assume it is an edit, nothing else to do, as the diffs

	    # will be included below.

	}

	# Add this to the table of contents array.

	push @toc, $entry;

	$line = <$fh>;

	return () unless defined $line;

    }

    # Skip the lines until the first diff chunk.

    while (defined($line) && $line !~ /^==== /) {

	$line = <$fh>;

    }

    # Now read the actual diff chunks.  Any entries not here will be added

    # or removed files, the text of which has already (should) have been

    # retrieved from the repository.

    my $toc_index = 0;

    while (defined($line) && $line =~ /^====/) {

	# Read the next diff chunk.

	return () unless $line =~ /^==== (.*)\#(\d+) \((.*)\) ====$/;

	my $filename = $1;

	my $revision = $2;

	my $filetype = $3;

	# Check if there are any outstanding added/removed entries from the

	# toc that need to be processed first.

	my $entry = $toc[$toc_index];

	while ($entry->{filename} ne $filename) {

	    my $chunk = _make_chunk($entry);

	    push @result, $chunk;

	    # Check the next TOC entry, if any.

	    last if ($toc_index >= $#toc);

	    $toc_index++;

	    $entry = $toc[$toc_index];

	}

	# Skip the next blank line before the unidiff.

	$line = <$fh>;

	next unless defined $line;

	if ($filetype =~ /.*text/) {

	    # Now read the entire diff chunk.

	    # Note there may be an optional '---' and '+++' lines

	    # before the chunk.

	    my $lastpos = tell $fh;

	    if (<$fh> !~ /^\-\-\-/ || <$fh> !~ /^\+\+\+/) {

		# Move the file pointer back.

		seek $fh, $lastpos, 0;

	    }

	    my @file_diffs = Codestriker::FileParser::UnidiffUtils->

		read_unidiff_text($fh, $filename, $revision, $repmatch);

	    push @result, @file_diffs;

	} else {

	    # Assume it is a binary file, initialise the chunk from the

	    # TOC entry, and flag it as binary.

	    my $chunk = _make_chunk($entry);

	    $chunk->{binary} = 1;

	    push @result, $chunk;

	}

	# Move on to the next entry in the TOC.

	$toc_index++;

	# Skip the next blank line before the next chunk.

	$line = <$fh>;

    }

    # Finally, add any remaining TOC netries that are unaccounted for.

    while ($toc_index <= $#toc) {

	my $chunk = _make_chunk($toc[$toc_index]);

	push @result, $chunk;

	$toc_index++;

    }

    # Return the found diff chunks.

    return @result;

}

# Make an initial chunk from a toc entry.

sub _make_chunk ($) {

    my ($entry) = @_;

    my $chunk = {};

    $chunk->{filename} = $entry->{filename};

    $chunk->{revision} = $entry->{revision};

    $chunk->{old_linenumber} = $entry->{old_linenumber};

    $chunk->{new_linenumber} = $entry->{new_linenumber};

    $chunk->{binary} = 0;

    $chunk->{text} = $entry->{text};

    $chunk->{description} = "";

    $chunk->{repmatch} = $entry->{repmatch};

    return $chunk;

}

# Retrieve the text specified in $entry from the repository.

sub _retrieve_file ($$) {

    my ($entry, $repository) = @_;

    eval {

	my $added = $entry->{change_type} eq 'add';

	my @text = ();

	$repository->retrieve($entry->{filename}, $entry->{revision},

			      \@text);

	if ($#text >= 0) {

	    if ($added) {

		$entry->{new_linenumber} = 1;

	    } else {

		$entry->{old_linenumber} = 1;

	    }

	    for (my $i = 1; $i <= $#text; $i++) {

		$entry->{text} .= ($added ? "+" : "-") . $text[$i] . "\n";

	    }

	}

    };

    if ($@) {

	# Problem retrieving text, assume there is no repository match.

	$entry->{repmatch} = 0;

    }

}

1;