#!/usr/bin/perl -w

# Copyright (C) 2007, 2008, 2009 Apple Inc.  All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# 1.  Redistributions of source code must retain the above copyright

#     notice, this list of conditions and the following disclaimer. 

# 2.  Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution. 

# 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

#     its contributors may be used to endorse or promote products derived

#     from this software without specific prior written permission. 

#

# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Merge and resolve ChangeLog conflicts for svn and git repositories

use strict;

use FindBin;

use lib $FindBin::Bin;

use File::Basename;

use File::Copy;

use File::Path;

use File::Spec;

use Getopt::Long;

use POSIX;

use VCSUtils;

sub canonicalRelativePath($);

sub conflictFiles($);

sub findChangeLog($);

sub findUnmergedChangeLogs();

sub fixMergedChangeLogs($;@);

sub fixOneMergedChangeLog($);

sub hasGitUnmergedFiles();

sub isInGitFilterBranch();

sub parseFixMerged($$;$);

sub removeChangeLogArguments($);

sub resolveChangeLog($);

sub resolveConflict($);

sub showStatus($;$);

sub usageAndExit();

my $isGit = isGit();

my $isSVN = isSVN();

my $SVN = "svn";

my $GIT = "git";

my $fixMerged;

my $gitRebaseContinue = 0;

my $mergeDriver = 0;

my $printWarnings = 1;

my $showHelp;

my $getOptionsResult = GetOptions(

    'c|continue!'     => \$gitRebaseContinue,

    'f|fix-merged:s'  => \&parseFixMerged,

    'm|merge-driver!' => \$mergeDriver,

    'h|help'          => \$showHelp,

    'w|warnings!'     => \$printWarnings,

);

my $relativePath = isInGitFilterBranch() ? '.' : chdirReturningRelativePath(determineVCSRoot());

my @changeLogFiles = removeChangeLogArguments($relativePath);

if (!defined $fixMerged && !$mergeDriver && scalar(@changeLogFiles) == 0) {

    @changeLogFiles = findUnmergedChangeLogs();

}

if (!$mergeDriver && scalar(@ARGV) > 0) {

    print STDERR "ERROR: Files listed on command-line that are not ChangeLogs.\n";

    undef $getOptionsResult;

} elsif (!defined $fixMerged && !$mergeDriver && scalar(@changeLogFiles) == 0) {

    print STDERR "ERROR: No ChangeLog files listed on command-line or found unmerged.\n";

    undef $getOptionsResult;

} elsif ($gitRebaseContinue && !$isGit) {

    print STDERR "ERROR: --continue may only be used with a git repository\n";

    undef $getOptionsResult;

} elsif (defined $fixMerged && !$isGit) {

    print STDERR "ERROR: --fix-merged may only be used with a git repository\n";

    undef $getOptionsResult;

} elsif ($mergeDriver && !$isGit) {

    print STDERR "ERROR: --merge-driver may only be used with a git repository\n";

    undef $getOptionsResult;

} elsif ($mergeDriver && scalar(@ARGV) < 3) {

    print STDERR "ERROR: --merge-driver expects %O %A %B as arguments\n";

    undef $getOptionsResult;

}

sub usageAndExit()

{

    print STDERR <<__END__;

Usage: @{[ basename($0) ]} [options] [path/to/ChangeLog] [path/to/another/ChangeLog ...]

  -c|--[no-]continue               run "git rebase --continue" after fixing ChangeLog

                                   entries (default: --no-continue)

  -f|--fix-merged [revision-range] fix git-merged ChangeLog entries; if a revision-range

                                   is specified, run git filter-branch on the range

  -m|--merge-driver %O %A %B       act as a git merge-driver on files %O %A %B

  -h|--help                        show this help message

  -w|--[no-]warnings               show or suppress warnings (default: show warnings)

__END__

    exit 1;

}

if (!$getOptionsResult || $showHelp) {

    usageAndExit();

}

