src/Git/TGitPath.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2015 - TortoiseGit
   4 // Copyright (C) 2003-2008 - TortoiseSVN
   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 "TGitPath.h"
  22 #include "UnicodeUtils.h"
  23 #include "GitAdminDir.h"
  24 #include "PathUtils.h"
  25 #include <regex>
  26 #include "Git.h"
  27 #include "../TortoiseShell/Globals.h"
  28 #include "StringUtils.h"
  29 #include "../Resources/LoglistCommonResource.h"
  30 #include <memory>
  31
  32 extern CGit g_Git;
  33
  34 CTGitPath::CTGitPath(void)
  35         : m_bDirectoryKnown(false)
  36         , m_bIsDirectory(false)
  37         , m_bURLKnown(false)
  38         , m_bHasAdminDirKnown(false)
  39         , m_bHasAdminDir(false)
  40         , m_bIsValidOnWindowsKnown(false)
  41         , m_bIsValidOnWindows(false)
  42         , m_bIsReadOnly(false)
  43         , m_bIsAdminDirKnown(false)
  44         , m_bIsAdminDir(false)
  45         , m_bExists(false)
  46         , m_bExistsKnown(false)
  47         , m_bLastWriteTimeKnown(0)
  48         , m_lastWriteTime(0)
  49         , m_customData(NULL)
  50         , m_bIsSpecialDirectoryKnown(false)
  51         , m_bIsSpecialDirectory(false)
  52         , m_bIsWCRootKnown(false)
  53         , m_bIsWCRoot(false)
  54         , m_fileSize(0)
  55         , m_Checked(false)
  56 {
  57         m_Action=0;
  58         m_ParentNo=0;
  59         m_Stage = 0;
  60 }
  61
  62 CTGitPath::~CTGitPath(void)
  63 {
  64 }
  65 // Create a TGitPath object from an unknown path type (same as using SetFromUnknown)
  66 CTGitPath::CTGitPath(const CString& sUnknownPath) :
  67           m_bDirectoryKnown(false)
  68         , m_bIsDirectory(false)
  69         , m_bURLKnown(false)
  70         , m_bHasAdminDirKnown(false)
  71         , m_bHasAdminDir(false)
  72         , m_bIsValidOnWindowsKnown(false)
  73         , m_bIsValidOnWindows(false)
  74         , m_bIsReadOnly(false)
  75         , m_bIsAdminDirKnown(false)
  76         , m_bIsAdminDir(false)
  77         , m_bExists(false)
  78         , m_bExistsKnown(false)
  79         , m_bLastWriteTimeKnown(0)
  80         , m_lastWriteTime(0)
  81         , m_customData(NULL)
  82         , m_bIsSpecialDirectoryKnown(false)
  83         , m_bIsSpecialDirectory(false)
  84         , m_bIsWCRootKnown(false)
  85         , m_bIsWCRoot(false)
  86         , m_fileSize(0)
  87         , m_Checked(false)
  88 {
  89         SetFromUnknown(sUnknownPath);
  90         m_Action=0;
  91         m_Stage=0;
  92         m_ParentNo=0;
  93 }
  94
  95 int CTGitPath::ParserAction(BYTE action)
  96 {
  97         //action=action.TrimLeft();
  98         //TCHAR c=action.GetAt(0);
  99         if(action == 'M')
 100                 m_Action|= LOGACTIONS_MODIFIED;
 101         if(action == 'R')
 102                 m_Action|= LOGACTIONS_REPLACED;
 103         if(action == 'A')
 104                 m_Action|= LOGACTIONS_ADDED;
 105         if(action == 'D')
 106                 m_Action|= LOGACTIONS_DELETED;
 107         if(action == 'U')
 108                 m_Action|= LOGACTIONS_UNMERGED;
 109         if(action == 'K')
 110                 m_Action|= LOGACTIONS_DELETED;
 111         if(action == 'C' )
 112                 m_Action|= LOGACTIONS_COPY;
 113         if(action == 'T')
 114                 m_Action|= LOGACTIONS_MODIFIED;
 115
 116         return m_Action;
 117 }
 118 void CTGitPath::SetFromGit(const char* pPath)
 119 {
 120         Reset();
 121         if (pPath == NULL)
 122                 return;
 123         int len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, NULL, 0);
 124         if (len)
 125         {
 126                 len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, m_sFwdslashPath.GetBuffer(len+1), len+1);
 127                 m_sFwdslashPath.ReleaseBuffer(len-1);
 128         }
 129         SanitizeRootPath(m_sFwdslashPath, true);
 130 }
 131
 132 void CTGitPath::SetFromGit(const char* pPath, bool bIsDirectory)
 133 {
 134         SetFromGit(pPath);
 135         m_bDirectoryKnown = true;
 136         m_bIsDirectory = bIsDirectory;
 137 }
 138
 139 void CTGitPath::SetFromGit(const TCHAR* pPath, bool bIsDirectory)
 140 {
 141         Reset();
 142         if (pPath)
 143         {
 144                 m_sFwdslashPath = pPath;
 145                 SanitizeRootPath(m_sFwdslashPath, true);
 146         }
 147         m_bDirectoryKnown = true;
 148         m_bIsDirectory = bIsDirectory;
 149 }
 150
 151 void CTGitPath::SetFromGit(const CString& sPath,CString *oldpath)
 152 {
 153         Reset();
 154         m_sFwdslashPath = sPath;
 155         SanitizeRootPath(m_sFwdslashPath, true);
 156         if(oldpath)
 157                 m_sOldFwdslashPath = *oldpath;
 158 }
 159
 160 void CTGitPath::SetFromWin(LPCTSTR pPath)
 161 {
 162         Reset();
 163         m_sBackslashPath = pPath;
 164         m_sBackslashPath.Replace(L"\\\\?\\", L"");
 165         SanitizeRootPath(m_sBackslashPath, false);
 166         ATLASSERT(m_sBackslashPath.Find('/')<0);
 167 }
 168 void CTGitPath::SetFromWin(const CString& sPath)
 169 {
 170         Reset();
 171         m_sBackslashPath = sPath;
 172         m_sBackslashPath.Replace(L"\\\\?\\", L"");
 173         SanitizeRootPath(m_sBackslashPath, false);
 174 }
 175 void CTGitPath::SetFromWin(LPCTSTR pPath, bool bIsDirectory)
 176 {
 177         Reset();
 178         m_sBackslashPath = pPath;
 179         m_bIsDirectory = bIsDirectory;
 180         m_bDirectoryKnown = true;
 181         SanitizeRootPath(m_sBackslashPath, false);
 182 }
 183 void CTGitPath::SetFromWin(const CString& sPath, bool bIsDirectory)
 184 {
 185         Reset();
 186         m_sBackslashPath = sPath;
 187         m_bIsDirectory = bIsDirectory;
 188         m_bDirectoryKnown = true;
 189         SanitizeRootPath(m_sBackslashPath, false);
 190 }
 191 void CTGitPath::SetFromUnknown(const CString& sPath)
 192 {
 193         Reset();
 194         // Just set whichever path we think is most likely to be used
 195 //      GitAdminDir admin;
 196 //      CString p;
 197 //      if(admin.HasAdminDir(sPath,&p))
 198 //              SetFwdslashPath(sPath.Right(sPath.GetLength()-p.GetLength()));
 199 //      else
 200                 SetFwdslashPath(sPath);
 201 }
 202
 203 LPCTSTR CTGitPath::GetWinPath() const
 204 {
 205         if(IsEmpty())
 206         {
 207                 return _T("");
 208         }
 209         if(m_sBackslashPath.IsEmpty())
 210         {
 211                 SetBackslashPath(m_sFwdslashPath);
 212         }
 213         return m_sBackslashPath;
 214 }
 215 // This is a temporary function, to be used during the migration to
 216 // the path class.  Ultimately, functions consuming paths should take a CTGitPath&, not a CString
 217 const CString& CTGitPath::GetWinPathString() const
 218 {
 219         if(m_sBackslashPath.IsEmpty())
 220         {
 221                 SetBackslashPath(m_sFwdslashPath);
 222         }
 223         return m_sBackslashPath;
 224 }
 225
 226 const CString& CTGitPath::GetGitPathString() const
 227 {
 228         if(m_sFwdslashPath.IsEmpty())
 229         {
 230                 SetFwdslashPath(m_sBackslashPath);
 231         }
 232         return m_sFwdslashPath;
 233 }
 234
 235 const CString &CTGitPath::GetGitOldPathString() const
 236 {
 237         return m_sOldFwdslashPath;
 238 }
 239
 240 const CString& CTGitPath::GetUIPathString() const
 241 {
 242         if (m_sUIPath.IsEmpty())
 243         {
 244                 m_sUIPath = GetWinPathString();
 245         }
 246         return m_sUIPath;
 247 }
 248
 249 void CTGitPath::SetFwdslashPath(const CString& sPath) const
 250 {
 251         CString path = sPath;
 252         path.Replace('\\', '/');
 253
 254         // We don't leave a trailing /
 255         path.TrimRight('/');
 256         path.Replace(L"//?/", L"");
 257
 258         SanitizeRootPath(path, true);
 259
 260         path.Replace(_T("file:////"), _T("file://"));
 261         m_sFwdslashPath = path;
 262
 263         m_sUTF8FwdslashPath.Empty();
 264 }
 265
 266 void CTGitPath::SetBackslashPath(const CString& sPath) const
 267 {
 268         CString path = sPath;
 269         path.Replace('/', '\\');
 270         path.TrimRight('\\');
 271         SanitizeRootPath(path, false);
 272         m_sBackslashPath = path;
 273 }
 274
 275 void CTGitPath::SetUTF8FwdslashPath(const CString& sPath) const
 276 {
 277         m_sUTF8FwdslashPath = CUnicodeUtils::GetUTF8(sPath);
 278 }
 279
 280 void CTGitPath::SanitizeRootPath(CString& sPath, bool bIsForwardPath) const
 281 {
 282         // Make sure to add the trailing slash to root paths such as 'C:'
 283         if (sPath.GetLength() == 2 && sPath[1] == ':')
 284         {
 285                 sPath += (bIsForwardPath) ? _T("/") : _T("\\");
 286         }
 287 }
 288
 289 bool CTGitPath::IsDirectory() const
 290 {
 291         if(!m_bDirectoryKnown)
 292         {
 293                 UpdateAttributes();
 294         }
 295         return m_bIsDirectory;
 296 }
 297
 298 bool CTGitPath::Exists() const
 299 {
 300         if (!m_bExistsKnown)
 301         {
 302                 UpdateAttributes();
 303         }
 304         return m_bExists;
 305 }
 306
 307 bool CTGitPath::Delete(bool bTrash) const
 308 {
 309         EnsureBackslashPathSet();
 310         ::SetFileAttributes(m_sBackslashPath, FILE_ATTRIBUTE_NORMAL);
 311         bool bRet = false;
 312         if (Exists())
 313         {
 314                 if ((bTrash)||(IsDirectory()))
 315                 {
 316                         std::unique_ptr<TCHAR[]> buf(new TCHAR[m_sBackslashPath.GetLength() + 2]);
 317                         _tcscpy_s(buf.get(), m_sBackslashPath.GetLength() + 2, m_sBackslashPath);
 318                         buf[m_sBackslashPath.GetLength()] = 0;
 319                         buf[m_sBackslashPath.GetLength()+1] = 0;
 320                         bRet = CTGitPathList::DeleteViaShell(buf.get(), bTrash);
 321                 }
 322                 else
 323                 {
 324                         bRet = !!::DeleteFile(m_sBackslashPath);
 325                 }
 326         }
 327         m_bExists = false;
 328         m_bExistsKnown = true;
 329         return bRet;
 330 }
 331
 332 __int64  CTGitPath::GetLastWriteTime() const
 333 {
 334         if(!m_bLastWriteTimeKnown)
 335         {
 336                 UpdateAttributes();
 337         }
 338         return m_lastWriteTime;
 339 }
 340
 341 __int64 CTGitPath::GetFileSize() const
 342 {
 343         if(!m_bDirectoryKnown)
 344         {
 345                 UpdateAttributes();
 346         }
 347         return m_fileSize;
 348 }
 349
 350 bool CTGitPath::IsReadOnly() const
 351 {
 352         if(!m_bLastWriteTimeKnown)
 353         {
 354                 UpdateAttributes();
 355         }
 356         return m_bIsReadOnly;
 357 }
 358
 359 void CTGitPath::UpdateAttributes() const
 360 {
 361         EnsureBackslashPathSet();
 362         WIN32_FILE_ATTRIBUTE_DATA attribs;
 363         if (m_sBackslashPath.GetLength() >= 248)
 364                 m_sLongBackslashPath = _T("\\\\?\\") + m_sBackslashPath;
 365         if(GetFileAttributesEx(m_sBackslashPath.GetLength() >= 248 ? m_sLongBackslashPath : m_sBackslashPath, GetFileExInfoStandard, &attribs))
 366         {
 367                 m_bIsDirectory = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 368                 // don't cast directly to an __int64:
 369                 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms724284%28v=vs.85%29.aspx
 370                 // "Do not cast a pointer to a FILETIME structure to either a ULARGE_INTEGER* or __int64* value
 371                 // because it can cause alignment faults on 64-bit Windows."
 372                 m_lastWriteTime = static_cast<__int64>(attribs.ftLastWriteTime.dwHighDateTime) << 32 | attribs.ftLastWriteTime.dwLowDateTime;
 373                 if (m_bIsDirectory)
 374                 {
 375                         m_fileSize = 0;
 376                 }
 377                 else
 378                 {
 379                         m_fileSize = ((INT64)( (DWORD)(attribs.nFileSizeLow) ) | ( (INT64)( (DWORD)(attribs.nFileSizeHigh) )<<32 ));
 380                 }
 381                 m_bIsReadOnly = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
 382                 m_bExists = true;
 383         }
 384         else
 385         {
 386                 m_bIsDirectory = false;
 387                 m_lastWriteTime = 0;
 388                 m_fileSize = 0;
 389                 DWORD err = GetLastError();
 390                 if ((err == ERROR_FILE_NOT_FOUND)||(err == ERROR_PATH_NOT_FOUND)||(err == ERROR_INVALID_NAME))
 391                 {
 392                         m_bExists = false;
 393                 }
 394                 else
 395                 {
 396                         m_bExists = true;
 397                         return;
 398                 }
 399         }
 400         m_bDirectoryKnown = true;
 401         m_bLastWriteTimeKnown = true;
 402         m_bExistsKnown = true;
 403 }
 404
 405 CTGitPath CTGitPath::GetSubPath(const CTGitPath &root)
 406 {
 407         CTGitPath path;
 408
 409         if(GetWinPathString().Left(root.GetWinPathString().GetLength()) == root.GetWinPathString())
 410         {
 411                 CString str=GetWinPathString();
 412                 path.SetFromWin(str.Right(str.GetLength()-root.GetWinPathString().GetLength()-1));
 413         }
 414         return path;
 415 }
 416
 417 void CTGitPath::EnsureBackslashPathSet() const
 418 {
 419         if(m_sBackslashPath.IsEmpty())
 420         {
 421                 SetBackslashPath(m_sFwdslashPath);
 422                 ATLASSERT(IsEmpty() || !m_sBackslashPath.IsEmpty());
 423         }
 424 }
 425 void CTGitPath::EnsureFwdslashPathSet() const
 426 {
 427         if(m_sFwdslashPath.IsEmpty())
 428         {
 429                 SetFwdslashPath(m_sBackslashPath);
 430                 ATLASSERT(IsEmpty() || !m_sFwdslashPath.IsEmpty());
 431         }
 432 }
 433
 434
 435 // Reset all the caches
 436 void CTGitPath::Reset()
 437 {
 438         m_bDirectoryKnown = false;
 439         m_bURLKnown = false;
 440         m_bLastWriteTimeKnown = false;
 441         m_bHasAdminDirKnown = false;
 442         m_bIsValidOnWindowsKnown = false;
 443         m_bIsAdminDirKnown = false;
 444         m_bExistsKnown = false;
 445         m_bIsSpecialDirectoryKnown = false;
 446         m_bIsSpecialDirectory = false;
 447
 448         m_sBackslashPath.Empty();
 449         m_sFwdslashPath.Empty();
 450         m_sUTF8FwdslashPath.Empty();
 451         this->m_Action=0;
 452         this->m_StatAdd=_T("");
 453         this->m_StatDel=_T("");
 454         m_ParentNo=0;
 455         ATLASSERT(IsEmpty());
 456 }
 457
 458 CTGitPath CTGitPath::GetDirectory() const
 459 {
 460         if ((IsDirectory())||(!Exists()))
 461         {
 462                 return *this;
 463         }
 464         return GetContainingDirectory();
 465 }
 466
 467 CTGitPath CTGitPath::GetContainingDirectory() const
 468 {
 469         EnsureBackslashPathSet();
 470
 471         CString sDirName = m_sBackslashPath.Left(m_sBackslashPath.ReverseFind('\\'));
 472         if(sDirName.GetLength() == 2 && sDirName[1] == ':')
 473         {
 474                 // This is a root directory, which needs a trailing slash
 475                 sDirName += '\\';
 476                 if(sDirName == m_sBackslashPath)
 477                 {
 478                         // We were clearly provided with a root path to start with - we should return nothing now
 479                         sDirName.Empty();
 480                 }
 481         }
 482         if(sDirName.GetLength() == 1 && sDirName[0] == '\\')
 483         {
 484                 // We have an UNC path and we already are the root
 485                 sDirName.Empty();
 486         }
 487         CTGitPath retVal;
 488         retVal.SetFromWin(sDirName);
 489         return retVal;
 490 }
 491
 492 CString CTGitPath::GetRootPathString() const
 493 {
 494         EnsureBackslashPathSet();
 495         CString workingPath = m_sBackslashPath;
 496         LPTSTR pPath = workingPath.GetBuffer(MAX_PATH);         // MAX_PATH ok here.
 497         ATLVERIFY(::PathStripToRoot(pPath));
 498         workingPath.ReleaseBuffer();
 499         return workingPath;
 500 }
 501
 502
 503 CString CTGitPath::GetFilename() const
 504 {
 505         //ATLASSERT(!IsDirectory());
 506         return GetFileOrDirectoryName();
 507 }
 508
 509 CString CTGitPath::GetFileOrDirectoryName() const
 510 {
 511         EnsureBackslashPathSet();
 512         return m_sBackslashPath.Mid(m_sBackslashPath.ReverseFind('\\')+1);
 513 }
 514
 515 CString CTGitPath::GetUIFileOrDirectoryName() const
 516 {
 517         GetUIPathString();
 518         return m_sUIPath.Mid(m_sUIPath.ReverseFind('\\')+1);
 519 }
 520
 521 CString CTGitPath::GetFileExtension() const
 522 {
 523         if(!IsDirectory())
 524         {
 525                 EnsureBackslashPathSet();
 526                 int dotPos = m_sBackslashPath.ReverseFind('.');
 527                 int slashPos = m_sBackslashPath.ReverseFind('\\');
 528                 if (dotPos > slashPos)
 529                         return m_sBackslashPath.Mid(dotPos);
 530         }
 531         return CString();
 532 }
 533 CString CTGitPath::GetBaseFilename() const
 534 {
 535         int dot;
 536         CString filename=GetFilename();
 537         dot = filename.ReverseFind(_T('.'));
 538         if(dot>0)
 539                 return filename.Left(dot);
 540         else
 541                 return filename;
 542 }
 543
 544 bool CTGitPath::ArePathStringsEqual(const CString& sP1, const CString& sP2)
 545 {
 546         int length = sP1.GetLength();
 547         if(length != sP2.GetLength())
 548         {
 549                 // Different lengths
 550                 return false;
 551         }
 552         // We work from the end of the strings, because path differences
 553         // are more likely to occur at the far end of a string
 554         LPCTSTR pP1Start = sP1;
 555         LPCTSTR pP1 = pP1Start+(length-1);
 556         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);
 557         while(length-- > 0)
 558         {
 559                 if(_totlower(*pP1--) != _totlower(*pP2--))
 560                 {
 561                         return false;
 562                 }
 563         }
 564         return true;
 565 }
 566
 567 bool CTGitPath::ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2)
 568 {
 569         int length = sP1.GetLength();
 570         if(length != sP2.GetLength())
 571         {
 572                 // Different lengths
 573                 return false;
 574         }
 575         // We work from the end of the strings, because path differences
 576         // are more likely to occur at the far end of a string
 577         LPCTSTR pP1Start = sP1;
 578         LPCTSTR pP1 = pP1Start+(length-1);
 579         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);
 580         while(length-- > 0)
 581         {
 582                 if((*pP1--) != (*pP2--))
 583                 {
 584                         return false;
 585                 }
 586         }
 587         return true;
 588 }
 589
 590 bool CTGitPath::IsEmpty() const
 591 {
 592         // Check the backward slash path first, since the chance that this
 593         // one is set is higher. In case of a 'false' return value it's a little
 594         // bit faster.
 595         return m_sBackslashPath.IsEmpty() && m_sFwdslashPath.IsEmpty();
 596 }
 597
 598 // Test if both paths refer to the same item
 599 // Ignores case and slash direction
 600 bool CTGitPath::IsEquivalentTo(const CTGitPath& rhs) const
 601 {
 602         // Try and find a slash direction which avoids having to convert
 603         // both filenames
 604         if(!m_sBackslashPath.IsEmpty())
 605         {
 606                 // *We've* got a \ path - make sure that the RHS also has a \ path
 607                 rhs.EnsureBackslashPathSet();
 608                 return ArePathStringsEqualWithCase(m_sBackslashPath, rhs.m_sBackslashPath);
 609         }
 610         else
 611         {
 612                 // Assume we've got a fwdslash path and make sure that the RHS has one
 613                 rhs.EnsureFwdslashPathSet();
 614                 return ArePathStringsEqualWithCase(m_sFwdslashPath, rhs.m_sFwdslashPath);
 615         }
 616 }
 617
 618 bool CTGitPath::IsEquivalentToWithoutCase(const CTGitPath& rhs) const
 619 {
 620         // Try and find a slash direction which avoids having to convert
 621         // both filenames
 622         if(!m_sBackslashPath.IsEmpty())
 623         {
 624                 // *We've* got a \ path - make sure that the RHS also has a \ path
 625                 rhs.EnsureBackslashPathSet();
 626                 return ArePathStringsEqual(m_sBackslashPath, rhs.m_sBackslashPath);
 627         }
 628         else
 629         {
 630                 // Assume we've got a fwdslash path and make sure that the RHS has one
 631                 rhs.EnsureFwdslashPathSet();
 632                 return ArePathStringsEqual(m_sFwdslashPath, rhs.m_sFwdslashPath);
 633         }
 634 }
 635
 636 bool CTGitPath::IsAncestorOf(const CTGitPath& possibleDescendant) const
 637 {
 638         possibleDescendant.EnsureBackslashPathSet();
 639         EnsureBackslashPathSet();
 640
 641         bool bPathStringsEqual = ArePathStringsEqual(m_sBackslashPath, possibleDescendant.m_sBackslashPath.Left(m_sBackslashPath.GetLength()));
 642         if (m_sBackslashPath.GetLength() >= possibleDescendant.GetWinPathString().GetLength())
 643         {
 644                 return bPathStringsEqual;
 645         }
 646
 647         return (bPathStringsEqual &&
 648                         ((possibleDescendant.m_sBackslashPath[m_sBackslashPath.GetLength()] == '\\')||
 649                         (m_sBackslashPath.GetLength()==3 && m_sBackslashPath[1]==':')));
 650 }
 651
 652 // Get a string representing the file path, optionally with a base
 653 // section stripped off the front.
 654 CString CTGitPath::GetDisplayString(const CTGitPath* pOptionalBasePath /* = NULL*/) const
 655 {
 656         EnsureFwdslashPathSet();
 657         if(pOptionalBasePath != NULL)
 658         {
 659                 // Find the length of the base-path without having to do an 'ensure' on it
 660                 int baseLength = max(pOptionalBasePath->m_sBackslashPath.GetLength(), pOptionalBasePath->m_sFwdslashPath.GetLength());
 661
 662                 // Now, chop that baseLength of the front of the path
 663                 return m_sFwdslashPath.Mid(baseLength).TrimLeft('/');
 664         }
 665         return m_sFwdslashPath;
 666 }
 667
 668 int CTGitPath::Compare(const CTGitPath& left, const CTGitPath& right)
 669 {
 670         left.EnsureBackslashPathSet();
 671         right.EnsureBackslashPathSet();
 672         return left.m_sBackslashPath.CompareNoCase(right.m_sBackslashPath);
 673 }
 674
 675 bool operator<(const CTGitPath& left, const CTGitPath& right)
 676 {
 677         return CTGitPath::Compare(left, right) < 0;
 678 }
 679
 680 bool CTGitPath::PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right)
 681 {
 682         return left.IsEquivalentTo(right);
 683 }
 684
 685 bool CTGitPath::PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right)
 686 {
 687         if (left.IsAdminDir() && right.IsAdminDir())
 688         {
 689                 CTGitPath l = left;
 690                 CTGitPath r = right;
 691                 do
 692                 {
 693                         l = l.GetContainingDirectory();
 694                 } while(l.HasAdminDir());
 695                 do
 696                 {
 697                         r = r.GetContainingDirectory();
 698                 } while(r.HasAdminDir());
 699                 return l.GetContainingDirectory().IsEquivalentTo(r.GetContainingDirectory());
 700         }
 701         return left.GetDirectory().IsEquivalentTo(right.GetDirectory());
 702 }
 703
 704 bool CTGitPath::CheckChild(const CTGitPath &parent, const CTGitPath& child)
 705 {
 706         return parent.IsAncestorOf(child);
 707 }
 708
 709 void CTGitPath::AppendRawString(const CString& sAppend)
 710 {
 711         EnsureFwdslashPathSet();
 712         CString strCopy = m_sFwdslashPath += sAppend;
 713         SetFromUnknown(strCopy);
 714 }
 715
 716 void CTGitPath::AppendPathString(const CString& sAppend)
 717 {
 718         EnsureBackslashPathSet();
 719         CString cleanAppend(sAppend);
 720         cleanAppend.Replace('/', '\\');
 721         cleanAppend.TrimLeft('\\');
 722         m_sBackslashPath.TrimRight('\\');
 723         CString strCopy = m_sBackslashPath + _T("\\") + cleanAppend;
 724         SetFromWin(strCopy);
 725 }
 726
 727 bool CTGitPath::IsWCRoot() const
 728 {
 729         if (m_bIsWCRootKnown)
 730                 return m_bIsWCRoot;
 731
 732         m_bIsWCRootKnown = true;
 733         m_bIsWCRoot = false;
 734
 735         CString topDirectory;
 736         if (!IsDirectory() || !HasAdminDir(&topDirectory))
 737         {
 738                 return m_bIsWCRoot;
 739         }
 740
 741         if (IsEquivalentToWithoutCase(topDirectory))
 742         {
 743                 m_bIsWCRoot = true;
 744         }
 745
 746         return m_bIsWCRoot;
 747 }
 748
 749 bool CTGitPath::HasAdminDir() const
 750 {
 751         if (m_bHasAdminDirKnown)
 752                 return m_bHasAdminDir;
 753
 754         EnsureBackslashPathSet();
 755         m_bHasAdminDir = GitAdminDir::HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
 756         m_bHasAdminDirKnown = true;
 757         return m_bHasAdminDir;
 758 }
 759
 760 bool CTGitPath::HasSubmodules() const
 761 {
 762         if (HasAdminDir())
 763         {
 764                 CString path = m_sProjectRoot;
 765                 path += _T("\\.gitmodules");
 766                 if( PathFileExists(path) )
 767                         return true;
 768         }
 769         return false;
 770 }
 771
 772 int CTGitPath::GetAdminDirMask() const
 773 {
 774         int status = 0;
 775         CString topdir;
 776         if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
 777         {
 778                 return status;
 779         }
 780
 781         // ITEMIS_INGIT will be revoked if necessary in TortoiseShell/ContextMenu.cpp
 782         status |= ITEMIS_INGIT|ITEMIS_INVERSIONEDFOLDER;
 783
 784         if (IsDirectory())
 785         {
 786                 status |= ITEMIS_FOLDERINGIT;
 787                 if (IsWCRoot())
 788                 {
 789                         status |= ITEMIS_WCROOT;
 790
 791                         CString topProjectDir;
 792                         if (GitAdminDir::HasAdminDir(GetWinPathString(), false, &topProjectDir))
 793                         {
 794                                 if (PathFileExists(topProjectDir + _T("\\.gitmodules")))
 795                                 {
 796                                         CAutoConfig config(true);
 797                                         git_config_add_file_ondisk(config, CGit::GetGitPathStringA(topProjectDir + _T("\\.gitmodules")), GIT_CONFIG_LEVEL_APP, FALSE);
 798                                         CString relativePath = GetWinPathString().Mid(topProjectDir.GetLength());
 799                                         relativePath.Replace(_T("\\"), _T("/"));
 800                                         relativePath.Trim(_T("/"));
 801                                         CStringA submodulePath = CUnicodeUtils::GetUTF8(relativePath);
 802                                         if (git_config_foreach_match(config, "submodule\\..*\\.path",
 803                                                 [](const git_config_entry *entry, void *data) { return entry->value == *(CStringA *)data ? GIT_EUSER : 0; }, &submodulePath) == GIT_EUSER)
 804                                                 status |= ITEMIS_SUBMODULE;
 805                                 }
 806                         }
 807                 }
 808         }
 809
 810         CString dotGitPath;
 811         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 812
 813         if (PathFileExists(dotGitPath + _T("BISECT_START")))
 814                 status |= ITEMIS_BISECT;
 815
 816         if (PathFileExists(dotGitPath + _T("MERGE_HEAD")))
 817                 status |= ITEMIS_MERGEACTIVE;
 818
 819         if (PathFileExists(dotGitPath + _T("refs\\stash")))
 820                 status |= ITEMIS_STASH;
 821
 822         if (PathFileExists(dotGitPath + _T("svn")))
 823                 status |= ITEMIS_GITSVN;
 824
 825         if (PathFileExists(topdir + _T("\\.gitmodules")))
 826                 status |= ITEMIS_SUBMODULECONTAINER;
 827
 828         return status;
 829 }
 830
 831 bool CTGitPath::HasStashDir() const
 832 {
 833         CString topdir;
 834         if(!GitAdminDir::HasAdminDir(GetWinPathString(),&topdir))
 835         {
 836                 return false;
 837         }
 838
 839         CString dotGitPath;
 840         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 841
 842         return !!PathFileExists(dotGitPath + _T("\\refs\\stash"));
 843 }
 844 bool CTGitPath::HasGitSVNDir() const
 845 {
 846         CString topdir;
 847         if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
 848         {
 849                 return false;
 850         }
 851
 852         CString dotGitPath;
 853         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 854
 855         return !!PathFileExists(dotGitPath + _T("svn"));
 856 }
 857 bool CTGitPath::IsBisectActive() const
 858 {
 859         CString topdir;
 860         if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
 861         {
 862                 return false;
 863         }
 864
 865         CString dotGitPath;
 866         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 867
 868         return !!PathFileExists(dotGitPath + _T("BISECT_START"));
 869 }
 870 bool CTGitPath::IsMergeActive() const
 871 {
 872         CString topdir;
 873         if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
 874         {
 875                 return false;
 876         }
 877
 878         CString dotGitPath;
 879         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 880
 881         return !!PathFileExists(dotGitPath + _T("MERGE_HEAD"));
 882 }
 883 bool CTGitPath::HasRebaseApply() const
 884 {
 885         CString topdir;
 886         if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
 887         {
 888                 return false;
 889         }
 890
 891         CString dotGitPath;
 892         GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
 893
 894         return !!PathFileExists(dotGitPath + _T("rebase-apply"));
 895 }
 896
 897 bool CTGitPath::HasAdminDir(CString *ProjectTopDir) const
 898 {
 899         if (m_bHasAdminDirKnown)
 900         {
 901                 if (ProjectTopDir)
 902                         *ProjectTopDir = m_sProjectRoot;
 903                 return m_bHasAdminDir;
 904         }
 905
 906         EnsureBackslashPathSet();
 907         m_bHasAdminDir = GitAdminDir::HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
 908         m_bHasAdminDirKnown = true;
 909         if (ProjectTopDir)
 910                 *ProjectTopDir = m_sProjectRoot;
 911         return m_bHasAdminDir;
 912 }
 913
 914 bool CTGitPath::IsAdminDir() const
 915 {
 916         if (m_bIsAdminDirKnown)
 917                 return m_bIsAdminDir;
 918
 919         EnsureBackslashPathSet();
 920         m_bIsAdminDir = GitAdminDir::IsAdminDirPath(m_sBackslashPath);
 921         m_bIsAdminDirKnown = true;
 922         return m_bIsAdminDir;
 923 }
 924
 925 bool CTGitPath::IsValidOnWindows() const
 926 {
 927         if (m_bIsValidOnWindowsKnown)
 928                 return m_bIsValidOnWindows;
 929
 930         m_bIsValidOnWindows = false;
 931         EnsureBackslashPathSet();
 932         CString sMatch = m_sBackslashPath + _T("\r\n");
 933         std::wstring sPattern;
 934         // the 'file://' URL is just a normal windows path:
 935         if (sMatch.Left(7).CompareNoCase(_T("file:\\\\"))==0)
 936         {
 937                 sMatch = sMatch.Mid(7);
 938                 sMatch.TrimLeft(_T("\\"));
 939                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
 940         }
 941         else
 942         {
 943                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
 944         }
 945
 946         try
 947         {
 948                 std::tr1::wregex rx(sPattern, std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
 949                 std::tr1::wsmatch match;
 950
 951                 std::wstring rmatch = std::wstring((LPCTSTR)sMatch);
 952                 if (std::tr1::regex_match(rmatch, match, rx))
 953                 {
 954                         if (std::wstring(match[0]).compare(sMatch)==0)
 955                                 m_bIsValidOnWindows = true;
 956                 }
 957                 if (m_bIsValidOnWindows)
 958                 {
 959                         // now check for illegal filenames
 960                         std::tr1::wregex rx2(_T("\\\\(lpt\\d|com\\d|aux|nul|prn|con)(\\\\|$)"), std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
 961                         rmatch = m_sBackslashPath;
 962                         if (std::tr1::regex_search(rmatch, rx2, std::tr1::regex_constants::match_default))
 963                                 m_bIsValidOnWindows = false;
 964                 }
 965         }
 966         catch (std::exception) {}
 967
 968         m_bIsValidOnWindowsKnown = true;
 969         return m_bIsValidOnWindows;
 970 }
 971
 972 //////////////////////////////////////////////////////////////////////////
 973
 974 CTGitPathList::CTGitPathList()
 975 {
 976         m_Action = 0;
 977 }
 978
 979 // A constructor which allows a path list to be easily built which one initial entry in
 980 CTGitPathList::CTGitPathList(const CTGitPath& firstEntry)
 981 {
 982         m_Action = 0;
 983         AddPath(firstEntry);
 984 }
 985 int CTGitPathList::ParserFromLsFile(BYTE_VECTOR &out,bool /*staged*/)
 986 {
 987         int pos=0;
 988         CString one;
 989         CTGitPath path;
 990         CString part;
 991         this->Clear();
 992
 993         while (pos >= 0 && pos < (int)out.size())
 994         {
 995                 one.Empty();
 996                 path.Reset();
 997
 998                 CGit::StringAppend(&one, &out[pos], CP_UTF8);
 999                 int tabstart=0;
1000                 // m_Action is never used and propably never worked (needs to be set after path.SetFromGit)
1001                 // also dropped LOGACTIONS_CACHE for 'H'
1002                 // path.m_Action=path.ParserAction(out[pos]);
1003                 one.Tokenize(_T("\t"),tabstart);
1004
1005                 if(tabstart>=0)
1006                         path.SetFromGit(one.Right(one.GetLength()-tabstart));
1007                 else
1008                         return -1;
1009
1010                 tabstart=0;
1011
1012                 part=one.Tokenize(_T(" "),tabstart); //Tag
1013                 if (tabstart < 0)
1014                         return -1;
1015
1016                 part=one.Tokenize(_T(" "),tabstart); //Mode
1017                 if (tabstart < 0)
1018                         return -1;
1019
1020                 part=one.Tokenize(_T(" "),tabstart); //Hash
1021                 if (tabstart < 0)
1022                         return -1;
1023
1024                 part=one.Tokenize(_T("\t"),tabstart); //Stage
1025                 if (tabstart < 0)
1026                         return -1;
1027
1028                 path.m_Stage=_ttol(part);
1029
1030                 this->AddPath(path);
1031
1032                 pos=out.findNextString(pos);
1033         }
1034         return 0;
1035 }
1036 int CTGitPathList::FillUnRev(unsigned int action, CTGitPathList *list, CString *err)
1037 {
1038         this->Clear();
1039         CTGitPath path;
1040
1041         int count;
1042         if(list==NULL)
1043                 count=1;
1044         else
1045                 count=list->GetCount();
1046         for (int i = 0; i < count; ++i)
1047         {
1048                 CString cmd;
1049                 int pos = 0;
1050
1051                 CString ignored;
1052                 if(action & CTGitPath::LOGACTIONS_IGNORE)
1053                         ignored= _T(" -i");
1054
1055                 if(list==NULL)
1056                 {
1057                         cmd=_T("git.exe ls-files --exclude-standard --full-name --others -z");
1058                         cmd+=ignored;
1059
1060                 }
1061                 else
1062                 {       cmd.Format(_T("git.exe ls-files --exclude-standard --full-name --others -z%s -- \"%s\""),
1063                                         ignored,
1064                                         (*list)[i].GetWinPathString());
1065                 }
1066
1067                 BYTE_VECTOR out, errb;
1068                 out.clear();
1069                 if (g_Git.Run(cmd, &out, &errb))
1070                 {
1071                         if (err != nullptr)
1072                                 CGit::StringAppend(err, &errb[0], CP_UTF8, (int)errb.size());
1073                         return -1;
1074                 }
1075
1076                 pos=0;
1077                 CString one;
1078                 while (pos >= 0 && pos < (int)out.size())
1079                 {
1080                         one.Empty();
1081                         CGit::StringAppend(&one, &out[pos], CP_UTF8);
1082                         if(!one.IsEmpty())
1083                         {
1084                                 //SetFromGit will clear all status
1085                                 path.SetFromGit(one);
1086                                 path.m_Action=action;
1087                                 AddPath(path);
1088                         }
1089                         pos=out.findNextString(pos);
1090                 }
1091
1092         }
1093         return 0;
1094 }
1095 int CTGitPathList::FillBasedOnIndexFlags(unsigned short flag, CTGitPathList* list /*nullptr*/)
1096 {
1097         Clear();
1098         CTGitPath path;
1099
1100         CAutoRepository repository(g_Git.GetGitRepository());
1101         if (!repository)
1102                 return -1;
1103
1104         CAutoIndex index;
1105         if (git_repository_index(index.GetPointer(), repository))
1106                 return -1;
1107
1108         int count;
1109         if (list == nullptr)
1110                 count = 1;
1111         else
1112                 count = list->GetCount();
1113         for (int j = 0; j < count; ++j)
1114         {
1115                 for (size_t i = 0, ecount = git_index_entrycount(index); i < ecount; ++i)
1116                 {
1117                         const git_index_entry *e = git_index_get_byindex(index, i);
1118
1119                         if (!e || !((e->flags | e->flags_extended) & flag) || !e->path)
1120                                 continue;
1121
1122                         CString one = CUnicodeUtils::GetUnicode(e->path);
1123
1124                         if (!(!list || (*list)[j].GetWinPathString().IsEmpty() || one == (*list)[j].GetGitPathString() || (PathIsDirectory(g_Git.CombinePath((*list)[j].GetWinPathString())) && one.Find((*list)[j].GetGitPathString() + _T("/")) == 0)))
1125                                 continue;
1126
1127                         //SetFromGit will clear all status
1128                         path.SetFromGit(one);
1129                         if ((e->flags | e->flags_extended) & GIT_IDXENTRY_SKIP_WORKTREE)
1130                                 path.m_Action = CTGitPath::LOGACTIONS_SKIPWORKTREE;
1131                         else if ((e->flags | e->flags_extended) & GIT_IDXENTRY_VALID)
1132                                 path.m_Action = CTGitPath::LOGACTIONS_ASSUMEVALID;
1133                         AddPath(path);
1134                 }
1135         }
1136         RemoveDuplicates();
1137         return 0;
1138 }
1139 int CTGitPathList::ParserFromLog(BYTE_VECTOR &log, bool parseDeletes /*false*/)
1140 {
1141         this->Clear();
1142         int pos=0;
1143         CTGitPath path;
1144         m_Action=0;
1145         while (pos >= 0 && pos < (int)log.size())
1146         {
1147                 path.Reset();
1148                 if(log[pos]=='\n')
1149                         ++pos;
1150
1151                 if(log[pos]==':')
1152                 {
1153                         bool merged=false;
1154                         if(log[pos+1] ==':')
1155                         {
1156                                 merged=true;
1157                         }
1158                         int end=log.find(0,pos);
1159                         int actionstart=-1;
1160                         int file1=-1,file2=-1;
1161                         if( end>0 )
1162                         {
1163                                 actionstart=log.find(' ',end-6);
1164                                 pos=actionstart;
1165                         }
1166                         if( actionstart>0 )
1167                         {
1168                                 ++actionstart;
1169
1170                                 file1 = log.find(0,actionstart);
1171                                 if( file1>=0 )
1172                                 {
1173                                         ++file1;
1174                                         pos=file1;
1175                                 }
1176                                 if( log[actionstart] == 'C' || log[actionstart] == 'R' )
1177                                 {
1178                                         file2=file1;
1179                                         file1 = log.find(0,file1);
1180                                         if(file1>=0 )
1181                                         {
1182                                                 ++file1;
1183                                                 pos=file1;
1184                                         }
1185
1186                                 }
1187                         }
1188
1189                         CString pathname1;
1190                         CString pathname2;
1191
1192                         if( file1>=0 )
1193                                 CGit::StringAppend(&pathname1, &log[file1], CP_UTF8);
1194                         if( file2>=0 )
1195                                 CGit::StringAppend(&pathname2, &log[file2], CP_UTF8);
1196
1197                         CTGitPath *GitPath=LookForGitPath(pathname1);
1198
1199                         if(GitPath)
1200                         {
1201                                 GitPath->ParserAction( log[actionstart] );
1202
1203                                 if(merged)
1204                                 {
1205                                         GitPath->m_Action |= CTGitPath::LOGACTIONS_MERGED;
1206                                         GitPath->m_Action &= ~CTGitPath::LOGACTIONS_FORWORD;
1207                                 }
1208                                 m_Action |=GitPath->m_Action;
1209
1210                         }
1211                         else
1212                         {
1213                                 int ac=path.ParserAction(log[actionstart] );
1214                                 ac |= merged?CTGitPath::LOGACTIONS_MERGED:0;
1215
1216                                 path.SetFromGit(pathname1,&pathname2);
1217                                 path.m_Action=ac;
1218                                         //action must be set after setfromgit. SetFromGit will clear all status.
1219                                 this->m_Action|=ac;
1220
1221                                 AddPath(path);
1222
1223                         }
1224
1225                 }
1226                 else
1227                 {
1228                         int tabstart=0;
1229                         path.Reset();
1230                         CString StatAdd;
1231                         CString StatDel;
1232                         CString file1;
1233                         CString file2;
1234
1235                         tabstart=log.find('\t',pos);
1236                         if(tabstart >=0)
1237                         {
1238                                 log[tabstart]=0;
1239                                 CGit::StringAppend(&StatAdd, &log[pos], CP_UTF8);
1240                                 pos=tabstart+1;
1241                         }
1242
1243                         tabstart=log.find('\t',pos);
1244                         if(tabstart >=0)
1245                         {
1246                                 log[tabstart]=0;
1247
1248                                 CGit::StringAppend(&StatDel, &log[pos], CP_UTF8);
1249                                 pos=tabstart+1;
1250                         }
1251
1252                         if(log[pos] == 0) //rename
1253                         {
1254                                 ++pos;
1255                                 CGit::StringAppend(&file2, &log[pos], CP_UTF8);
1256                                 int sec=log.find(0,pos);
1257                                 if(sec>=0)
1258                                 {
1259                                         ++sec;
1260                                         CGit::StringAppend(&file1, &log[sec], CP_UTF8);
1261                                 }
1262                                 pos=sec;
1263
1264                         }
1265                         else
1266                         {
1267                                 CGit::StringAppend(&file1, &log[pos], CP_UTF8);
1268                         }
1269                         path.SetFromGit(file1,&file2);
1270
1271                         CTGitPath *GitPath=LookForGitPath(path.GetGitPathString());
1272                         if(GitPath)
1273                         {
1274                                 GitPath->m_StatAdd=StatAdd;
1275                                 GitPath->m_StatDel=StatDel;
1276                         }
1277                         else
1278                         {
1279                                 //path.SetFromGit(pathname);
1280                                 if (parseDeletes)
1281                                 {
1282                                         path.m_StatAdd=_T("0");
1283                                         path.m_StatDel=_T("0");
1284                                         path.m_Action |= CTGitPath::LOGACTIONS_DELETED;
1285                                 }
1286                                 else
1287                                 {
1288                                         path.m_StatAdd=StatAdd;
1289                                         path.m_StatDel=StatDel;
1290                                         path.m_Action |= CTGitPath::LOGACTIONS_FORWORD;
1291                                 }
1292                                 AddPath(path);
1293                         }
1294
1295                 }
1296                 pos=log.findNextString(pos);
1297         }
1298         return pos;
1299 }
1300
1301 void CTGitPathList::AddPath(const CTGitPath& newPath)
1302 {
1303         m_paths.push_back(newPath);
1304         m_commonBaseDirectory.Reset();
1305 }
1306 int CTGitPathList::GetCount() const
1307 {
1308         return (int)m_paths.size();
1309 }
1310 bool CTGitPathList::IsEmpty() const
1311 {
1312         return m_paths.empty();
1313 }
1314 void CTGitPathList::Clear()
1315 {
1316         m_paths.clear();
1317         m_commonBaseDirectory.Reset();
1318 }
1319
1320 const CTGitPath& CTGitPathList::operator[](INT_PTR index) const
1321 {
1322         ATLASSERT(index >= 0 && index < (INT_PTR)m_paths.size());
1323         return m_paths[index];
1324 }
1325
1326 bool CTGitPathList::AreAllPathsFiles() const
1327 {
1328         // Look through the vector for any directories - if we find them, return false
1329         return std::find_if(m_paths.begin(), m_paths.end(), std::mem_fun_ref(&CTGitPath::IsDirectory)) == m_paths.end();
1330 }
1331
1332
1333 #if defined(_MFC_VER)
1334
1335 bool CTGitPathList::LoadFromFile(const CTGitPath& filename)
1336 {
1337         Clear();
1338         try
1339         {
1340                 CString strLine;
1341                 CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);
1342
1343                 // for every selected file/folder
1344                 CTGitPath path;
1345                 while (file.ReadString(strLine))
1346                 {
1347                         path.SetFromUnknown(strLine);
1348                         AddPath(path);
1349                 }
1350                 file.Close();
1351         }
1352         catch (CFileException* pE)
1353         {
1354                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading target file list\n");
1355                 TCHAR error[10000] = {0};
1356                 pE->GetErrorMessage(error, 10000);
1357 //              CMessageBox::Show(NULL, error, _T("TortoiseGit"), MB_ICONERROR);
1358                 pE->Delete();
1359                 return false;
1360         }
1361         return true;
1362 }
1363
1364 bool CTGitPathList::WriteToFile(const CString& sFilename, bool bANSI /* = false */) const
1365 {
1366         try
1367         {
1368                 if (bANSI)
1369                 {
1370                         CStdioFile file(sFilename, CFile::typeText | CFile::modeReadWrite | CFile::modeCreate);
1371                         PathVector::const_iterator it;
1372                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1373                         {
1374                                 CStringA line = CStringA(it->GetGitPathString()) + '\n';
1375                                 file.Write(line, line.GetLength());
1376                         }
1377                         file.Close();
1378                 }
1379                 else
1380                 {
1381                         CStdioFile file(sFilename, CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);
1382                         PathVector::const_iterator it;
1383                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1384                         {
1385                                 file.WriteString(it->GetGitPathString()+_T("\n"));
1386                         }
1387                         file.Close();
1388                 }
1389         }
1390         catch (CFileException* pE)
1391         {
1392                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException in writing temp file\n");
1393                 pE->Delete();
1394                 return false;
1395         }
1396         return true;
1397 }
1398
1399
1400 void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString)
1401 {
1402         int pos = 0;
1403         CString temp;
1404         for(;;)
1405         {
1406                 temp = sPathString.Tokenize(_T("*"),pos);
1407                 if(temp.IsEmpty())
1408                 {
1409                         break;
1410                 }
1411                 AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));
1412         }
1413 }
1414
1415 CString CTGitPathList::CreateAsteriskSeparatedString() const
1416 {
1417         CString sRet;
1418         PathVector::const_iterator it;
1419         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1420         {
1421                 if (!sRet.IsEmpty())
1422                         sRet += _T("*");
1423                 sRet += it->GetWinPathString();
1424         }
1425         return sRet;
1426 }
1427 #endif // _MFC_VER
1428
1429 bool
1430 CTGitPathList::AreAllPathsFilesInOneDirectory() const
1431 {
1432         // Check if all the paths are files and in the same directory
1433         PathVector::const_iterator it;
1434         m_commonBaseDirectory.Reset();
1435         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1436         {
1437                 if(it->IsDirectory())
1438                 {
1439                         return false;
1440                 }
1441                 const CTGitPath& baseDirectory = it->GetDirectory();
1442                 if(m_commonBaseDirectory.IsEmpty())
1443                 {
1444                         m_commonBaseDirectory = baseDirectory;
1445                 }
1446                 else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1447                 {
1448                         // Different path
1449                         m_commonBaseDirectory.Reset();
1450                         return false;
1451                 }
1452         }
1453         return true;
1454 }
1455
1456 CTGitPath CTGitPathList::GetCommonDirectory() const
1457 {
1458         if (m_commonBaseDirectory.IsEmpty())
1459         {
1460                 PathVector::const_iterator it;
1461                 for(it = m_paths.begin(); it != m_paths.end(); ++it)
1462                 {
1463                         const CTGitPath& baseDirectory = it->GetDirectory();
1464                         if(m_commonBaseDirectory.IsEmpty())
1465                         {
1466                                 m_commonBaseDirectory = baseDirectory;
1467                         }
1468                         else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1469                         {
1470                                 // Different path
1471                                 m_commonBaseDirectory.Reset();
1472                                 break;
1473                         }
1474                 }
1475         }
1476         // since we only checked strings, not paths,
1477         // we have to make sure now that we really return a *path* here
1478         PathVector::const_iterator iter;
1479         for(iter = m_paths.begin(); iter != m_paths.end(); ++iter)
1480         {
1481                 if (!m_commonBaseDirectory.IsAncestorOf(*iter))
1482                 {
1483                         m_commonBaseDirectory = m_commonBaseDirectory.GetContainingDirectory();
1484                         break;
1485                 }
1486         }
1487         return m_commonBaseDirectory;
1488 }
1489
1490 CTGitPath CTGitPathList::GetCommonRoot() const
1491 {
1492         if (IsEmpty())
1493                 return CTGitPath();
1494
1495         if (GetCount() == 1)
1496                 return m_paths[0];
1497
1498         // first entry is common root for itself
1499         // (add trailing '\\' to detect partial matches of the last path element)
1500         CString root = m_paths[0].GetWinPathString() + _T('\\');
1501         int rootLength = root.GetLength();
1502
1503         // determine common path string prefix
1504         for (PathVector::const_iterator it = m_paths.begin() + 1; it != m_paths.end(); ++it)
1505         {
1506                 CString path = it->GetWinPathString() + _T('\\');
1507
1508                 int newLength = CStringUtils::GetMatchingLength(root, path);
1509                 if (newLength != rootLength)
1510                 {
1511                         root.Delete(newLength, rootLength);
1512                         rootLength = newLength;
1513                 }
1514         }
1515
1516         // remove the last (partial) path element
1517         if (rootLength > 0)
1518                 root.Delete(root.ReverseFind(_T('\\')), rootLength);
1519
1520         // done
1521         return CTGitPath(root);
1522 }
1523
1524 void CTGitPathList::SortByPathname(bool bReverse /*= false*/)
1525 {
1526         std::sort(m_paths.begin(), m_paths.end());
1527         if (bReverse)
1528                 std::reverse(m_paths.begin(), m_paths.end());
1529 }
1530
1531 void CTGitPathList::DeleteAllFiles(bool bTrash, bool bFilesOnly)
1532 {
1533         PathVector::const_iterator it;
1534         SortByPathname(true); // nested ones first
1535
1536         CString sPaths;
1537         for (it = m_paths.begin(); it != m_paths.end(); ++it)
1538         {
1539                 if ((it->Exists()) && ((it->IsDirectory() != bFilesOnly) || !bFilesOnly))
1540                 {
1541                         if (!it->IsDirectory())
1542                                 ::SetFileAttributes(it->GetWinPath(), FILE_ATTRIBUTE_NORMAL);
1543
1544                         sPaths += it->GetWinPath();
1545                         sPaths += '\0';
1546                 }
1547         }
1548         sPaths += '\0';
1549         sPaths += '\0';
1550         DeleteViaShell((LPCTSTR)sPaths, bTrash);
1551         Clear();
1552 }
1553
1554 bool CTGitPathList::DeleteViaShell(LPCTSTR path, bool bTrash)
1555 {
1556         SHFILEOPSTRUCT shop = {0};
1557         shop.wFunc = FO_DELETE;
1558         shop.pFrom = path;
1559         shop.fFlags = FOF_NOCONFIRMATION|FOF_NOERRORUI|FOF_SILENT|FOF_NO_CONNECTED_ELEMENTS;
1560         if (bTrash)
1561                 shop.fFlags |= FOF_ALLOWUNDO;
1562         const bool bRet = (SHFileOperation(&shop) == 0);
1563         return bRet;
1564 }
1565
1566 void CTGitPathList::RemoveDuplicates()
1567 {
1568         SortByPathname();
1569         // Remove the duplicates
1570         // (Unique moves them to the end of the vector, then erase chops them off)
1571         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::PredLeftEquivalentToRight), m_paths.end());
1572 }
1573
1574 void CTGitPathList::RemoveAdminPaths()
1575 {
1576         PathVector::iterator it;
1577         for(it = m_paths.begin(); it != m_paths.end(); )
1578         {
1579                 if (it->IsAdminDir())
1580                 {
1581                         m_paths.erase(it);
1582                         it = m_paths.begin();
1583                 }
1584                 else
1585                         ++it;
1586         }
1587 }
1588
1589 void CTGitPathList::RemovePath(const CTGitPath& path)
1590 {
1591         PathVector::iterator it;
1592         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1593         {
1594                 if (it->IsEquivalentTo(path))
1595                 {
1596                         m_paths.erase(it);
1597                         return;
1598                 }
1599         }
1600 }
1601
1602 void CTGitPathList::RemoveItem(CTGitPath & path)
1603 {
1604         PathVector::iterator it;
1605         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1606         {
1607                 if (it->GetGitPathString()==path.GetGitPathString())
1608                 {
1609                         m_paths.erase(it);
1610                         return;
1611                 }
1612         }
1613 }
1614 void CTGitPathList::RemoveChildren()
1615 {
1616         SortByPathname();
1617         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::CheckChild), m_paths.end());
1618 }
1619
1620 bool CTGitPathList::IsEqual(const CTGitPathList& list)
1621 {
1622         if (list.GetCount() != GetCount())
1623                 return false;
1624         for (int i=0; i<list.GetCount(); ++i)
1625         {
1626                 if (!list[i].IsEquivalentTo(m_paths[i]))
1627                         return false;
1628         }
1629         return true;
1630 }
1631
1632 CTGitPath * CTGitPathList::LookForGitPath(CString path)
1633 {
1634         int i=0;
1635         for (i = 0; i < this->GetCount(); ++i)
1636         {
1637                 if((*this)[i].GetGitPathString() == path )
1638                         return (CTGitPath*)&(*this)[i];
1639         }
1640         return NULL;
1641 }
1642 CString CTGitPath::GetActionName(int action)
1643 {
1644         if(action  & CTGitPath::LOGACTIONS_UNMERGED)
1645                 return MAKEINTRESOURCE(IDS_PATHACTIONS_CONFLICT);
1646         if(action  & CTGitPath::LOGACTIONS_ADDED)
1647                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ADD);
1648         if(action  & CTGitPath::LOGACTIONS_DELETED)
1649                 return MAKEINTRESOURCE(IDS_PATHACTIONS_DELETE);
1650         if(action  & CTGitPath::LOGACTIONS_MERGED )
1651                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MERGED);
1652
1653         if(action  & CTGitPath::LOGACTIONS_MODIFIED)
1654                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MODIFIED);
1655         if(action  & CTGitPath::LOGACTIONS_REPLACED)
1656                 return MAKEINTRESOURCE(IDS_PATHACTIONS_RENAME);
1657         if(action  & CTGitPath::LOGACTIONS_COPY)
1658                 return MAKEINTRESOURCE(IDS_PATHACTIONS_COPY);
1659
1660         if(action  & CTGitPath::LOGACTIONS_FORWORD )
1661                 return MAKEINTRESOURCE(IDS_PATHACTIONS_FORWARD);
1662
1663         if (action & CTGitPath::LOGACTIONS_ASSUMEVALID)
1664                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ASSUMEUNCHANGED);
1665         if (action & CTGitPath::LOGACTIONS_SKIPWORKTREE)
1666                 return MAKEINTRESOURCE(IDS_PATHACTIONS_SKIPWORKTREE);
1667
1668         return MAKEINTRESOURCE(IDS_PATHACTIONS_UNKNOWN);
1669 }
1670 CString CTGitPath::GetActionName()
1671 {
1672         return GetActionName(m_Action);
1673 }
1674
1675 int CTGitPathList::GetAction()
1676 {
1677         return m_Action;
1678 }
1679