clientmerge3.cc #1

/*
 * Copyright 1995, 1996 Perforce Software.  All rights reserved.
 *
 * This file is part of Perforce - the FAST SCM System.
 */

# include <stdhdrs.h>

# include <strbuf.h>
# include <error.h>
# include <handler.h>

# include <filesys.h>
# include <md5.h>
# include <i18napi.h>
# include <charcvt.h>

# include <diffmerge.h>

# include <msgclient.h>

# include "clientuser.h"
# include "clientmerge.h"
# include "clientmerge3.h"


static const char *const mergeHelp[] = {
    "Three-way merge options:",
    "",
    "    Accept:",
    "            at              Keep only changes to their file.",
    "            ay              Keep only changes to your file.",
    "            am              Keep merged file.",
    "            ae              Keep merged and edited file.",
    "            a               Keep autoselected file.",
    "",
    "    Diff:",
    "            dt              See their changes alone.",
    "            dy              See your changes alone.",
    "            dm              See merged changes.",
    "            d               Diff your file against merged file.",
    "",
    "    Edit:",
    "            et              Edit their file (read only).",
    "            ey              Edit your file (read/write).",
    "            e               Edit merged file (read/write).",
    "",
    "    Misc:",
    "            m               Run '$P4MERGE base theirs yours merged'.",
    "            s               Skip this file.",
    "            h               Print this help message.",
    "            ^C              Quit the resolve operation.",
    "",
    "The autoselected 'accept' option is shown in []'s on the prompt.",
    "",
    0 
};

ClientMerge3::ClientMerge3( ClientUser *ui,
			    FileSysType type,
			    FileSysType resType,
			    FileSysType theirType,
			    FileSysType baseType )
{
    	// Save UI for future use
    	this->ui = ui;

	// Set up files.

	yours  = ui->File( type );
	result = ui->File( resType );
	theirs = ui->File( theirType );
	base   = ui->File( baseType );

	// make base,theirs,result temp

	base->SetDeleteOnClose();
	theirs->SetDeleteOnClose();
	result->SetDeleteOnClose();

	// Digests for seeing if edited result matches inputs

	yoursMD5 = new MD5;
	theirsMD5 = new MD5;
	resultMD5 = new MD5;

	showAll = 0;

	theirs_cvt = NULL;
	result_cvt = NULL;
}

ClientMerge3::~ClientMerge3()
{
	delete yours;
	delete base;
	delete theirs;
	delete result;

	delete yoursMD5;
	delete theirsMD5;
	delete resultMD5;

	delete theirs_cvt;
	delete result_cvt;
}

void
ClientMerge3::SetNames( StrPtr *b, StrPtr *t, StrPtr *y )
{
	int i;
	StrPtr n = StrRef::Null();

	if( !b ) b = &n;
	if( !t ) t = &n;
	if( !y ) y = &n;

	for( i = 0; i < MarkerLast; i++ )
	    markertab[i].Clear();

	markertab[ MarkerOriginal ] << ">>>> ORIGINAL " << b;
	markertab[ MarkerTheirs ] << "==== THEIRS " << t;
	markertab[ MarkerYours ] << "==== YOURS " << y;
	markertab[ MarkerBoth ] << "==== BOTH " << t << " " << y;
	markertab[ MarkerEnd ] << "<<<<";
}

void
ClientMerge3::Open( StrPtr *name, Error *e, CharSetCvt *cvt, int charset )
{
	// No names?

	if( !markertab[0].Length() )
	    SetNames( 0, 0, 0 );

	// Open the various temps for writing.
	// Figure if the first one succeeds then the others
	// probably will, too.

	yours->Set( *name );

	if( charset )
	{
	    base->SetContentCharSetPriv( charset );
	    theirs->SetContentCharSetPriv( charset );
	    yours->SetContentCharSetPriv( charset );
	    result->SetContentCharSetPriv( charset );
	}

	base->MakeLocalTemp( name->Text() );
	theirs->MakeLocalTemp( name->Text() );
	result->MakeLocalTemp( name->Text() );

	base->Open( FOM_WRITE, e );

	if( e->Test() )
	    return;

	result->Perms( FPM_RW );
	theirs->Open( FOM_WRITE, e );
	result->Open( FOM_WRITE, e );

	if( cvt )
	{
	    theirs_cvt = cvt->Clone();
	    result_cvt = cvt->Clone();

	    base->Translator( cvt );
	    theirs->Translator( theirs_cvt );
	    result->Translator( result_cvt );
	}

	// And zonk counters for chunks

	chunksYours = 
	chunksTheirs =
	chunksConflict =
	chunksBoth = 0;

	oldBits = 0;
	markersInFile = 0;
	needNl = 0;
}