if (defined $fixMerged && length($fixMerged) > 0) {

    my $commitRange = $fixMerged;

    $commitRange = $commitRange . "..HEAD" if index($commitRange, "..") < 0;

    fixMergedChangeLogs($commitRange, @changeLogFiles);

} elsif ($mergeDriver) {

    my ($base, $theirs, $ours) = @ARGV;

    if (mergeChangeLogs($ours, $base, $theirs)) {

        unlink($ours);

        copy($theirs, $ours) or die $!;

    } else {

        exec qw(git merge-file -L THEIRS -L BASE -L OURS), $theirs, $base, $ours;

    }

} elsif (@changeLogFiles) {

    for my $file (@changeLogFiles) {

        if (defined $fixMerged) {

            fixOneMergedChangeLog($file);

        } else {

            resolveChangeLog($file);

        }

    }

} else {

    print STDERR "ERROR: Unknown combination of switches and arguments.\n";

    usageAndExit();

}

if ($gitRebaseContinue) {

    if (hasGitUnmergedFiles()) {

        print "Unmerged files; skipping '$GIT rebase --continue'.\n";

    } else {

        print "Running '$GIT rebase --continue'...\n";

        print `$GIT rebase --continue`;

    }

}

exit 0;

sub canonicalRelativePath($)

{

    my ($originalPath) = @_;

    my $absolutePath = Cwd::abs_path($originalPath);

    return File::Spec->abs2rel($absolutePath, Cwd::getcwd());

}

sub conflictFiles($)

{

    my ($file) = @_;

    my $fileMine;

    my $fileOlder;

    my $fileNewer;

    if (-e $file && -e "$file.orig" && -e "$file.rej") {

        return ("$file.rej", "$file.orig", $file);

    }

    if ($isSVN) {

        open STAT, "-|", $SVN, "status", $file or die $!;

        my $status = <STAT>;

        close STAT;

        if (!$status || $status !~ m/^C\s+/) {

            print STDERR "WARNING: ${file} is not in a conflicted state.\n" if $printWarnings;

            return ();

        }

        $fileMine = "${file}.mine" if -e "${file}.mine";

        my $currentRevision;

        open INFO, "-|", $SVN, "info", $file or die $!;

        while (my $line = <INFO>) {

            if ($line =~ m/^Revision: ([0-9]+)/) {

                $currentRevision = $1;

                { local $/ = undef; <INFO>; }  # Consume rest of input.

            }

        }

        close INFO;

        $fileNewer = "${file}.r${currentRevision}" if -e "${file}.r${currentRevision}";

        my @matchingFiles = grep { $_ ne $fileNewer } glob("${file}.r[0-9][0-9]*");

        if (scalar(@matchingFiles) > 1) {

            print STDERR "WARNING: Too many conflict files exist for ${file}!\n" if $printWarnings;

        } else {

            $fileOlder = shift @matchingFiles;

        }

    } elsif ($isGit) {

        my $gitPrefix = `$GIT rev-parse --show-prefix`;

        chomp $gitPrefix;

        open GIT, "-|", $GIT, "ls-files", "--unmerged", $file or die $!;

        while (my $line = <GIT>) {

            my ($mode, $hash, $stage, $fileName) = split(' ', $line);

            my $outputFile;

            if ($stage == 1) {

                $fileOlder = "${file}.BASE.$$";

                $outputFile = $fileOlder;

            } elsif ($stage == 2) {

                $fileNewer = "${file}.LOCAL.$$";

                $outputFile = $fileNewer;

            } elsif ($stage == 3) {

                $fileMine = "${file}.REMOTE.$$";

                $outputFile = $fileMine;

            } else {

                die "Unknown file stage: $stage";

            }

            system("$GIT cat-file blob :${stage}:${gitPrefix}${file} > $outputFile");

            die $! if WEXITSTATUS($?);

        }

        close GIT or die $!;

    } else {

        die "Unknown version control system";

    }

    if (!$fileMine && !$fileOlder && !$fileNewer) {

        print STDERR "WARNING: ${file} does not need merging.\n" if $printWarnings;

    } elsif (!$fileMine || !$fileOlder || !$fileNewer) {

        print STDERR "WARNING: ${file} is missing some conflict files.\n" if $printWarnings;

    }

    return ($fileMine, $fileOlder, $fileNewer);

}

