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-2012 - 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 #include "StdAfx.h"
  20 #include "GitDiff.h"
  21 #include "AppUtils.h"
  22 #include "git.h"
  23 #include "gittype.h"
  24 #include "resource.h"
  25 #include "MessageBox.h"
  26 #include "FileDiffDlg.h"
  27 #include "SubmoduleDiffDlg.h"
  28
  29 CGitDiff::CGitDiff(void)
  30 {
  31 }
  32
  33 CGitDiff::~CGitDiff(void)
  34 {
  35 }
  36 int CGitDiff::SubmoduleDiffNull(CTGitPath *pPath, git_revnum_t &rev1)
  37 {
  38         CString oldhash = GIT_REV_ZERO;
  39         CString oldsub ;
  40         CString newsub;
  41         CString newhash;
  42
  43         CString cmd;
  44         if (rev1 != GIT_REV_ZERO)
  45                 cmd.Format(_T("git.exe ls-tree \"%s\" -- \"%s\""), rev1, pPath->GetGitPathString());
  46         else
  47                 cmd.Format(_T("git.exe ls-files -s -- \"%s\""), pPath->GetGitPathString());
  48
  49         CString output, err;
  50         if (g_Git.Run(cmd, &output, &err, CP_UTF8))
  51         {
  52                 CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
  53                 return -1;
  54         }
  55
  56         int start=0;
  57         start=output.Find(_T(' '),start);
  58         if(start>0)
  59         {
  60                 if (rev1 != GIT_REV_ZERO) // in ls-files the hash is in the second column; in ls-tree it's in the third one
  61                         start = output.Find(_T(' '), start + 1);
  62                 if(start>0)
  63                         newhash=output.Mid(start+1, 40);
  64
  65                 CGit subgit;
  66                 subgit.m_CurrentDir=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
  67                 int encode=CAppUtils::GetLogOutputEncode(&subgit);
  68
  69                 cmd.Format(_T("git.exe log -n1  --pretty=format:\"%%s\" %s"),newhash);
  70                 bool toOK = !subgit.Run(cmd,&newsub,encode);
  71
  72                 bool dirty = false;
  73                 if (rev1 == GIT_REV_ZERO)
  74                 {
  75                         CString dirtyList;
  76                         subgit.Run(_T("git.exe status --porcelain"), &dirtyList, encode);
  77                         dirty = !dirtyList.IsEmpty();
  78                 }
  79
  80                 CSubmoduleDiffDlg submoduleDiffDlg;
  81                 submoduleDiffDlg.SetDiff(pPath->GetWinPath(), false, oldhash, oldsub, true, newhash, newsub, toOK, dirty, CSubmoduleDiffDlg::NewSubmodule);
  82                 submoduleDiffDlg.DoModal();
  83
  84                 return 0;
  85         }
  86
  87         if (rev1 != GIT_REV_ZERO)
  88                 CMessageBox::Show(NULL, _T("ls-tree output format error"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
  89         else
  90                 CMessageBox::Show(NULL, _T("ls-files output format error"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
  91         return -1;
  92 }
  93
  94 int CGitDiff::DiffNull(CTGitPath *pPath, git_revnum_t rev1,bool bIsAdd)
  95 {
  96         CString temppath;
  97         GetTempPath(temppath);
  98         rev1 = g_Git.GetHash(rev1); // make sure we have a HASH here, otherwise filenames might be invalid
  99         CString file1;
 100         CString nullfile;
 101         CString cmd;
 102
 103         if(pPath->IsDirectory())
 104         {
 105                 git_revnum_t rev2;
 106                 return SubmoduleDiffNull(pPath,rev1);
 107         }
 108
 109         if(rev1 != GIT_REV_ZERO )
 110         {
 111                 TCHAR szTempName[MAX_PATH];
 112                 GetTempFileName(temppath, pPath->GetBaseFilename(), 0, szTempName);
 113                 CString temp(szTempName);
 114                 DeleteFile(szTempName);
 115                 CreateDirectory(szTempName, NULL);
 116                 file1.Format(_T("%s\\%s-%s%s"),
 117                                 temp,
 118                                 pPath->GetBaseFilename(),
 119                                 rev1.Left(g_Git.GetShortHASHLength()),
 120                                 pPath->GetFileExtension());
 121
 122                 g_Git.GetOneFile(rev1,*pPath,file1);
 123         }
 124         else
 125         {
 126                 file1=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 127         }
 128
 129         // preserve FileExtension, needed especially for diffing deleted images (detection on new filename extension)
 130         CString tempfile=::GetTempFile() + pPath->GetFileExtension();
 131         CStdioFile file(tempfile,CFile::modeReadWrite|CFile::modeCreate );
 132         //file.WriteString();
 133         file.Close();
 134         ::SetFileAttributes(tempfile, FILE_ATTRIBUTE_READONLY);
 135
 136         CAppUtils::DiffFlags flags;
 137
 138         if(bIsAdd)
 139                 CAppUtils::StartExtDiff(tempfile,file1,
 140                                                         pPath->GetGitPathString(),
 141                                                         pPath->GetGitPathString() + _T(":") + rev1.Left(g_Git.GetShortHASHLength()),
 142                                                         g_Git.m_CurrentDir + _T("\\") + pPath->GetWinPathString(), g_Git.m_CurrentDir + _T("\\") + pPath->GetWinPathString(),
 143                                                         git_revnum_t(GIT_REV_ZERO), rev1
 144                                                         , flags);
 145         else
 146                 CAppUtils::StartExtDiff(file1,tempfile,
 147                                                         pPath->GetGitPathString() + _T(":") + rev1.Left(g_Git.GetShortHASHLength()),
 148                                                         pPath->GetGitPathString(),
 149                                                         g_Git.m_CurrentDir + _T("\\") + pPath->GetWinPathString(), g_Git.m_CurrentDir + _T("\\") + pPath->GetWinPathString(),
 150                                                         rev1, git_revnum_t(GIT_REV_ZERO)
 151                                                         , flags);
 152
 153         return 0;
 154 }
 155
 156 int CGitDiff::SubmoduleDiff(CTGitPath * pPath,CTGitPath * /*pPath2*/, git_revnum_t rev1, 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(_T("git.exe diff %s -- \"%s\""),
 177                 rev,pPath->GetGitPathString());
 178
 179                 CString output, err;
 180                 if (g_Git.Run(cmd, &output, &err, CP_UTF8))
 181                 {
 182                         CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
 183                         return -1;
 184                 }
 185                 int start =0;
 186                 int oldstart = output.Find(_T("-Subproject commit"),start);
 187                 if(oldstart<0)
 188                 {
 189                         CMessageBox::Show(NULL,_T("Subproject Diff Format error") ,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 190                         return -1;
 191                 }
 192                 oldhash = output.Mid(oldstart+ CString(_T("-Subproject commit")).GetLength()+1,40);
 193                 start = 0;
 194                 int newstart = output.Find(_T("+Subproject commit"),start);
 195                 if(oldstart<0)
 196                 {
 197                         CMessageBox::Show(NULL,_T("Subproject Diff Format error") ,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 198                         return -1;
 199                 }
 200                 newhash = output.Mid(newstart+ CString(_T("+Subproject commit")).GetLength()+1,40);
 201                 dirty = output.Mid(newstart + CString(_T("+Subproject commit")).GetLength() + 41) == _T("-dirty\n");
 202         }
 203         else
 204         {
 205                 cmd.Format(_T("git.exe diff-tree -r -z %s %s -- \"%s\""),
 206                 rev2,rev1,pPath->GetGitPathString());
 207
 208                 BYTE_VECTOR bytes, errBytes;
 209                 if(g_Git.Run(cmd, &bytes, &errBytes))
 210                 {
 211                         CString err;
 212                         g_Git.StringAppend(&err, &errBytes[0], CP_UTF8);
 213                         CMessageBox::Show(NULL,err,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 214                         return -1;
 215                 }
 216
 217                 g_Git.StringAppend(&oldhash, &bytes[15], CP_UTF8, 40);
 218                 g_Git.StringAppend(&newhash, &bytes[15+41], CP_UTF8, 40);
 219
 220         }
 221
 222         CString oldsub;
 223         CString newsub;
 224         bool oldOK = false, newOK = false;
 225
 226         CGit subgit;
 227         subgit.m_CurrentDir=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 228         CSubmoduleDiffDlg::ChangeType changeType = CSubmoduleDiffDlg::Unknown;
 229
 230         if(pPath->HasAdminDir())
 231         {
 232                 int encode=CAppUtils::GetLogOutputEncode(&subgit);
 233                 int oldTime = 0, newTime = 0;
 234
 235                 if(oldhash != GIT_REV_ZERO)
 236                 {
 237                         CString cmdout, cmderr;
 238                         cmd.Format(_T("git log -n1 --pretty=format:\"%%ct %%s\" %s"), oldhash);
 239                         oldOK = !subgit.Run(cmd, &cmdout, &cmderr, encode);
 240                         if (oldOK)
 241                         {
 242                                 int pos = cmdout.Find(_T(" "));
 243                                 oldTime = _ttoi(cmdout.Left(pos));
 244                                 oldsub = cmdout.Mid(pos + 1);
 245                         }
 246                         else
 247                                 oldsub = cmderr;
 248                 }
 249                 if (newhash != GIT_REV_ZERO)
 250                 {
 251                         CString cmdout, cmderr;
 252                         cmd.Format(_T("git log -n1 --pretty=format:\"%%ct %%s\" %s"), newhash);
 253                         newOK = !subgit.Run(cmd, &cmdout, &cmderr, encode);
 254                         if (newOK)
 255                         {
 256                                 int pos = cmdout.Find(_T(" "));
 257                                 newTime = _ttoi(cmdout.Left(pos));
 258                                 newsub = cmdout.Mid(pos + 1);
 259                         }
 260                         else
 261                                 newsub = cmderr;
 262                 }
 263
 264                 if (oldhash == GIT_REV_ZERO)
 265                 {
 266                         oldOK = true;
 267                         changeType = CSubmoduleDiffDlg::NewSubmodule;
 268                 }
 269                 else if (newhash == GIT_REV_ZERO)
 270                 {
 271                         newOK = true;
 272                         changeType = CSubmoduleDiffDlg::DeleteSubmodule;
 273                 }
 274                 else if (oldhash != newhash)
 275                 {
 276                         bool ffNewer = false, ffOlder = false;
 277                         ffNewer = subgit.IsFastForward(oldhash, newhash);
 278                         if (!ffNewer)
 279                         {
 280                                 ffOlder = subgit.IsFastForward(newhash, oldhash);
 281                                 if (!ffOlder)
 282                                 {
 283                                         if (newTime > oldTime)
 284                                                 changeType = CSubmoduleDiffDlg::NewerTime;
 285                                         else if (newTime < oldTime)
 286                                                 changeType = CSubmoduleDiffDlg::OlderTime;
 287                                         else
 288                                                 changeType = CSubmoduleDiffDlg::SameTime;
 289                                 }
 290                                 else
 291                                         changeType = CSubmoduleDiffDlg::Rewind;
 292                         }
 293                         else
 294                                 changeType = CSubmoduleDiffDlg::FastForward;
 295                 }
 296         }
 297
 298         CSubmoduleDiffDlg submoduleDiffDlg;
 299         submoduleDiffDlg.SetDiff(pPath->GetWinPath(), isWorkingCopy, oldhash, oldsub, oldOK, newhash, newsub, newOK, dirty, changeType);
 300         submoduleDiffDlg.DoModal();
 301
 302         return 0;
 303 }
 304
 305 int CGitDiff::Diff(CTGitPath * pPath,CTGitPath * pPath2, git_revnum_t rev1, git_revnum_t rev2, bool /*blame*/, bool /*unified*/)
 306 {
 307         CString temppath;
 308         GetTempPath(temppath);
 309
 310         // make sure we have HASHes here, otherwise filenames might be invalid
 311         rev1 = g_Git.GetHash(rev1);
 312         rev2 = g_Git.GetHash(rev2);
 313
 314         CString file1;
 315         CString title1;
 316         CString cmd;
 317
 318         if(pPath->IsDirectory() || pPath2->IsDirectory())
 319         {
 320                 return SubmoduleDiff(pPath,pPath2,rev1,rev2);
 321         }
 322
 323         if(rev1 != GIT_REV_ZERO )
 324         {
 325                 TCHAR szTempName[MAX_PATH];
 326                 GetTempFileName(temppath, pPath->GetBaseFilename(), 0, szTempName);
 327                 CString temp(szTempName);
 328                 DeleteFile(szTempName);
 329                 CreateDirectory(szTempName, NULL);
 330                 // use original file extension, an external diff tool might need it
 331                 file1.Format(_T("%s\\%s-%s-right%s"),
 332                                 temp,
 333                                 pPath->GetBaseFilename(),
 334                                 rev1.Left(g_Git.GetShortHASHLength()),
 335                                 pPath->GetFileExtension());
 336                 title1 = pPath->GetFileOrDirectoryName() + _T(":") + rev1.Left(g_Git.GetShortHASHLength());
 337                 g_Git.GetOneFile(rev1,*pPath,file1);
 338                 ::SetFileAttributes(file1, FILE_ATTRIBUTE_READONLY);
 339         }
 340         else
 341         {
 342                 file1=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 343                 title1.Format( IDS_DIFF_WCNAME, pPath->GetFileOrDirectoryName() );
 344                 if (!PathFileExists(file1))
 345                 {
 346                         CString sMsg;
 347                         sMsg.Format(IDS_PROC_DIFFERROR_FILENOTINWORKINGTREE, file1);
 348                         if (MessageBox(NULL, sMsg, _T("TortoiseGit"), MB_ICONEXCLAMATION | MB_OKCANCEL) == IDCANCEL)
 349                                 return 1;
 350                         if (!CCommonAppUtils::FileOpenSave(file1, NULL, IDS_DIFF_WCNAME, IDS_COMMONFILEFILTER, true))
 351                                 return 1;
 352                         title1.Format(IDS_DIFF_WCNAME, CTGitPath(file1).GetUIFileOrDirectoryName());
 353                 }
 354         }
 355
 356         CString file2;
 357         CString title2;
 358         if(rev2 != GIT_REV_ZERO)
 359         {
 360                 TCHAR szTempName[MAX_PATH];
 361                 GetTempFileName(temppath, pPath2->GetBaseFilename(), 0, szTempName);
 362                 CString temp(szTempName);
 363                 DeleteFile(szTempName);
 364                 CreateDirectory(szTempName, NULL);
 365                 CTGitPath fileName = *pPath2;
 366                 if (rev1 == GIT_REV_ZERO && pPath2->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 367                         fileName = CTGitPath(pPath2->GetGitOldPathString());
 368
 369                 // use original file extension, an external diff tool might need it
 370                 file2.Format(_T("%s\\%s-%s-left%s"),
 371                                 temp,
 372                                 fileName.GetBaseFilename(),
 373                                 rev2.Left(g_Git.GetShortHASHLength()),
 374                                 fileName.GetFileExtension());
 375                 title2 = fileName.GetFileOrDirectoryName() + _T(":") + rev2.Left(g_Git.GetShortHASHLength());
 376                 g_Git.GetOneFile(rev2, fileName, file2);
 377                 ::SetFileAttributes(file2, FILE_ATTRIBUTE_READONLY);
 378         }
 379         else
 380         {
 381                 file2=g_Git.m_CurrentDir+_T("\\")+pPath2->GetWinPathString();
 382                 title2.Format( IDS_DIFF_WCNAME, pPath2->GetFileOrDirectoryName() );
 383         }
 384
 385         if (pPath->m_Action == pPath->LOGACTIONS_ADDED)
 386         {
 387                 CGitDiff::DiffNull(pPath, rev1, true);
 388         }
 389         else if (pPath->m_Action == pPath->LOGACTIONS_DELETED)
 390         {
 391                 CGitDiff::DiffNull(pPath, rev2, false);
 392         }
 393         else
 394         {
 395                 CAppUtils::DiffFlags flags;
 396                 CAppUtils::StartExtDiff(file2,file1,
 397                                                                 title2,
 398                                                                 title1,
 399                                                                 g_Git.m_CurrentDir + _T("\\") + pPath2->GetWinPathString(),
 400                                                                 g_Git.m_CurrentDir + _T("\\") + pPath->GetWinPathString(),
 401                                                                 rev2,
 402                                                                 rev1,
 403                                                                 flags);
 404         }
 405         return 0;
 406 }
 407
 408 int CGitDiff::DiffCommit(CTGitPath &path, GitRev *r1, GitRev *r2)
 409 {
 410         return DiffCommit(path, path, r1, r2);
 411 }
 412
 413 int CGitDiff::DiffCommit(CTGitPath path1, CTGitPath path2, GitRev *r1, GitRev *r2)
 414 {
 415         if (path1.GetWinPathString().IsEmpty())
 416         {
 417                 CFileDiffDlg dlg;
 418                 dlg.SetDiff(NULL, *r1, *r2);
 419                 dlg.DoModal();
 420         }
 421         else if (path1.IsDirectory())
 422         {
 423                 CFileDiffDlg dlg;
 424                 dlg.SetDiff(&path1, *r1, *r2);
 425                 dlg.DoModal();
 426         }
 427         else
 428         {
 429                 Diff(&path1, &path2, r1->m_CommitHash.ToString(), r2->m_CommitHash.ToString());
 430         }
 431         return 0;
 432 }
 433
 434 int CGitDiff::DiffCommit(CTGitPath &path, CString r1, CString r2)
 435 {
 436         return DiffCommit(path, path, r1, r2);
 437 }
 438
 439
 440 int CGitDiff::DiffCommit(CTGitPath path1, CTGitPath path2, CString r1, CString r2)
 441 {
 442         if (path1.GetWinPathString().IsEmpty())
 443         {
 444                 CFileDiffDlg dlg;
 445                 dlg.SetDiff(NULL, r1, r2);
 446                 dlg.DoModal();
 447         }
 448         else if (path1.IsDirectory())
 449         {
 450                 CFileDiffDlg dlg;
 451                 dlg.SetDiff(&path1, r1, r2);
 452                 dlg.DoModal();
 453         }
 454         else
 455         {
 456                 Diff(&path1, &path2, r1, r2);
 457         }
 458         return 0;
 459 }