void
ClientMerge3::Write( StrPtr *buf, StrPtr *bits, Error *e )
{
	Marker3 marker = MarkerOriginal;

	int b = bits ? bits->Atoi() : 0;

	if( oldBits && oldBits != b )
	{
	    switch( b )
	    {
	    case SEL_BASE|SEL_CONF:
		++chunksConflict;

	    default:
	    case SEL_BASE:
	    case SEL_BASE|SEL_LEG1:
	    case SEL_BASE|SEL_LEG2:
		marker = MarkerOriginal;
		break;

	    case SEL_LEG1|SEL_RSLT:
		++chunksTheirs;

	    case SEL_LEG1|SEL_RSLT|SEL_CONF:
		marker = MarkerTheirs;
		break;

	    case SEL_LEG2|SEL_RSLT:
		++chunksYours;

	    case SEL_LEG2|SEL_RSLT|SEL_CONF:
		marker = MarkerYours;
		break;

	    case SEL_LEG1|SEL_LEG2|SEL_RSLT:
		marker = MarkerBoth;
		++chunksBoth;
		break;

	    case SEL_ALL:
		marker = MarkerEnd;
		break;
	    }

	    if( showAll || b & SEL_CONF || b == SEL_ALL && oldBits & SEL_CONF )
	    {
		if( needNl ) result->Write( "\n", 1, e );
		result->Write( &markertab[ marker ], e );
		result->Write( "\n", 1, e );
		++markersInFile;
	    }
	}

	oldBits = b;

	// Just a shortcut - we get back empty buffers as marker placeholders.

	if( !buf->Length() )
	    return;

	// Write to each file, according to the bits.
	// We don't need to write 'yours', because that is what is
	// already on the client.

	// We compute the md5 digest of each file at this point.
	// We'll use that later to provide a default for 'accept'.

	// The extra check in writing result is that we want to write
	// out the original version (the base) for any conflicts.  If
	// a chunk is only in the base, then leg1 and leg2 must be in
	// conflict for that chunk.

	if( b & SEL_BASE )
	{
	    base->Write( buf, e );
	    // no base digest -- can't accept it
	}

	if( b & SEL_LEG1 )
	{
	    theirs->Write( buf, e );
	    theirsMD5->Update( *buf );
	}

	if( b & SEL_LEG2 )
	{
	    // no writing yours -- already there!
	    yoursMD5->Update( *buf );
	}

	if( b & SEL_RSLT )
	{
	    resultMD5->Update( *buf );
	}

	if( ( b & SEL_RSLT ) || showAll || b == ( SEL_BASE | SEL_CONF ) )
	{
	    result->Write( buf, e );
	}

	// If this block didn't end in a linefeed, we may need to add
	// one before putting out the next marker.  This can happen if
	// some yoyo has a conflict on the last line of a file, and that
	// line has no newline.

	needNl = buf->Text()[ buf->Length() - 1 ] != '\n';
}

void
ClientMerge3::Close( Error *e )
{
	base->Close( e );
	theirs->Close( e );
	result->Close( e );

	theirsMD5->Final( theirsDigest );
	yoursMD5->Final( yoursDigest );
	resultMD5->Final( resultDigest );
}

void
ClientMerge3::Chmod( const char *perms, Error *e )
{
	yours->Chmod2( perms, e ); 
}

void
ClientMerge3::SetTheirModTime( StrPtr *modTime )
{
	theirs->ModTime( modTime );
}

MergeStatus
ClientMerge3::AutoResolve( MergeForce force )
{
	/*
	 * Automatic logic: 
	 */

	/* If showing all markers, always merge */
	/* If conflict -- skip or merge (if forced) */
	/* If we have no unique changes, accept theirs */
	/* If they have no unique changes, take ours */
	/* If we both have changes -- merge or skip (if safe). */

	Error	e;
	e.Set( MsgClient::MergeMsg3 ) << chunksYours 
	    			      << chunksTheirs
				      << chunksBoth
				      << chunksConflict;

	ui->Message( &e );

	if( showAll && force == CMF_FORCE )
	    return CMS_EDIT;

	if( chunksConflict )
	    return force == CMF_FORCE ? CMS_EDIT : CMS_SKIP;

	/* Now we know there are no conflicts. */

	if( !chunksYours )
	    return CMS_THEIRS;

	if( !chunksTheirs )
	    return CMS_YOURS;

	// There can be markers in the file without conflicts if
	// showAll (resolve -v) was selected.

	if( markersInFile )
	    return force == CMF_FORCE ? CMS_EDIT : CMS_SKIP;

	/* We both have changes. */

	switch( force )
	{
	case CMF_AUTO:	return CMS_MERGED;
	case CMF_SAFE:	return CMS_SKIP;
	case CMF_FORCE:	return CMS_MERGED;
	}

	/* not reached */

	return CMS_SKIP;
}