sub findChangeLog($)

{

    return $_[0] if basename($_[0]) eq "ChangeLog";

    my $file = File::Spec->catfile($_[0], "ChangeLog");

    return $file if -d $_[0] and -e $file;

    return undef;

}

sub findUnmergedChangeLogs()

{

    my $statCommand = "";

    if ($isSVN) {

        $statCommand = "$SVN stat | grep '^C'";

    } elsif ($isGit) {

        $statCommand = "$GIT diff -r --name-status --diff-filter=U -C -C -M";

    } else {

        return ();

    }

    my @results = ();

    open STAT, "-|", $statCommand or die "The status failed: $!.\n";

    while (<STAT>) {

        if ($isSVN) {

            my $matches;

            my $file;

            if (isSVNVersion16OrNewer()) {

                $matches = /^([C]).{6} (.+?)[\r\n]*$/;

                $file = $2;

            } else {

                $matches = /^([C]).{5} (.+?)[\r\n]*$/;

                $file = $2;

            }

            if ($matches) {

                $file = findChangeLog(normalizePath($file));

                push @results, $file if $file;

            } else {

                print;  # error output from svn stat

            }

        } elsif ($isGit) {

            if (/^([U])\t(.+)$/) {

                my $file = findChangeLog(normalizePath($2));

                push @results, $file if $file;

            } else {

                print;  # error output from git diff

            }

        }

    }

    close STAT;

    return @results;

}

sub fixMergedChangeLogs($;@)

{

    my $revisionRange = shift;

    my @changedFiles = @_;

    if (scalar(@changedFiles) < 1) {

        # Read in list of files changed in $revisionRange

        open GIT, "-|", $GIT, "diff", "--name-only", $revisionRange or die $!;

        push @changedFiles, <GIT>;

        close GIT or die $!;

        die "No changed files in $revisionRange" if scalar(@changedFiles) < 1;

        chomp @changedFiles;

    }

    my @changeLogs = grep { defined $_ } map { findChangeLog($_) } @changedFiles;

    die "No changed ChangeLog files in $revisionRange" if scalar(@changeLogs) < 1;

    system("$GIT filter-branch --tree-filter 'PREVIOUS_COMMIT=\`$GIT rev-parse \$GIT_COMMIT^\` && MAPPED_PREVIOUS_COMMIT=\`map \$PREVIOUS_COMMIT\` \"$0\" -f \"" . join('" "', @changeLogs) . "\"' $revisionRange");

    # On success, remove the backup refs directory

    if (WEXITSTATUS($?) == 0) {

        rmtree(qw(.git/refs/original));

    }

}

sub fixOneMergedChangeLog($)

