src/TortoiseProc/GitDiff.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2016 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19
  20 #include "stdafx.h"
  21 #include "GitDiff.h"
  22 #include "AppUtils.h"
  23 #include "gittype.h"
  24 #include "resource.h"
  25 #include "MessageBox.h"
  26 #include "FileDiffDlg.h"
  27 #include "SubmoduleDiffDlg.h"
  28 #include "TempFile.h"
  29
  30 int CGitDiff::SubmoduleDiffNull(const CTGitPath * pPath, const git_revnum_t &rev1)
  31 {
  32         CString oldhash = GIT_REV_ZERO;
  33         CString oldsub ;
  34         CString newsub;
  35         CString newhash;
  36
  37         CString cmd;
  38         if (rev1 != GIT_REV_ZERO)
  39                 cmd.Format(L"git.exe ls-tree \"%s\" -- \"%s\"", (LPCTSTR)rev1, (LPCTSTR)pPath->GetGitPathString());
  40         else
  41                 cmd.Format(L"git.exe ls-files -s -- \"%s\"", (LPCTSTR)pPath->GetGitPathString());
  42
  43         CString output, err;
  44         if (g_Git.Run(cmd, &output, &err, CP_UTF8))
  45         {
  46                 CMessageBox::Show(nullptr, output + L'\n' + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
  47                 return -1;
  48         }
  49
  50         int start = output.Find(L' ');
  51         if(start>0)
  52         {
  53                 if (rev1 != GIT_REV_ZERO) // in ls-files the hash is in the second column; in ls-tree it's in the third one
  54                         start = output.Find(L' ', start + 1);
  55                 if(start>0)
  56                         newhash=output.Mid(start+1, 40);
  57
  58                 CGit subgit;
  59                 subgit.m_CurrentDir = g_Git.CombinePath(pPath);
  60                 int encode=CAppUtils::GetLogOutputEncode(&subgit);
  61
  62                 cmd.Format(L"git.exe log -n1 --pretty=format:\"%%s\" %s --", (LPCTSTR)newhash);
  63                 bool toOK = !subgit.Run(cmd,&newsub,encode);
  64
  65                 bool dirty = false;
  66                 if (rev1 == GIT_REV_ZERO && !(pPath->m_Action & CTGitPath::LOGACTIONS_DELETED))
  67                 {
  68                         CString dirtyList;
  69                         subgit.Run(L"git.exe status --porcelain", &dirtyList, encode);
  70                         dirty = !dirtyList.IsEmpty();
  71                 }
  72
  73                 CSubmoduleDiffDlg submoduleDiffDlg;
  74                 if (pPath->m_Action & CTGitPath::LOGACTIONS_DELETED)
  75                         submoduleDiffDlg.SetDiff(pPath->GetWinPath(), false, newhash, newsub, toOK, oldhash, oldsub, false, dirty, DeleteSubmodule);
  76                 else
  77                         submoduleDiffDlg.SetDiff(pPath->GetWinPath(), false, oldhash, oldsub, true, newhash, newsub, toOK, dirty, NewSubmodule);
  78                 submoduleDiffDlg.DoModal();
  79                 if (submoduleDiffDlg.IsRefresh())
  80                         return 1;
  81
  82                 return 0;
  83         }
  84
  85         if (rev1 != GIT_REV_ZERO)
  86                 CMessageBox::Show(nullptr, L"ls-tree output format error", L"TortoiseGit", MB_OK | MB_ICONERROR);
  87         else
  88                 CMessageBox::Show(nullptr, L"ls-files output format error", L"TortoiseGit", MB_OK | MB_ICONERROR);
  89         return -1;
  90 }
  91
  92 int CGitDiff::DiffNull(const CTGitPath *pPath, git_revnum_t rev1, bool bIsAdd, int jumpToLine, bool bAlternative)
  93 {
  94         if (rev1 != GIT_REV_ZERO)
  95         {
  96                 CGitHash rev1Hash;
  97                 if (g_Git.GetHash(rev1Hash, rev1)) // make sure we have a HASH here, otherwise filenames might be invalid
  98                 {
  99                         MessageBox(nullptr, g_Git.GetGitLastErr(L"Could not get hash of \"" + rev1 + L"\"."), L"TortoiseGit", MB_ICONERROR);
 100                         return -1;
 101                 }
 102                 rev1 = rev1Hash.ToString();
 103         }
 104         CString file1;
 105         CString nullfile;
 106         CString cmd;
 107
 108         if(pPath->IsDirectory())
 109         {
 110                 int result;
 111                 // refresh if result = 1
 112                 CTGitPath path = *pPath;
 113                 while ((result = SubmoduleDiffNull(&path, rev1)) == 1)
 114                         path.SetFromGit(pPath->GetGitPathString());
 115                 return result;
 116         }
 117
 118         if(rev1 != GIT_REV_ZERO )
 119         {
 120                 file1 = CTempFiles::Instance().GetTempFilePath(false, *pPath, rev1).GetWinPathString();
 121                 if (g_Git.GetOneFile(rev1, *pPath, file1))
 122                 {
 123                         CString out;
 124                         out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)pPath->GetGitPathString(), (LPCTSTR)rev1, (LPCTSTR)file1);
 125                         CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", MB_OK);
 126                         return -1;
 127                 }
 128                 ::SetFileAttributes(file1, FILE_ATTRIBUTE_READONLY);
 129         }
 130         else
 131                 file1 = g_Git.CombinePath(pPath);
 132
 133         CString tempfile = CTempFiles::Instance().GetTempFilePath(false, *pPath, rev1).GetWinPathString();
 134         ::SetFileAttributes(tempfile, FILE_ATTRIBUTE_READONLY);
 135
 136         CAppUtils::DiffFlags flags;
 137         flags.bAlternativeTool = bAlternative;
 138         if(bIsAdd)
 139                 CAppUtils::StartExtDiff(tempfile,file1,
 140                                                         pPath->GetGitPathString(),
 141                                                         pPath->GetGitPathString() + L':' + rev1.Left(g_Git.GetShortHASHLength()),
 142                                                         g_Git.CombinePath(pPath), g_Git.CombinePath(pPath),
 143                                                         git_revnum_t(GIT_REV_ZERO), rev1
 144                                                         , flags, jumpToLine);
 145         else
 146                 CAppUtils::StartExtDiff(file1,tempfile,
 147                                                         pPath->GetGitPathString() + L':' + rev1.Left(g_Git.GetShortHASHLength()),
 148                                                         pPath->GetGitPathString(),
 149                                                         g_Git.CombinePath(pPath), g_Git.CombinePath(pPath),
 150                                                         rev1, git_revnum_t(GIT_REV_ZERO)
 151                                                         , flags, jumpToLine);
 152
 153         return 0;
 154 }
 155
 156 int CGitDiff::SubmoduleDiff(const CTGitPath * pPath, const CTGitPath * /*pPath2*/, const git_revnum_t &rev1, const git_revnum_t &rev2, bool /*blame*/, bool /*unified*/)
 157 {
 158         CString oldhash;
 159         CString newhash;
 160         bool dirty = false;
 161         CString cmd;
 162         bool isWorkingCopy = false;
 163         if( rev2 == GIT_REV_ZERO || rev1 == GIT_REV_ZERO )
 164         {
 165                 oldhash = GIT_REV_ZERO;
 166                 newhash = GIT_REV_ZERO;
 167
 168                 CString rev;
 169                 if( rev2 != GIT_REV_ZERO )
 170                         rev = rev2;
 171                 if( rev1 != GIT_REV_ZERO )
 172                         rev = rev1;
 173
 174                 isWorkingCopy = true;
 175
 176                 cmd.Format(L"git.exe diff %s -- \"%s\"",
 177                 (LPCTSTR)rev, (LPCTSTR)pPath->GetGitPathString());
 178
 179                 CString output, err;
 180                 if (g_Git.Run(cmd, &output, &err, CP_UTF8))
 181                 {
 182                         CMessageBox::Show(nullptr, output + L'\n' + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
 183                         return -1;
 184                 }
 185
 186                 if (output.IsEmpty())
 187                 {
 188                         output.Empty();
 189                         err.Empty();
 190                         // also compare against index
 191                         cmd.Format(L"git.exe diff -- \"%s\"", (LPCTSTR)pPath->GetGitPathString());
 192                         if (g_Git.Run(cmd, &output, &err, CP_UTF8))
 193                         {
 194                                 CMessageBox::Show(nullptr, output + L'\n' + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
 195                                 return -1;
 196                         }
 197
 198                         if (output.IsEmpty())
 199                         {
 200                                 CMessageBox::Show(nullptr, IDS_ERR_EMPTYDIFF, IDS_APPNAME, MB_OK | MB_ICONERROR);
 201                                 return -1;
 202                         }
 203                         else if (CMessageBox::Show(nullptr, IDS_SUBMODULE_EMPTYDIFF, IDS_APPNAME, 1, IDI_QUESTION, IDS_MSGBOX_YES, IDS_MSGBOX_NO) == 1)
 204                         {
 205                                 CString sCmd;
 206                                 sCmd.Format(L"/command:subupdate /bkpath:\"%s\"", (LPCTSTR)g_Git.m_CurrentDir);
 207                                 CAppUtils::RunTortoiseGitProc(sCmd);
 208                         }
 209                         return -1;
 210                 }
 211
 212                 int start =0;
 213                 int oldstart = output.Find(L"-Subproject commit", start);
 214                 if(oldstart<0)
 215                 {
 216                         CMessageBox::Show(nullptr, L"Subproject Diff Format error", L"TortoiseGit", MB_OK | MB_ICONERROR);
 217                         return -1;
 218                 }
 219                 oldhash = output.Mid(oldstart + CString(L"-Subproject commit").GetLength() + 1, 40);
 220                 start = 0;
 221                 int newstart = output.Find(L"+Subproject commit",start);
 222                 if (newstart < 0)
 223                 {
 224                         CMessageBox::Show(nullptr, L"Subproject Diff Format error", L"TortoiseGit", MB_OK | MB_ICONERROR);
 225                         return -1;
 226                 }
 227                 newhash = output.Mid(newstart+ CString(L"+Subproject commit").GetLength() + 1, 40);
 228                 dirty = output.Mid(newstart + CString(L"+Subproject commit").GetLength() + 41) == L"-dirty\n";
 229         }
 230         else
 231         {
 232                 cmd.Format(L"git.exe diff-tree -r -z %s %s -- \"%s\"",
 233                 (LPCTSTR)rev2, (LPCTSTR)rev1, (LPCTSTR)pPath->GetGitPathString());
 234
 235                 BYTE_VECTOR bytes, errBytes;
 236                 if(g_Git.Run(cmd, &bytes, &errBytes))
 237                 {
 238                         CString err;
 239                         CGit::StringAppend(&err, &errBytes[0], CP_UTF8);
 240                         CMessageBox::Show(nullptr, err, L"TortoiseGit", MB_OK | MB_ICONERROR);
 241                         return -1;
 242                 }
 243
 244                 if (bytes.size() < 15 + 2 * GIT_HASH_SIZE + 1 + 2 * GIT_HASH_SIZE)
 245                 {
 246                         CMessageBox::Show(nullptr, L"git diff-tree gives invalid output", L"TortoiseGit", MB_OK | MB_ICONERROR);
 247                         return -1;
 248                 }
 249                 CGit::StringAppend(&oldhash, &bytes[15], CP_UTF8, 2 * GIT_HASH_SIZE);
 250                 CGit::StringAppend(&newhash, &bytes[15 + 2 * GIT_HASH_SIZE + 1], CP_UTF8, 2 * GIT_HASH_SIZE);
 251
 252         }
 253
 254         CString oldsub;
 255         CString newsub;
 256         bool oldOK = false, newOK = false;
 257
 258         CGit subgit;
 259         subgit.m_CurrentDir = g_Git.CombinePath(pPath);
 260         ChangeType changeType = Unknown;
 261
 262         if (pPath->HasAdminDir())
 263                 GetSubmoduleChangeType(subgit, oldhash, newhash, oldOK, newOK, changeType, oldsub, newsub);
 264
 265         CSubmoduleDiffDlg submoduleDiffDlg;
 266         submoduleDiffDlg.SetDiff(pPath->GetWinPath(), isWorkingCopy, oldhash, oldsub, oldOK, newhash, newsub, newOK, dirty, changeType);
 267         submoduleDiffDlg.DoModal();
 268         if (submoduleDiffDlg.IsRefresh())
 269                 return 1;
 270
 271         return 0;
 272 }
 273
 274 void CGitDiff::GetSubmoduleChangeType(CGit& subgit, const CString& oldhash, const CString& newhash, bool& oldOK, bool& newOK, ChangeType& changeType, CString& oldsub, CString& newsub)
 275 {
 276         CString cmd;
 277         int encode = CAppUtils::GetLogOutputEncode(&subgit);
 278         int oldTime = 0, newTime = 0;
 279
 280         if (oldhash != GIT_REV_ZERO)
 281         {
 282                 CString cmdout, cmderr;
 283                 cmd.Format(L"git.exe log -n1 --pretty=format:\"%%ct %%s\" %s --", (LPCTSTR)oldhash);
 284                 oldOK = !subgit.Run(cmd, &cmdout, &cmderr, encode);
 285                 if (oldOK)
 286                 {
 287                         int pos = cmdout.Find(L' ');
 288                         oldTime = _wtoi(cmdout.Left(pos));
 289                         oldsub = cmdout.Mid(pos + 1);
 290                 }
 291                 else
 292                         oldsub = cmderr;
 293         }
 294         if (newhash != GIT_REV_ZERO)
 295         {
 296                 CString cmdout, cmderr;
 297                 cmd.Format(L"git.exe log -n1 --pretty=format:\"%%ct %%s\" %s --", (LPCTSTR)newhash);
 298                 newOK = !subgit.Run(cmd, &cmdout, &cmderr, encode);
 299                 if (newOK)
 300                 {
 301                         int pos = cmdout.Find(L' ');
 302                         newTime = _wtoi(cmdout.Left(pos));
 303                         newsub = cmdout.Mid(pos + 1);
 304                 }
 305                 else
 306                         newsub = cmderr;
 307         }
 308
 309         if (oldhash == GIT_REV_ZERO)
 310         {
 311                 oldOK = true;
 312                 changeType = NewSubmodule;
 313         }
 314         else if (newhash == GIT_REV_ZERO)
 315         {
 316                 newOK = true;
 317                 changeType = DeleteSubmodule;
 318         }
 319         else if (oldhash != newhash)
 320         {
 321                 bool ffNewer = subgit.IsFastForward(oldhash, newhash);
 322                 if (!ffNewer)
 323                 {
 324                         bool ffOlder = subgit.IsFastForward(newhash, oldhash);
 325                         if (!ffOlder)
 326                         {
 327                                 if (newTime > oldTime)
 328                                         changeType = NewerTime;
 329                                 else if (newTime < oldTime)
 330                                         changeType = OlderTime;
 331                                 else
 332                                         changeType = SameTime;
 333                         }
 334                         else
 335                                 changeType = Rewind;
 336                 }
 337                 else
 338                         changeType = FastForward;
 339         }
 340         else if (oldhash == newhash)
 341                 changeType = Identical;
 342
 343         if (!oldOK || !newOK)
 344                 changeType = Unknown;
 345 }
 346
 347 int CGitDiff::Diff(const CTGitPath* pPath, const CTGitPath* pPath2, git_revnum_t rev1, git_revnum_t rev2, bool /*blame*/, bool /*unified*/, int jumpToLine, bool bAlternativeTool)
 348 {
 349         // make sure we have HASHes here, otherwise filenames might be invalid
 350         if (rev1 != GIT_REV_ZERO)
 351         {
 352                 CGitHash rev1Hash;
 353                 if (g_Git.GetHash(rev1Hash, rev1))
 354                 {
 355                         MessageBox(nullptr, g_Git.GetGitLastErr(L"Could not get hash of \"" + rev1 + L"\"."), L"TortoiseGit", MB_ICONERROR);
 356                         return -1;
 357                 }
 358                 rev1 = rev1Hash.ToString();
 359         }
 360         if (rev2 != GIT_REV_ZERO)
 361         {
 362                 CGitHash rev2Hash;
 363                 if (g_Git.GetHash(rev2Hash, rev2))
 364                 {
 365                         MessageBox(nullptr, g_Git.GetGitLastErr(L"Could not get hash of \"" + rev2 + L"\"."), L"TortoiseGit", MB_ICONERROR);
 366                         return -1;
 367                 }
 368                 rev2 = rev2Hash.ToString();
 369         }
 370
 371         CString file1;
 372         CString title1;
 373         CString cmd;
 374
 375         if(pPath->IsDirectory() || pPath2->IsDirectory())
 376         {
 377                 int result;
 378                 // refresh if result = 1
 379                 CTGitPath path = *pPath;
 380                 CTGitPath path2 = *pPath2;
 381                 while ((result = SubmoduleDiff(&path, &path2, rev1, rev2)) == 1)
 382                 {
 383                         path.SetFromGit(pPath->GetGitPathString());
 384                         path2.SetFromGit(pPath2->GetGitPathString());
 385                 }
 386                 return result;
 387         }
 388
 389         if(rev1 != GIT_REV_ZERO )
 390         {
 391                 // use original file extension, an external diff tool might need it
 392                 file1 = CTempFiles::Instance().GetTempFilePath(false, *pPath, rev1).GetWinPathString();
 393                 title1 = pPath->GetGitPathString() + L": " + rev1.Left(g_Git.GetShortHASHLength());
 394                 if (g_Git.GetOneFile(rev1, *pPath, file1))
 395                 {
 396                         CString out;
 397                         out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)pPath->GetGitPathString(), (LPCTSTR)rev1, (LPCTSTR)file1);
 398                         CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", MB_OK);
 399                         return -1;
 400                 }
 401                 ::SetFileAttributes(file1, FILE_ATTRIBUTE_READONLY);
 402         }
 403         else
 404         {
 405                 file1 = g_Git.CombinePath(pPath);
 406                 title1.Format(IDS_DIFF_WCNAME, (LPCTSTR)pPath->GetGitPathString());
 407                 if (!PathFileExists(file1))
 408                 {
 409                         CString sMsg;
 410                         sMsg.Format(IDS_PROC_DIFFERROR_FILENOTINWORKINGTREE, (LPCTSTR)file1);
 411                         if (MessageBox(nullptr, sMsg, L"TortoiseGit", MB_ICONEXCLAMATION | MB_YESNO) != IDYES)
 412                                 return 1;
 413                         if (!CCommonAppUtils::FileOpenSave(file1, nullptr, IDS_SELECTFILE, IDS_COMMONFILEFILTER, true))
 414                                 return 1;
 415                         title1 = file1;
 416                 }
 417         }
 418
 419         CString file2;
 420         CString title2;
 421         if(rev2 != GIT_REV_ZERO)
 422         {
 423                 CTGitPath fileName = *pPath2;
 424                 if (pPath2->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 425                         fileName = CTGitPath(pPath2->GetGitOldPathString());
 426
 427                 file2 = CTempFiles::Instance().GetTempFilePath(false, fileName, rev2).GetWinPathString();
 428                 title2 = fileName.GetGitPathString() + L": " + rev2.Left(g_Git.GetShortHASHLength());
 429                 if (g_Git.GetOneFile(rev2, fileName, file2))
 430                 {
 431                         CString out;
 432                         out.Format(IDS_STATUSLIST_CHECKOUTFILEFAILED, (LPCTSTR)pPath2->GetGitPathString(), (LPCTSTR)rev2, (LPCTSTR)file2);
 433                         CMessageBox::Show(nullptr, g_Git.GetGitLastErr(out, CGit::GIT_CMD_GETONEFILE), L"TortoiseGit", MB_OK);
 434                         return -1;
 435                 }
 436                 ::SetFileAttributes(file2, FILE_ATTRIBUTE_READONLY);
 437         }
 438         else
 439         {
 440                 file2 = g_Git.CombinePath(pPath2);
 441                 title2.Format(IDS_DIFF_WCNAME, pPath2->GetGitPathString());
 442         }
 443
 444         CAppUtils::DiffFlags flags;
 445         flags.bAlternativeTool = bAlternativeTool;
 446         CAppUtils::StartExtDiff(file2,file1,
 447                                                         title2,
 448                                                         title1,
 449                                                         g_Git.CombinePath(pPath2),
 450                                                         g_Git.CombinePath(pPath),
 451                                                         rev2,
 452                                                         rev1,
 453                                                         flags, jumpToLine);
 454
 455         return 0;
 456 }
 457
 458 int CGitDiff::DiffCommit(const CTGitPath& path, const GitRev* r1, const GitRev* r2, bool bAlternative)
 459 {
 460         return DiffCommit(path, path, r1, r2, bAlternative);
 461 }
 462
 463 int CGitDiff::DiffCommit(const CTGitPath& path1, const CTGitPath& path2, const GitRev* r1, const GitRev* r2, bool bAlternative)
 464 {
 465         if (path1.GetWinPathString().IsEmpty())
 466         {
 467                 CFileDiffDlg dlg;
 468                 dlg.SetDiff(nullptr, *r2, *r1);
 469                 dlg.DoModal();
 470         }
 471         else if (path1.IsDirectory())
 472         {
 473                 CFileDiffDlg dlg;
 474                 dlg.SetDiff(&path1, *r2, *r1);
 475                 dlg.DoModal();
 476         }
 477         else
 478                 Diff(&path1, &path2, r1->m_CommitHash.ToString(), r2->m_CommitHash.ToString(), false, false, 0, bAlternative);
 479         return 0;
 480 }
 481
 482 int CGitDiff::DiffCommit(const CTGitPath& path, const CString& r1, const CString& r2, bool bAlternative)
 483 {
 484         return DiffCommit(path, path, r1, r2, bAlternative);
 485 }
 486
 487 int CGitDiff::DiffCommit(const CTGitPath& path1, const CTGitPath& path2, const CString& r1, const CString& r2, bool bAlternative)
 488 {
 489         if (path1.GetWinPathString().IsEmpty())
 490         {
 491                 CFileDiffDlg dlg;
 492                 dlg.SetDiff(nullptr, r2, r1);
 493                 dlg.DoModal();
 494         }
 495         else if (path1.IsDirectory())
 496         {
 497                 CFileDiffDlg dlg;
 498                 dlg.SetDiff(&path1, r2, r1);
 499                 dlg.DoModal();
 500         }
 501         else
 502                 Diff(&path1, &path2, r1, r2, false, false, 0, bAlternative);
 503         return 0;
 504 }