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-2011 - 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
  28 CGitDiff::CGitDiff(void)
  29 {
  30 }
  31
  32 CGitDiff::~CGitDiff(void)
  33 {
  34 }
  35 int CGitDiff::Parser(git_revnum_t &rev)
  36 {
  37         if(rev == GIT_REV_ZERO)
  38                 return 0;
  39         if(rev.GetLength() > 40)
  40         {
  41                 CString cmd;
  42                 cmd.Format(_T("git.exe rev-parse %s"),rev);
  43                 CString output;
  44                 if (!g_Git.Run(cmd, &output, NULL, CP_UTF8))
  45                 {
  46                         //int start=output.Find(_T('\n'));
  47                         rev=output.Left(40);
  48                 }
  49         }
  50         return 0;
  51 }
  52
  53 int CGitDiff::SubmoduleDiffNull(CTGitPath *pPath, git_revnum_t &/*rev1*/)
  54 {
  55         CString oldhash = GIT_REV_ZERO;
  56         CString oldsub ;
  57         CString newsub;
  58         CString newhash;
  59         CString workingcopy;
  60
  61         CString cmd;
  62         cmd.Format(_T("git.exe ls-tree  HEAD -- \"%s\""), pPath->GetGitPathString());
  63         CString output, err;
  64         if(g_Git.Run(cmd, &output, &err, CP_ACP))
  65         {
  66                 CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
  67                 return -1;
  68         }
  69
  70         int start=0;
  71         start=output.Find(_T(' '),start);
  72         if(start>0)
  73         {
  74                 start=output.Find(_T(' '),start+1);
  75                 if(start>0)
  76                         newhash=output.Mid(start+1, 40);
  77
  78                 CGit subgit;
  79                 subgit.m_CurrentDir=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
  80                 int encode=CAppUtils::GetLogOutputEncode(&subgit);
  81
  82                 cmd.Format(_T("git.exe log -n1  --pretty=format:\"%%s\" %s"),newhash);
  83                 subgit.Run(cmd,&newsub,encode);
  84
  85                 CString msg;
  86                 msg.Format(_T("Submodule <b>%s</b> Change\r\n\r\n<b>From:</b> %s\r\n\t%s\r\n\r\n<b>To%s:</b>     %s\r\n\t\t%s"),
  87                                 pPath->GetWinPath(),
  88                                 oldhash,
  89                                 oldsub ,
  90                                 workingcopy,
  91                                 newhash,
  92                                 newsub);
  93                 CMessageBox::Show(NULL,msg,_T("TortoiseGit"),MB_OK);
  94                 return 0;
  95         }
  96
  97         CMessageBox::Show(NULL,_T("ls-tree output format error"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
  98         return -1;
  99 }
 100
 101 int CGitDiff::DiffNull(CTGitPath *pPath, git_revnum_t rev1,bool bIsAdd)
 102 {
 103         CString temppath;
 104         GetTempPath(temppath);
 105         Parser(rev1);
 106         CString file1;
 107         CString nullfile;
 108         CString cmd;
 109
 110         if(pPath->IsDirectory())
 111         {
 112                 git_revnum_t rev2;
 113                 return SubmoduleDiffNull(pPath,rev1);
 114         }
 115
 116         if(rev1 != GIT_REV_ZERO )
 117         {
 118                 TCHAR szTempName[MAX_PATH];
 119                 GetTempFileName(temppath, pPath->GetBaseFilename(), 0, szTempName);
 120                 CString temp(szTempName);
 121                 DeleteFile(szTempName);
 122                 CreateDirectory(szTempName, NULL);
 123                 file1.Format(_T("%s\\%s-%s%s"),
 124                                 temp,
 125                                 pPath->GetBaseFilename(),
 126                                 rev1.Left(6),
 127                                 pPath->GetFileExtension());
 128
 129                 g_Git.GetOneFile(rev1,*pPath,file1);
 130         }
 131         else
 132         {
 133                 file1=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 134         }
 135
 136         // preserve FileExtension, needed especially for diffing deleted images (detection on new filename extension)
 137         CString tempfile=::GetTempFile() + pPath->GetFileExtension();
 138         CStdioFile file(tempfile,CFile::modeReadWrite|CFile::modeCreate );
 139         //file.WriteString();
 140         file.Close();
 141         ::SetFileAttributes(tempfile, FILE_ATTRIBUTE_READONLY);
 142
 143         CAppUtils::DiffFlags flags;
 144
 145         if(bIsAdd)
 146                 CAppUtils::StartExtDiff(tempfile,file1,
 147                                                         pPath->GetGitPathString(),
 148                                                         pPath->GetGitPathString()+_T(":")+rev1.Left(6)
 149                                                         ,flags);
 150         else
 151                 CAppUtils::StartExtDiff(file1,tempfile,
 152                                                         pPath->GetGitPathString()+_T(":")+rev1.Left(6)
 153                                                         ,pPath->GetGitPathString(),flags);
 154
 155         return 0;
 156 }
 157
 158 int CGitDiff::SubmoduleDiff(CTGitPath * pPath,CTGitPath * /*pPath2*/, git_revnum_t rev1, git_revnum_t rev2, bool /*blame*/, bool /*unified*/)
 159 {
 160         CString oldhash;
 161         CString newhash;
 162         CString cmd;
 163         CString workingcopy;
 164
 165         if( rev2 == GIT_REV_ZERO || rev1 == GIT_REV_ZERO )
 166         {
 167                 oldhash = GIT_REV_ZERO;
 168                 newhash = GIT_REV_ZERO;
 169
 170                 CString rev;
 171                 if( rev2 != GIT_REV_ZERO )
 172                         rev = rev2;
 173                 if( rev1 != GIT_REV_ZERO )
 174                         rev = rev1;
 175
 176                 workingcopy = _T(" (Work Copy)");
 177
 178                 cmd.Format(_T("git.exe diff %s -- \"%s\""),
 179                 rev,pPath->GetGitPathString());
 180
 181                 CString output, err;
 182                 if (g_Git.Run(cmd, &output, &err, CP_ACP))
 183                 {
 184                         CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
 185                         return -1;
 186                 }
 187                 int start =0;
 188                 int oldstart = output.Find(_T("-Subproject commit"),start);
 189                 if(oldstart<0)
 190                 {
 191                         CMessageBox::Show(NULL,_T("Subproject Diff Format error") ,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 192                         return -1;
 193                 }
 194                 oldhash = output.Mid(oldstart+ CString(_T("-Subproject commit")).GetLength()+1,40);
 195                 start = 0;
 196                 int newstart = output.Find(_T("+Subproject commit"),start);
 197                 if(oldstart<0)
 198                 {
 199                         CMessageBox::Show(NULL,_T("Subproject Diff Format error") ,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 200                         return -1;
 201                 }
 202                 newhash = output.Mid(newstart+ CString(_T("+Subproject commit")).GetLength()+1,40);
 203
 204         }
 205         else
 206         {
 207                 cmd.Format(_T("git.exe diff-tree -r -z %s %s -- \"%s\""),
 208                 rev2,rev1,pPath->GetGitPathString());
 209
 210                 BYTE_VECTOR bytes, errBytes;
 211                 if(g_Git.Run(cmd, &bytes, &errBytes))
 212                 {
 213                         CString err;
 214                         g_Git.StringAppend(&err,&errBytes[0],CP_ACP);
 215                         CMessageBox::Show(NULL,err,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 216                         return -1;
 217                 }
 218
 219                 g_Git.StringAppend(&oldhash,&bytes[15],CP_ACP,40);
 220                 g_Git.StringAppend(&newhash,&bytes[15+41],CP_ACP,40);
 221
 222         }
 223
 224         CString oldsub;
 225         CString newsub;
 226
 227         CGit subgit;
 228         subgit.m_CurrentDir=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 229
 230         if(pPath->HasAdminDir())
 231         {
 232                 int encode=CAppUtils::GetLogOutputEncode(&subgit);
 233
 234                 if(oldhash != GIT_REV_ZERO)
 235                 {
 236                         cmd.Format(_T("git log -n1  --pretty=format:\"%%s\" %s"),oldhash);
 237                         subgit.Run(cmd,&oldsub,encode);
 238                 }
 239                 if(newsub != GIT_REV_ZERO)
 240                 {
 241                         cmd.Format(_T("git log -n1  --pretty=format:\"%%s\" %s"),newhash);
 242                         subgit.Run(cmd,&newsub,encode);
 243                 }
 244         }
 245         CString msg;
 246         msg.Format(_T("Submodule <b>%s</b> Change\r\n\r\n<b>From:</b> %s\r\n\t%s\r\n\r\n<b>To%s:</b>     %s\r\n\t\t%s"),
 247                                 pPath->GetWinPath(),
 248                                 oldhash,
 249                                 oldsub ,
 250                                 workingcopy,
 251                                 newhash,
 252                                 newsub);
 253         CMessageBox::Show(NULL,msg,_T("TortoiseGit"),MB_OK);
 254
 255         return 0;
 256 }
 257
 258 int CGitDiff::Diff(CTGitPath * pPath,CTGitPath * pPath2, git_revnum_t rev1, git_revnum_t rev2, bool /*blame*/, bool /*unified*/)
 259 {
 260         CString temppath;
 261         GetTempPath(temppath);
 262         Parser(rev1);
 263         Parser(rev2);
 264         CString file1;
 265         CString title1;
 266         CString cmd;
 267
 268         if(pPath->IsDirectory() || pPath2->IsDirectory())
 269         {
 270                 return SubmoduleDiff(pPath,pPath2,rev1,rev2);
 271         }
 272
 273         if(rev1 != GIT_REV_ZERO )
 274         {
 275                 TCHAR szTempName[MAX_PATH];
 276                 GetTempFileName(temppath, pPath->GetBaseFilename(), 0, szTempName);
 277                 CString temp(szTempName);
 278                 DeleteFile(szTempName);
 279                 CreateDirectory(szTempName, NULL);
 280                 // use original file extension, an external diff tool might need it
 281                 file1.Format(_T("%s\\%s-%s-right%s"),
 282                                 temp,
 283                                 pPath->GetBaseFilename(),
 284                                 rev1.Left(6),
 285                                 pPath->GetFileExtension());
 286                 title1 = pPath->GetFileOrDirectoryName()+_T(":")+rev1.Left(6);
 287                 g_Git.GetOneFile(rev1,*pPath,file1);
 288                 ::SetFileAttributes(file1, FILE_ATTRIBUTE_READONLY);
 289         }
 290         else
 291         {
 292                 file1=g_Git.m_CurrentDir+_T("\\")+pPath->GetWinPathString();
 293                 title1.Format( IDS_DIFF_WCNAME, pPath->GetFileOrDirectoryName() );
 294         }
 295
 296         CString file2;
 297         CString title2;
 298         if(rev2 != GIT_REV_ZERO)
 299         {
 300                 TCHAR szTempName[MAX_PATH];
 301                 GetTempFileName(temppath, pPath2->GetBaseFilename(), 0, szTempName);
 302                 CString temp(szTempName);
 303                 DeleteFile(szTempName);
 304                 CreateDirectory(szTempName, NULL);
 305                 CTGitPath fileName = *pPath2;
 306                 if (rev1 == GIT_REV_ZERO && pPath2->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 307                         fileName = CTGitPath(pPath2->GetGitOldPathString());
 308
 309                 // use original file extension, an external diff tool might need it
 310                 file2.Format(_T("%s\\%s-%s-left%s"),
 311                                 temp,
 312                                 fileName.GetBaseFilename(),
 313                                 rev2.Left(6),
 314                                 fileName.GetFileExtension());
 315                 title2 = fileName.GetFileOrDirectoryName() + _T(":") + rev2.Left(6);
 316                 g_Git.GetOneFile(rev2, fileName, file2);
 317                 ::SetFileAttributes(file2, FILE_ATTRIBUTE_READONLY);
 318         }
 319         else
 320         {
 321                 file2=g_Git.m_CurrentDir+_T("\\")+pPath2->GetWinPathString();
 322                 title2.Format( IDS_DIFF_WCNAME, pPath2->GetFileOrDirectoryName() );
 323         }
 324
 325         if (pPath->m_Action == pPath->LOGACTIONS_ADDED)
 326         {
 327                 CGitDiff::DiffNull(pPath, rev1, true);
 328         }
 329         else if (pPath->m_Action == pPath->LOGACTIONS_DELETED)
 330         {
 331                 CGitDiff::DiffNull(pPath, rev2, false);
 332         }
 333         else
 334         {
 335                 CAppUtils::DiffFlags flags;
 336                 CAppUtils::StartExtDiff(file2,file1,
 337                                                                 title2,
 338                                                                 title1
 339                                                                 ,flags);
 340         }
 341         return 0;
 342 }
 343
 344 int CGitDiff::DiffCommit(CTGitPath &path, GitRev *r1, GitRev *r2)
 345 {
 346         if (path.GetWinPathString().IsEmpty())
 347         {
 348                 CFileDiffDlg dlg;
 349                 dlg.SetDiff(NULL,*r1,*r2);
 350                 dlg.DoModal();
 351         }
 352         else if (path.IsDirectory())
 353         {
 354                 CFileDiffDlg dlg;
 355                 dlg.SetDiff(&path,*r1,*r2);
 356                 dlg.DoModal();
 357         }
 358         else
 359         {
 360                 Diff(&path,&path,r1->m_CommitHash.ToString(),r2->m_CommitHash.ToString());
 361         }
 362         return 0;
 363 }
 364
 365 int CGitDiff::DiffCommit(CTGitPath &path, CString r1, CString r2)
 366 {
 367         if (path.GetWinPathString().IsEmpty())
 368         {
 369                 CFileDiffDlg dlg;
 370                 dlg.SetDiff(NULL,r1,r2);
 371                 dlg.DoModal();
 372         }
 373         else if (path.IsDirectory())
 374         {
 375                 CFileDiffDlg dlg;
 376                 dlg.SetDiff(&path,r1,r2);
 377                 dlg.DoModal();
 378         }
 379         else
 380         {
 381                 Diff(&path,&path,r1,r2);
 382         }
 383         return 0;
 384 }