{

    my $file = shift;

    my $patch;

    # Read in patch for incorrectly merged ChangeLog entry

    {

        local $/ = undef;

        open GIT, "-|", $GIT, "diff", ($ENV{GIT_COMMIT} || "HEAD") . "^", $file or die $!;

        $patch = <GIT>;

        close GIT or die $!;

    }

    # Always checkout the previous commit's copy of the ChangeLog

    system($GIT, "checkout", $ENV{MAPPED_PREVIOUS_COMMIT} || "HEAD^", $file);

    die $! if WEXITSTATUS($?);

    # The patch must have 0 or more lines of context, then 1 or more lines

    # of additions, and then 1 or more lines of context.  If not, we skip it.

    if ($patch =~ /\n@@ -(\d+),(\d+) \+(\d+),(\d+) @@\n( .*\n)*((\+.*\n)+)( .*\n)+$/m) {

        # Copy the header from the original patch.

        my $newPatch = substr($patch, 0, index($patch, "@@ -${1},${2} +${3},${4} @@"));

        # Generate a new set of line numbers and patch lengths.  Our new

        # patch will start with the lines for the fixed ChangeLog entry,

        # then have 3 lines of context from the top of the current file to

        # make the patch apply cleanly.

        $newPatch .= "@@ -1,3 +1," . ($4 - $2 + 3) . " @@\n";

        # We assume that top few lines of the ChangeLog entry are actually

        # at the bottom of the list of added lines (due to the way the patch

        # algorithm works), so we simply search through the lines until we

        # find the date line, then move the rest of the lines to the top.

        my @patchLines = map { $_ . "\n" } split(/\n/, $6);

        foreach my $i (0 .. $#patchLines) {

            if ($patchLines[$i] =~ /^\+\d{4}-\d{2}-\d{2}  /) {

                unshift(@patchLines, splice(@patchLines, $i, scalar(@patchLines) - $i));

                last;

            }

        }

        $newPatch .= join("", @patchLines);

        # Add 3 lines of context to the end

        open FILE, "<", $file or die $!;

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

            $newPatch .= " " . <FILE>;

        }

        close FILE;

        # Apply the new patch

        open(PATCH, "| patch -p1 $file > " . File::Spec->devnull()) or die $!;

        print PATCH $newPatch;

        close(PATCH) or die $!;

        # Run "git add" on the fixed ChangeLog file

        system($GIT, "add", $file);

        die $! if WEXITSTATUS($?);

        showStatus($file, 1);

    } elsif ($patch) {

        # Restore the current copy of the ChangeLog file since we can't repatch it

        system($GIT, "checkout", $ENV{GIT_COMMIT} || "HEAD", $file);

        die $! if WEXITSTATUS($?);

        print STDERR "WARNING: Last change to ${file} could not be fixed and re-merged.\n" if $printWarnings;

    }

}

sub hasGitUnmergedFiles()

{

    my $output = `$GIT ls-files --unmerged`;

    return $output ne "";

}

sub isInGitFilterBranch()

{

    return exists $ENV{MAPPED_PREVIOUS_COMMIT} && $ENV{MAPPED_PREVIOUS_COMMIT};

}

sub parseFixMerged($$;$)

{

    my ($switchName, $key, $value) = @_;

    if (defined $key) {

        if (defined findChangeLog($key)) {

            unshift(@ARGV, $key);

            $fixMerged = "";

        } else {

            $fixMerged = $key;

        }

    } else {

        $fixMerged = "";

    }

}

sub removeChangeLogArguments($)

{

    my ($baseDir) = @_;

    my @results = ();

    for (my $i = 0; $i < scalar(@ARGV); ) {

        my $file = findChangeLog(canonicalRelativePath(File::Spec->catfile($baseDir, $ARGV[$i])));

        if (defined $file) {

            splice(@ARGV, $i, 1);

            push @results, $file;

        } else {

            $i++;

        }

    }

    return @results;

}

sub resolveChangeLog($)

{

    my ($file) = @_;

    my ($fileMine, $fileOlder, $fileNewer) = conflictFiles($file);

    return unless $fileMine && $fileOlder && $fileNewer;

    if (mergeChangeLogs($fileMine, $fileOlder, $fileNewer)) {

        if ($file ne $fileNewer) {

            unlink($file);

            rename($fileNewer, $file) or die $!;

        }

        unlink($fileMine, $fileOlder);

        resolveConflict($file);

        showStatus($file, 1);

    } else {

        showStatus($file);

        print STDERR "WARNING: ${file} could not be merged using fuzz level 3.\n" if $printWarnings;

        unlink($fileMine, $fileOlder, $fileNewer) if $isGit;

    }

}

sub resolveConflict($)

{

    my ($file) = @_;

    if ($isSVN) {

        system($SVN, "resolved", $file);

        die $! if WEXITSTATUS($?);

    } elsif ($isGit) {

        system($GIT, "add", $file);

        die $! if WEXITSTATUS($?);

    } else {

        die "Unknown version control system";

    }

}

sub showStatus($;$)

{

    my ($file, $isConflictResolved) = @_;

    if ($isSVN) {

        system($SVN, "status", $file);

    } elsif ($isGit) {

        my @args = qw(--name-status);

        unshift @args, qw(--cached) if $isConflictResolved;

        system($GIT, "diff", @args, $file);

    } else {

        die "Unknown version control system";

    }

}