MergeStatus
ClientMerge32::AutoResolve( MergeForce force )
{
	/*
	 * It's just a two-way diff, so we accept theirs if forced
	 * to or if there are no differences.
	 */

    	Error	e;

	e.Set( MsgClient::MergeMsg32 ) << chunksTheirs;
	ui->Message( &e );

	/* Hmmm.  showAll for 32?  I don't think so. */
	/* But just in case. */

	if( showAll && force == CMF_FORCE )
	    return CMS_EDIT;

	/* No changes -- better to take theirs */

	if( !chunksTheirs )
	    return CMS_THEIRS;

	/* Some changes */

	switch( force )
	{
	case CMF_AUTO:	return CMS_SKIP;
	case CMF_SAFE:	return CMS_SKIP;
	case CMF_FORCE:	return CMS_THEIRS;
	}

	/* not reached */

	return CMS_SKIP;
}

MergeStatus
ClientMerge3::Resolve( Error *e )
{
	/* If the files are identical, autoaccept theirs */
	/* We prefer theirs over ours, because then integration history */
	/* marks it as a "copy" and we know the files are now identical. */
	/* Note that this silently swallows chunksBoth... */

	/* get autoresolve's suggestion */

	MergeStatus autoStat = AutoResolve( CMF_FORCE );

	/* Iteratively prompt the user for what to do. */

	StrBuf buf;

	for(;;)
	{
	    const char *autoSuggest;
	    int resultEdited = 0;

	    // default action: edit if conflict, else accept suggestion
	    // made by autoResolve.

	    switch( autoStat )
	    {
	    default:		
	    case CMS_SKIP:	autoSuggest = "s" ; break;
	    case CMS_THEIRS:	autoSuggest = "at" ; break;
	    case CMS_YOURS:	autoSuggest = "ay" ; break;
	    case CMS_MERGED:	autoSuggest = "am" ; break;
	    case CMS_EDIT:	autoSuggest = markersInFile ? "e" : "ae"; break;
	    }

	    // Prompt.  If no response, use auto

	    buf.Clear();
	    e->Clear();
	    e->Set( MsgClient::MergePrompt ) << autoSuggest;
	    e->Fmt( buf, EF_PLAIN );
	    e->Clear();
	    ui->Prompt( buf, buf, 0, e );

	    if( e->Test() )
		return CMS_QUIT;

	    if( !buf[0] )
		buf = autoSuggest;

	    // Do the user-requested operation

	    # define pair( a, b ) ( (a) << 8 | (b) )

	    switch( pair( buf[0], buf[1] ) )
	    {
	    case pair( 'a', 0 ):
		// take suggestion
		// But if merged, check for conflicts.

		if( autoStat != CMS_EDIT )
		    return autoStat;

		// fall through

	    case pair( 'a', 'e' ): 
		// accept edited result
		if( markersInFile )
		{
		    e->Set( MsgClient::ConfirmMarkers );
		    if ( !Verify( e, e ) ) break;
		}
		return CMS_EDIT; 

	    case pair( 'a', 'm' ): 
		// accept result
		if( autoStat == CMS_EDIT ) 
		{
		    e->Set( MsgClient::ConfirmEdit );
		    if ( !Verify( e, e ) ) break;
		}
		return CMS_MERGED; 

	    case pair( 'a', 't' ):
		// accept theirs
		if( chunksYours + chunksConflict )
		{
		    e->Set( MsgClient::Confirm );
		    if ( !Verify( e, e ) ) break;
		}
		return CMS_THEIRS;

	    case pair( 'a', 'y' ): 
		// accept yours 
		return CMS_YOURS;

	    case pair( 'e', 't' ): 
		// edit theirs
		ui->Edit( theirs, e );
		break; 

	    case pair( 'e', 'y' ): 
		// edit yours 
		ui->Edit( yours, e );
		break;

	    case pair( 'e', 0 ):
		// edit the merged result
		// If no markers are left in the file, zero the
		// conflict count.  Once edited, the default becomes
		// to accept the merge.

		ui->Edit( result, e ); 
		resultEdited = 1;
		break;

	    case pair( 'd', 't' ): 
		// diff theirs
		ui->Diff( base, theirs, 1, flags.Text(), e );
		break;

	    case pair( 'd', 'y' ): 
		// diff yours
		ui->Diff( base, yours, 1, flags.Text(), e );
		break;

	    case pair( 'd', 'm' ): 
		// diff merge
		ui->Diff( base, result, 1, flags.Text(), e );
		break;

	    case pair( 'd', 0 ): 
		// diff result
		ui->Diff( yours, result, 1, flags.Text(), e );
		break;

	    case pair( 'm', 0 ):
		// merge
		ui->Merge( base, theirs, yours, result, e );
		resultEdited = 1;
		break;

	    case pair( 's', 0 ):
		// skip
		return CMS_SKIP;

	    case pair( '?', 0 ):
	    case pair( 'h', 0 ):
		// help
		ui->Help( mergeHelp );
		break;

	    default:
		e->Set( MsgClient::BadFlag );
		break;
	    }

	    // If the result was edited, we're going to have to
	    // try to pick a new result.  We have the digest of
	    // yours/theirs/result, so we just compute the digest
	    // of the current result and see which it matches.  
	    // If none match, it's an original edit.

	    if( !e->Test() && resultEdited )
	    {
		autoStat = DetectResolve();

		// Edited result has markers if (a) it
		// isn't theirs/yours/merged, (b) it had markers before,
		// and (c) CheckForMarkers() finds some.

		markersInFile = 
		    markersInFile && 
		    autoStat == CMS_EDIT && 
		    CheckForMarkers( result, e  );

		// If the edited result equals yours, suggest edit instead.
		// In most cases if the user has picked out the yours diff
		// in an editor, they will want to reverse-integrate it.

		if( autoStat == CMS_YOURS )
		    autoStat = CMS_EDIT;
	    }

	    // Report Errors

	    if( e->Test() )
	    {
		ui->Message( e );
		e->Clear();
	    }
	}
}

