Subversion Repositories DevTools

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

# Codestriker: Copyright (c) 2001, 2002 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.

# Model object for handling topic file data.

package Codestriker::Model::Delta;

use strict;

use Encode qw(decode_utf8);

# Create the appropriate delta rows for this review. This gets called

# by File::get_deltas. It passes in the result of a sql query on the

# delta table.

sub new {

    my $class = shift;

    my $self = {};

    bless $self;

    $self->{filename} = decode_utf8($_[1]);

    $self->{revision} = $_[2];

    $self->{binary} = $_[3];

    $self->{old_linenumber} = $_[4];

    $self->{new_linenumber} = $_[5];

    $self->{text} = decode_utf8($_[6]);

    $self->{description} = (defined $_[7]) ? decode_utf8($_[7]) : "";

    $self->{filenumber} = $_[8];

    $self->{repmatch} = $_[9];

    $self->{only_delta_in_file} = 0;

    return $self;

}

# Retrieve the number of lines in the data for a given file.

# Input -1 for filenumber for a full file list of a specific topic.

sub get_delta_size($$$) {

    my ($type, $topicid, $filenumber) = @_;

    my @deltas = ();

    @deltas = $type->get_deltas($topicid, $filenumber);

    my $addedLines = 0;

    my $removedLines = 0;

    for (my $i = 0; $i <= $#deltas; $i++) {

	my $delta = $deltas[$i];

	my @lines = split '\n', $delta->{text};

	for (my $j = 0; $j <= $#lines; $j++) {

	    my @aLine = $lines[$j];

	    if (scalar( grep !/^\+/, @aLine ) == 0) {

		$addedLines++;

	    } elsif (scalar( grep !/^\-/, @aLine ) == 0) {

		$removedLines++;

	    }

	}

    }

    my $numLines = "";

    # Return the changes if one is non zero.

    if (($removedLines != 0) || ($addedLines != 0)) {

	$numLines = "+$addedLines,-$removedLines";

    }

    return $numLines;

}

# Retrieve the ordered list of deltas that comprise this review.

# Input -1 for filenumber for a full file list of a specific topic.

sub get_delta_set($$$) {

    my ($type, $topicid, $filenumber) = @_;

    return $type->get_deltas($topicid, $filenumber);

}

# Retrieve the delta for the specific filename and linenumber.

sub get_delta($$$) {

    my ($type, $topicid, $filenumber, $linenumber, $new) = @_;

    # Grab all the deltas for this file, and grab the delta with the highest

    # starting line number lower than or equal to the specific linenumber,

    # and matching the same file number.

    my @deltas = $type->get_deltas($topicid, $filenumber);

    my $found_delta = undef;

    for (my $i = 0; $i <= $#deltas; $i++) {

	my $delta = $deltas[$i];

	my $delta_linenumber = $new ?

	    $delta->{new_linenumber} : $delta->{old_linenumber};

	if ($delta_linenumber <= $linenumber) {

	    $found_delta = $delta;

	} else {

	    # Passed the delta of interest, return the previous one found.

	    return $found_delta;

	}

    }

    # Return the matching delta found, if any.

    return $found_delta;

}

# Retrieve the ordered list of deltas applied to a specific file. Class factory

# method, returns a list of delta objects.

sub get_deltas($$$) {

    my ($type, $topicid, $filenumber) = @_;

    # Obtain a database connection.

    my $dbh = Codestriker::DB::DBI->get_connection();

    # Setup the appropriate statement and execute it.

    my $select_deltas =

	$dbh->prepare_cached('SELECT delta_sequence, filename, revision, ' .

			     'binaryfile, old_linenumber, new_linenumber, ' .

			     'deltatext, description, topicfile.sequence, ' .

			     'repmatch FROM topicfile, delta ' .

			     'WHERE delta.topicid = ? AND ' .

			     'delta.topicid = topicfile.topicid AND ' .

			     'delta.file_sequence = topicfile.sequence ' .

			     (($filenumber != -1) ?

			      'AND topicfile.sequence = ? ' : '') .

			     'ORDER BY delta_sequence ASC');

    my $success = defined $select_deltas;

    if ($filenumber != -1) {

	$success &&= $select_deltas->execute($topicid, $filenumber);

    } else {

	$success &&= $select_deltas->execute($topicid);

    }

    # Store the results into an array of objects.

    my @results = ();

    if ($success) {

	my @data;

	while (@data = $select_deltas->fetchrow_array()) {

            my $delta = Codestriker::Model::Delta->new( @data );

	    push @results, $delta;

	}

    }

    # The delta object needs to know if there are only delta objects

    # in this file so it can figure out if the delta is a new file.

    # Set the 'only_delta_in_file' field for each delta.

    if (scalar(@results) > 0) {

        # Assume the first delta is the only delta unless proven otherwise.

        $results[0]->{only_delta_in_file} = 1;

        for (my $i = 1; $i < scalar(@results); $i++) {

            if ($results[$i-1]->{filenumber} == $results[$i]->{filenumber}) {

                # If the previous file has the same filenumber, then

                # we know that neither the current file nor the

                # previous file are the only deltas for the file.

                $results[$i]->{only_delta_in_file} = 0;

                $results[$i-1]->{only_delta_in_file} = 0;

            } else {

                # This is the first delta of a file.  We'll assume it's the

                # only delta for this file.  If there are more deltas, the next

                # loop will correct the assumption.

                $results[$i]->{only_delta_in_file} = 1;

        }

        }

    }

    Codestriker::DB::DBI->release_connection($dbh, $success);

    die $dbh->errstr unless $success;

    return @results;

}

# This function looks at the delta, and will return 1 if the delta looks like

# it is a delta for a completly new file. This happens when a new file is added

# to SCM system, or the user updated a plain old text document to be reviewed

# without diffs. We need this function because we want to format this case

# special.

sub is_delta_new_file

{

    my $self = shift;

    # All of the following must be true:

    # - one delta for the entire file

    # - delta must start at line 1 (0ld, and new)

    my $is_new_file = 0;

    if ($self->{only_delta_in_file} &&

	$self->{old_linenumber} == 0 &&

	$self->{new_linenumber} == 1) {

	# All of the delta text lines must start with +.

	my @lines = split '\n', $self->{text};

	if ( scalar( grep !/^\+/, @lines ) == 0) {

	    $is_new_file = 1;

	}

    }

    return $is_new_file;

}

1;