void
ClientMerge3::Select( MergeStatus stat, Error *e )
{
	// Given the automatic or manual selection, now move the proper
	// file into place.  Usually it is already in place.

	switch( stat )
	{
	case CMS_THEIRS:
	    // accept theirs
	    theirs->Chmod( FPM_RW, e );
	    theirs->Rename( yours, e );

	    if( e->Test() )
	        return;

	    // in case the file type has changed, move the filesys objects
	    // around to leave the yours object with a result file type
	    theirs->Set( yours->Name() );
	    delete yours;
	    yours = theirs;
	    theirs = NULL;
	    return;

	case CMS_MERGED:
	case CMS_EDIT:
	    // accept result
	    result->Rename( yours, e );

	    if( e->Test() )
	        return;

	    // in case the file type has changed, move the filesys objects
	    // around to leave the yours object with a result file type
	    result->Set( yours->Name() );
	    delete yours;
	    yours = result;
	    result = NULL;
	    return;

	default:
	    return;
	}

}

int
ClientMerge3::CheckForMarkers( FileSys *f, Error *e ) const
{
	StrBuf l1;

	int markers = 0;

	f->Open( FOM_READ, e );

	if( e->Test() )
	    return 0;

	while( !markers )
	{
	    if( !f->ReadLine( &l1, e ) )
		break;

	    if( !l1.Length() || !strchr( "<>==", l1.Text()[0] ) )
		continue;

	    for( int i = 0; i < MarkerLast; i++ )
		if( l1 == markertab[ i ] )
		    ++markers;
	}

	f->Close( e );

	return markers > 0;
}

int
ClientMerge3::IsAcceptable() const
{
	// For the GUI: no error; we'll assume a missing
	// result will be seen downstream!

	Error e;

	return !markersInFile || !CheckForMarkers( result, &e );
}

MergeStatus
ClientMerge3::DetectResolve() const
{
	StrBuf d;
	Error e[1];
	CharSetCvt *icvt = 0;

	if( result_cvt )
	{
	    icvt = result_cvt->ReverseCvt();
	    result->Translator( icvt );
	}

	// Get & Compare digest of result against various legs
	// Blow off errors -- if we can't get to the result we'll
	// find out sooner or later.

	result->Digest( &d, e );
	delete icvt;

	if( d == theirsDigest ) 	return CMS_THEIRS;
	else if( d == yoursDigest ) 	return CMS_YOURS;
	else if( d == resultDigest ) 	return CMS_MERGED;
	else 				return CMS_EDIT;
}

const StrPtr *
ClientMerge3::GetMergeDigest() const
{
	// If the file has conflicts, do not report merge digest

	if( markersInFile || chunksConflict )
	    return NULL;

	return &resultDigest;
}

const StrPtr *
ClientMerge3::GetYourDigest() const
{
	return &yoursDigest;
}

const StrPtr *
ClientMerge3::GetTheirDigest() const
{
	return &theirsDigest;
}