src/Git/TGitPath.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2014 - TortoiseGit
   4 // Copyright (C) 2010-2014 Sven Strickroth <email@cs-ware.de>
   5 // Copyright (C) 2003-2008 - TortoiseSVN
   6
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software Foundation,
  19 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 //
  21 #include "stdafx.h"
  22 #include "TGitPath.h"
  23 #include "UnicodeUtils.h"
  24 #include "GitAdminDir.h"
  25 #include "PathUtils.h"
  26 #include <regex>
  27 #include "Git.h"
  28 #include "Globals.h"
  29 #include "StringUtils.h"
  30 #include "../Resources/LoglistCommonResource.h"
  31 #include <memory>
  32
  33 #ifndef ASSERT
  34 #define ASSERT()
  35 #endif
  36 extern CGit g_Git;
  37
  38 CTGitPath::CTGitPath(void)
  39         : m_bDirectoryKnown(false)
  40         , m_bIsDirectory(false)
  41         , m_bURLKnown(false)
  42         , m_bHasAdminDirKnown(false)
  43         , m_bHasAdminDir(false)
  44         , m_bIsValidOnWindowsKnown(false)
  45         , m_bIsValidOnWindows(false)
  46         , m_bIsReadOnly(false)
  47         , m_bIsAdminDirKnown(false)
  48         , m_bIsAdminDir(false)
  49         , m_bExists(false)
  50         , m_bExistsKnown(false)
  51         , m_bLastWriteTimeKnown(0)
  52         , m_lastWriteTime(0)
  53         , m_customData(NULL)
  54         , m_bIsSpecialDirectoryKnown(false)
  55         , m_bIsSpecialDirectory(false)
  56         , m_bIsWCRootKnown(false)
  57         , m_bIsWCRoot(false)
  58         , m_fileSize(0)
  59         , m_Checked(false)
  60 {
  61         m_Action=0;
  62         m_ParentNo=0;
  63         m_Stage = 0;
  64 }
  65
  66 CTGitPath::~CTGitPath(void)
  67 {
  68 }
  69 // Create a TGitPath object from an unknown path type (same as using SetFromUnknown)
  70 CTGitPath::CTGitPath(const CString& sUnknownPath) :
  71           m_bDirectoryKnown(false)
  72         , m_bIsDirectory(false)
  73         , m_bURLKnown(false)
  74         , m_bHasAdminDirKnown(false)
  75         , m_bHasAdminDir(false)
  76         , m_bIsValidOnWindowsKnown(false)
  77         , m_bIsValidOnWindows(false)
  78         , m_bIsReadOnly(false)
  79         , m_bIsAdminDirKnown(false)
  80         , m_bIsAdminDir(false)
  81         , m_bExists(false)
  82         , m_bExistsKnown(false)
  83         , m_bLastWriteTimeKnown(0)
  84         , m_lastWriteTime(0)
  85         , m_customData(NULL)
  86         , m_bIsSpecialDirectoryKnown(false)
  87         , m_bIsSpecialDirectory(false)
  88         , m_bIsWCRootKnown(false)
  89         , m_bIsWCRoot(false)
  90         , m_fileSize(0)
  91         , m_Checked(false)
  92 {
  93         SetFromUnknown(sUnknownPath);
  94         m_Action=0;
  95         m_Stage=0;
  96         m_ParentNo=0;
  97 }
  98
  99 int CTGitPath::ParserAction(BYTE action)
 100 {
 101         //action=action.TrimLeft();
 102         //TCHAR c=action.GetAt(0);
 103         if(action == 'M')
 104                 m_Action|= LOGACTIONS_MODIFIED;
 105         if(action == 'R')
 106                 m_Action|= LOGACTIONS_REPLACED;
 107         if(action == 'A')
 108                 m_Action|= LOGACTIONS_ADDED;
 109         if(action == 'D')
 110                 m_Action|= LOGACTIONS_DELETED;
 111         if(action == 'U')
 112                 m_Action|= LOGACTIONS_UNMERGED;
 113         if(action == 'K')
 114                 m_Action|= LOGACTIONS_DELETED;
 115         if(action == 'H')
 116                 m_Action|= LOGACTIONS_CACHE;
 117         if(action == 'C' )
 118                 m_Action|= LOGACTIONS_COPY;
 119         if(action == 'T')
 120                 m_Action|= LOGACTIONS_MODIFIED;
 121
 122         return m_Action;
 123 }
 124 void CTGitPath::SetFromGit(const char* pPath)
 125 {
 126         Reset();
 127         if (pPath == NULL)
 128                 return;
 129         int len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, NULL, 0);
 130         if (len)
 131         {
 132                 len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, m_sFwdslashPath.GetBuffer(len+1), len+1);
 133                 m_sFwdslashPath.ReleaseBuffer(len-1);
 134         }
 135         SanitizeRootPath(m_sFwdslashPath, true);
 136 }
 137
 138 void CTGitPath::SetFromGit(const char* pPath, bool bIsDirectory)
 139 {
 140         SetFromGit(pPath);
 141         m_bDirectoryKnown = true;
 142         m_bIsDirectory = bIsDirectory;
 143 }
 144
 145 void CTGitPath::SetFromGit(const TCHAR* pPath, bool bIsDirectory)
 146 {
 147         Reset();
 148         if (pPath)
 149         {
 150                 m_sFwdslashPath = pPath;
 151                 SanitizeRootPath(m_sFwdslashPath, true);
 152         }
 153         m_bDirectoryKnown = true;
 154         m_bIsDirectory = bIsDirectory;
 155 }
 156
 157 void CTGitPath::SetFromGit(const CString& sPath,CString *oldpath)
 158 {
 159         Reset();
 160         m_sFwdslashPath = sPath;
 161         SanitizeRootPath(m_sFwdslashPath, true);
 162         if(oldpath)
 163                 m_sOldFwdslashPath = *oldpath;
 164 }
 165
 166 void CTGitPath::SetFromWin(LPCTSTR pPath)
 167 {
 168         Reset();
 169         m_sBackslashPath = pPath;
 170         m_sBackslashPath.Replace(L"\\\\?\\", L"");
 171         SanitizeRootPath(m_sBackslashPath, false);
 172         ATLASSERT(m_sBackslashPath.Find('/')<0);
 173 }
 174 void CTGitPath::SetFromWin(const CString& sPath)
 175 {
 176         Reset();
 177         m_sBackslashPath = sPath;
 178         m_sBackslashPath.Replace(L"\\\\?\\", L"");
 179         SanitizeRootPath(m_sBackslashPath, false);
 180 }
 181 void CTGitPath::SetFromWin(LPCTSTR pPath, bool bIsDirectory)
 182 {
 183         Reset();
 184         m_sBackslashPath = pPath;
 185         m_bIsDirectory = bIsDirectory;
 186         m_bDirectoryKnown = true;
 187         SanitizeRootPath(m_sBackslashPath, false);
 188 }
 189 void CTGitPath::SetFromWin(const CString& sPath, bool bIsDirectory)
 190 {
 191         Reset();
 192         m_sBackslashPath = sPath;
 193         m_bIsDirectory = bIsDirectory;
 194         m_bDirectoryKnown = true;
 195         SanitizeRootPath(m_sBackslashPath, false);
 196 }
 197 void CTGitPath::SetFromUnknown(const CString& sPath)
 198 {
 199         Reset();
 200         // Just set whichever path we think is most likely to be used
 201 //      GitAdminDir admin;
 202 //      CString p;
 203 //      if(admin.HasAdminDir(sPath,&p))
 204 //              SetFwdslashPath(sPath.Right(sPath.GetLength()-p.GetLength()));
 205 //      else
 206                 SetFwdslashPath(sPath);
 207 }
 208
 209 LPCTSTR CTGitPath::GetWinPath() const
 210 {
 211         if(IsEmpty())
 212         {
 213                 return _T("");
 214         }
 215         if(m_sBackslashPath.IsEmpty())
 216         {
 217                 SetBackslashPath(m_sFwdslashPath);
 218         }
 219         return m_sBackslashPath;
 220 }
 221 // This is a temporary function, to be used during the migration to
 222 // the path class.  Ultimately, functions consuming paths should take a CTGitPath&, not a CString
 223 const CString& CTGitPath::GetWinPathString() const
 224 {
 225         if(m_sBackslashPath.IsEmpty())
 226         {
 227                 SetBackslashPath(m_sFwdslashPath);
 228         }
 229         return m_sBackslashPath;
 230 }
 231
 232 const CString& CTGitPath::GetGitPathString() const
 233 {
 234         if(m_sFwdslashPath.IsEmpty())
 235         {
 236                 SetFwdslashPath(m_sBackslashPath);
 237         }
 238         return m_sFwdslashPath;
 239 }
 240
 241 const CString &CTGitPath::GetGitOldPathString() const
 242 {
 243         return m_sOldFwdslashPath;
 244 }
 245
 246 const CString& CTGitPath::GetUIPathString() const
 247 {
 248         if (m_sUIPath.IsEmpty())
 249         {
 250                 m_sUIPath = GetWinPathString();
 251         }
 252         return m_sUIPath;
 253 }
 254
 255 void CTGitPath::SetFwdslashPath(const CString& sPath) const
 256 {
 257         m_sFwdslashPath = sPath;
 258         m_sFwdslashPath.Replace('\\', '/');
 259
 260         // We don't leave a trailing /
 261         m_sFwdslashPath.TrimRight('/');
 262         m_sFwdslashPath.Replace(L"//?/", L"");
 263
 264         SanitizeRootPath(m_sFwdslashPath, true);
 265
 266         m_sFwdslashPath.Replace(_T("file:////"), _T("file://"));
 267
 268         m_sUTF8FwdslashPath.Empty();
 269 }
 270
 271 void CTGitPath::SetBackslashPath(const CString& sPath) const
 272 {
 273         m_sBackslashPath = sPath;
 274         m_sBackslashPath.Replace('/', '\\');
 275         m_sBackslashPath.TrimRight('\\');
 276         SanitizeRootPath(m_sBackslashPath, false);
 277 }
 278
 279 void CTGitPath::SetUTF8FwdslashPath(const CString& sPath) const
 280 {
 281         m_sUTF8FwdslashPath = CUnicodeUtils::GetUTF8(sPath);
 282 }
 283
 284 void CTGitPath::SanitizeRootPath(CString& sPath, bool bIsForwardPath) const
 285 {
 286         // Make sure to add the trailing slash to root paths such as 'C:'
 287         if (sPath.GetLength() == 2 && sPath[1] == ':')
 288         {
 289                 sPath += (bIsForwardPath) ? _T("/") : _T("\\");
 290         }
 291 }
 292
 293 bool CTGitPath::IsDirectory() const
 294 {
 295         if(!m_bDirectoryKnown)
 296         {
 297                 UpdateAttributes();
 298         }
 299         return m_bIsDirectory;
 300 }
 301
 302 bool CTGitPath::Exists() const
 303 {
 304         if (!m_bExistsKnown)
 305         {
 306                 UpdateAttributes();
 307         }
 308         return m_bExists;
 309 }
 310
 311 bool CTGitPath::Delete(bool bTrash) const
 312 {
 313         EnsureBackslashPathSet();
 314         ::SetFileAttributes(m_sBackslashPath, FILE_ATTRIBUTE_NORMAL);
 315         bool bRet = false;
 316         if (Exists())
 317         {
 318                 if ((bTrash)||(IsDirectory()))
 319                 {
 320                         std::unique_ptr<TCHAR[]> buf(new TCHAR[m_sBackslashPath.GetLength() + 2]);
 321                         _tcscpy_s(buf.get(), m_sBackslashPath.GetLength() + 2, m_sBackslashPath);
 322                         buf[m_sBackslashPath.GetLength()] = 0;
 323                         buf[m_sBackslashPath.GetLength()+1] = 0;
 324                         bRet = CTGitPathList::DeleteViaShell(buf.get(), bTrash);
 325                 }
 326                 else
 327                 {
 328                         bRet = !!::DeleteFile(m_sBackslashPath);
 329                 }
 330         }
 331         m_bExists = false;
 332         m_bExistsKnown = true;
 333         return bRet;
 334 }
 335
 336 __int64  CTGitPath::GetLastWriteTime() const
 337 {
 338         if(!m_bLastWriteTimeKnown)
 339         {
 340                 UpdateAttributes();
 341         }
 342         return m_lastWriteTime;
 343 }
 344
 345 __int64 CTGitPath::GetFileSize() const
 346 {
 347         if(!m_bDirectoryKnown)
 348         {
 349                 UpdateAttributes();
 350         }
 351         return m_fileSize;
 352 }
 353
 354 bool CTGitPath::IsReadOnly() const
 355 {
 356         if(!m_bLastWriteTimeKnown)
 357         {
 358                 UpdateAttributes();
 359         }
 360         return m_bIsReadOnly;
 361 }
 362
 363 void CTGitPath::UpdateAttributes() const
 364 {
 365         EnsureBackslashPathSet();
 366         WIN32_FILE_ATTRIBUTE_DATA attribs;
 367         if (m_sBackslashPath.GetLength() >= 248)
 368                 m_sLongBackslashPath = _T("\\\\?\\") + m_sBackslashPath;
 369         if(GetFileAttributesEx(m_sBackslashPath.GetLength() >= 248 ? m_sLongBackslashPath : m_sBackslashPath, GetFileExInfoStandard, &attribs))
 370         {
 371                 m_bIsDirectory = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 372                 m_lastWriteTime = *(__int64*)&attribs.ftLastWriteTime;
 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 = g_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(!g_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 (g_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         g_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(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 835         {
 836                 return false;
 837         }
 838
 839         CString dotGitPath;
 840         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 841
 842         return !!PathFileExists(dotGitPath + _T("\\refs\\stash"));
 843 }
 844 bool CTGitPath::HasGitSVNDir() const
 845 {
 846         CString topdir;
 847         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 848         {
 849                 return false;
 850         }
 851
 852         CString dotGitPath;
 853         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 854
 855         return !!PathFileExists(dotGitPath + _T("svn"));
 856 }
 857 bool CTGitPath::IsBisectActive() const
 858 {
 859         CString topdir;
 860         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 861         {
 862                 return false;
 863         }
 864
 865         CString dotGitPath;
 866         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 867
 868         return !!PathFileExists(dotGitPath + _T("BISECT_START"));
 869 }
 870 bool CTGitPath::IsMergeActive() const
 871 {
 872         CString topdir;
 873         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 874         {
 875                 return false;
 876         }
 877
 878         CString dotGitPath;
 879         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 880
 881         return !!PathFileExists(dotGitPath + _T("MERGE_HEAD"));
 882 }
 883 bool CTGitPath::HasRebaseApply() const
 884 {
 885         CString topdir;
 886         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 887         {
 888                 return false;
 889         }
 890
 891         CString dotGitPath;
 892         g_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 = g_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 = g_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         unsigned int pos=0;
 988         CString one;
 989         CTGitPath path;
 990         CString part;
 991         this->Clear();
 992
 993         while(pos>=0 && pos<out.size())
 994         {
 995                 one.Empty();
 996                 path.Reset();
 997
 998                 g_Git.StringAppend(&one, &out[pos], CP_UTF8);
 999                 int tabstart=0;
1000                 path.m_Action=path.ParserAction(out[pos]);
1001                 one.Tokenize(_T("\t"),tabstart);
1002
1003                 if(tabstart>=0)
1004                         path.SetFromGit(one.Right(one.GetLength()-tabstart));
1005                 else
1006                         return -1;
1007
1008                 tabstart=0;
1009
1010                 part=one.Tokenize(_T(" "),tabstart); //Tag
1011                 if (tabstart < 0)
1012                         return -1;
1013
1014                 part=one.Tokenize(_T(" "),tabstart); //Mode
1015                 if (tabstart < 0)
1016                         return -1;
1017
1018                 part=one.Tokenize(_T(" "),tabstart); //Hash
1019                 if (tabstart < 0)
1020                         return -1;
1021
1022                 part=one.Tokenize(_T("\t"),tabstart); //Stage
1023                 if (tabstart < 0)
1024                         return -1;
1025
1026                 path.m_Stage=_ttol(part);
1027
1028                 this->AddPath(path);
1029
1030                 pos=out.findNextString(pos);
1031         }
1032         return 0;
1033 }
1034 int CTGitPathList::FillUnRev(unsigned int action, CTGitPathList *list, CString *err)
1035 {
1036         this->Clear();
1037         CTGitPath path;
1038
1039         int count;
1040         if(list==NULL)
1041                 count=1;
1042         else
1043                 count=list->GetCount();
1044         for (int i = 0; i < count; ++i)
1045         {
1046                 CString cmd;
1047                 int pos = 0;
1048
1049                 CString ignored;
1050                 if(action & CTGitPath::LOGACTIONS_IGNORE)
1051                         ignored= _T(" -i");
1052
1053                 if(list==NULL)
1054                 {
1055                         cmd=_T("git.exe ls-files --exclude-standard --full-name --others -z");
1056                         cmd+=ignored;
1057
1058                 }
1059                 else
1060                 {       cmd.Format(_T("git.exe ls-files --exclude-standard --full-name --others -z%s -- \"%s\""),
1061                                         ignored,
1062                                         (*list)[i].GetWinPathString());
1063                 }
1064
1065                 BYTE_VECTOR out, errb;
1066                 out.clear();
1067                 if (g_Git.Run(cmd, &out, &errb))
1068                 {
1069                         if (err != nullptr)
1070                                 g_Git.StringAppend(err, &errb[0], CP_UTF8, (int)errb.size());
1071                         return -1;
1072                 }
1073
1074                 pos=0;
1075                 CString one;
1076                 while (pos >= 0 && pos < (int)out.size())
1077                 {
1078                         one.Empty();
1079                         g_Git.StringAppend(&one, &out[pos], CP_UTF8);
1080                         if(!one.IsEmpty())
1081                         {
1082                                 //SetFromGit will clear all status
1083                                 path.SetFromGit(one);
1084                                 path.m_Action=action;
1085                                 AddPath(path);
1086                         }
1087                         pos=out.findNextString(pos);
1088                 }
1089
1090         }
1091         return 0;
1092 }
1093 int CTGitPathList::FillBasedOnIndexFlags(unsigned short flag, CTGitPathList* list /*nullptr*/)
1094 {
1095         Clear();
1096         CTGitPath path;
1097         CString one;
1098
1099         CAutoRepository repository(g_Git.GetGitRepository());
1100         if (!repository)
1101                 return -1;
1102
1103         CAutoIndex index;
1104         if (git_repository_index(index.GetPointer(), repository))
1105                 return -1;
1106
1107         int count;
1108         if (list == nullptr)
1109                 count = 1;
1110         else
1111                 count = list->GetCount();
1112         for (int j = 0; j < count; ++j)
1113         {
1114                 for (size_t i = 0, ecount = git_index_entrycount(index); i < ecount; ++i)
1115                 {
1116                         const git_index_entry *e = git_index_get_byindex(index, i);
1117
1118                         if (!e || !((e->flags | e->flags_extended) & flag) || !e->path)
1119                                 continue;
1120
1121                         one.Empty();
1122                         g_Git.StringAppend(&one, (BYTE*)e->path, CP_UTF8);
1123
1124                         if (!(!list || (*list)[j].GetWinPathString().IsEmpty() || one == (*list)[j].GetGitPathString() || (PathIsDirectory(g_Git.m_CurrentDir + L"\\" + (*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         //BYTE *p=&log[0];
1144         //CString one;
1145         CTGitPath path;
1146         m_Action=0;
1147         while (pos >= 0 && pos < (int)log.size())
1148         {
1149                 //one=log.Tokenize(_T("\n"),pos);
1150                 path.Reset();
1151                 if(log[pos]=='\n')
1152                         ++pos;
1153
1154                 if(log[pos]==':')
1155                 {
1156                         bool merged=false;
1157                         if(log[pos+1] ==':')
1158                         {
1159                                 merged=true;
1160                         }
1161                         int end=log.find(0,pos);
1162                         int actionstart=-1;
1163                         int file1=-1,file2=-1;
1164                         if( end>0 )
1165                         {
1166                                 actionstart=log.find(' ',end-6);
1167                                 pos=actionstart;
1168                         }
1169                         if( actionstart>0 )
1170                         {
1171                                 ++actionstart;
1172
1173                                 file1 = log.find(0,actionstart);
1174                                 if( file1>=0 )
1175                                 {
1176                                         ++file1;
1177                                         pos=file1;
1178                                 }
1179                                 if( log[actionstart] == 'C' || log[actionstart] == 'R' )
1180                                 {
1181                                         file2=file1;
1182                                         file1 = log.find(0,file1);
1183                                         if(file1>=0 )
1184                                         {
1185                                                 ++file1;
1186                                                 pos=file1;
1187                                         }
1188
1189                                 }
1190                         }
1191
1192                         CString pathname1;
1193                         CString pathname2;
1194
1195                         if( file1>=0 )
1196                                 g_Git.StringAppend(&pathname1, &log[file1], CP_UTF8);
1197                         if( file2>=0 )
1198                                 g_Git.StringAppend(&pathname2, &log[file2], CP_UTF8);
1199
1200                         CTGitPath *GitPath=LookForGitPath(pathname1);
1201
1202                         if(GitPath)
1203                         {
1204                                 GitPath->ParserAction( log[actionstart] );
1205
1206                                 if(merged)
1207                                 {
1208                                         GitPath->m_Action |= CTGitPath::LOGACTIONS_MERGED;
1209                                         GitPath->m_Action &= ~CTGitPath::LOGACTIONS_FORWORD;
1210                                 }
1211                                 m_Action |=GitPath->m_Action;
1212
1213                         }
1214                         else
1215                         {
1216                                 int ac=path.ParserAction(log[actionstart] );
1217                                 ac |= merged?CTGitPath::LOGACTIONS_MERGED:0;
1218
1219                                 path.SetFromGit(pathname1,&pathname2);
1220                                 path.m_Action=ac;
1221                                         //action must be set after setfromgit. SetFromGit will clear all status.
1222                                 this->m_Action|=ac;
1223
1224                                 AddPath(path);
1225
1226                         }
1227
1228                 }
1229                 else
1230                 {
1231                         int tabstart=0;
1232                         path.Reset();
1233                         CString StatAdd;
1234                         CString StatDel;
1235                         CString file1;
1236                         CString file2;
1237
1238                         tabstart=log.find('\t',pos);
1239                         if(tabstart >=0)
1240                         {
1241                                 log[tabstart]=0;
1242                                 g_Git.StringAppend(&StatAdd,&log[pos],CP_UTF8);
1243                                 pos=tabstart+1;
1244                         }
1245
1246                         tabstart=log.find('\t',pos);
1247                         if(tabstart >=0)
1248                         {
1249                                 log[tabstart]=0;
1250
1251                                 g_Git.StringAppend(&StatDel,&log[pos],CP_UTF8);
1252                                 pos=tabstart+1;
1253                         }
1254
1255                         if(log[pos] == 0) //rename
1256                         {
1257                                 ++pos;
1258                                 g_Git.StringAppend(&file2, &log[pos], CP_UTF8);
1259                                 int sec=log.find(0,pos);
1260                                 if(sec>=0)
1261                                 {
1262                                         ++sec;
1263                                         g_Git.StringAppend(&file1, &log[sec], CP_UTF8);
1264                                 }
1265                                 pos=sec;
1266
1267                         }
1268                         else
1269                         {
1270                                 g_Git.StringAppend(&file1, &log[pos], CP_UTF8);
1271                         }
1272                         path.SetFromGit(file1,&file2);
1273
1274                         CTGitPath *GitPath=LookForGitPath(path.GetGitPathString());
1275                         if(GitPath)
1276                         {
1277                                 GitPath->m_StatAdd=StatAdd;
1278                                 GitPath->m_StatDel=StatDel;
1279                         }
1280                         else
1281                         {
1282                                 //path.SetFromGit(pathname);
1283                                 if (parseDeletes)
1284                                 {
1285                                         path.m_StatAdd=_T("0");
1286                                         path.m_StatDel=_T("0");
1287                                         path.m_Action |= CTGitPath::LOGACTIONS_DELETED;
1288                                 }
1289                                 else
1290                                 {
1291                                         path.m_StatAdd=StatAdd;
1292                                         path.m_StatDel=StatDel;
1293                                         path.m_Action |= CTGitPath::LOGACTIONS_FORWORD;
1294                                 }
1295                                 AddPath(path);
1296                         }
1297
1298                 }
1299                 pos=log.findNextString(pos);
1300         }
1301         return pos;
1302 }
1303
1304 void CTGitPathList::AddPath(const CTGitPath& newPath)
1305 {
1306         m_paths.push_back(newPath);
1307         m_commonBaseDirectory.Reset();
1308 }
1309 int CTGitPathList::GetCount() const
1310 {
1311         return (int)m_paths.size();
1312 }
1313 bool CTGitPathList::IsEmpty() const
1314 {
1315         return m_paths.empty();
1316 }
1317 void CTGitPathList::Clear()
1318 {
1319         m_paths.clear();
1320         m_commonBaseDirectory.Reset();
1321 }
1322
1323 const CTGitPath& CTGitPathList::operator[](INT_PTR index) const
1324 {
1325         ATLASSERT(index >= 0 && index < (INT_PTR)m_paths.size());
1326         return m_paths[index];
1327 }
1328
1329 bool CTGitPathList::AreAllPathsFiles() const
1330 {
1331         // Look through the vector for any directories - if we find them, return false
1332         return std::find_if(m_paths.begin(), m_paths.end(), std::mem_fun_ref(&CTGitPath::IsDirectory)) == m_paths.end();
1333 }
1334
1335
1336 #if defined(_MFC_VER)
1337
1338 bool CTGitPathList::LoadFromFile(const CTGitPath& filename)
1339 {
1340         Clear();
1341         try
1342         {
1343                 CString strLine;
1344                 CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);
1345
1346                 // for every selected file/folder
1347                 CTGitPath path;
1348                 while (file.ReadString(strLine))
1349                 {
1350                         path.SetFromUnknown(strLine);
1351                         AddPath(path);
1352                 }
1353                 file.Close();
1354         }
1355         catch (CFileException* pE)
1356         {
1357                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading target file list\n");
1358                 TCHAR error[10000] = {0};
1359                 pE->GetErrorMessage(error, 10000);
1360 //              CMessageBox::Show(NULL, error, _T("TortoiseGit"), MB_ICONERROR);
1361                 pE->Delete();
1362                 return false;
1363         }
1364         return true;
1365 }
1366
1367 bool CTGitPathList::WriteToFile(const CString& sFilename, bool bANSI /* = false */) const
1368 {
1369         try
1370         {
1371                 if (bANSI)
1372                 {
1373                         CStdioFile file(sFilename, CFile::typeText | CFile::modeReadWrite | CFile::modeCreate);
1374                         PathVector::const_iterator it;
1375                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1376                         {
1377                                 CStringA line = CStringA(it->GetGitPathString()) + '\n';
1378                                 file.Write(line, line.GetLength());
1379                         }
1380                         file.Close();
1381                 }
1382                 else
1383                 {
1384                         CStdioFile file(sFilename, CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);
1385                         PathVector::const_iterator it;
1386                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1387                         {
1388                                 file.WriteString(it->GetGitPathString()+_T("\n"));
1389                         }
1390                         file.Close();
1391                 }
1392         }
1393         catch (CFileException* pE)
1394         {
1395                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException in writing temp file\n");
1396                 pE->Delete();
1397                 return false;
1398         }
1399         return true;
1400 }
1401
1402
1403 void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString)
1404 {
1405         int pos = 0;
1406         CString temp;
1407         for(;;)
1408         {
1409                 temp = sPathString.Tokenize(_T("*"),pos);
1410                 if(temp.IsEmpty())
1411                 {
1412                         break;
1413                 }
1414                 AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));
1415         }
1416 }
1417
1418 CString CTGitPathList::CreateAsteriskSeparatedString() const
1419 {
1420         CString sRet;
1421         PathVector::const_iterator it;
1422         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1423         {
1424                 if (!sRet.IsEmpty())
1425                         sRet += _T("*");
1426                 sRet += it->GetWinPathString();
1427         }
1428         return sRet;
1429 }
1430 #endif // _MFC_VER
1431
1432 bool
1433 CTGitPathList::AreAllPathsFilesInOneDirectory() const
1434 {
1435         // Check if all the paths are files and in the same directory
1436         PathVector::const_iterator it;
1437         m_commonBaseDirectory.Reset();
1438         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1439         {
1440                 if(it->IsDirectory())
1441                 {
1442                         return false;
1443                 }
1444                 const CTGitPath& baseDirectory = it->GetDirectory();
1445                 if(m_commonBaseDirectory.IsEmpty())
1446                 {
1447                         m_commonBaseDirectory = baseDirectory;
1448                 }
1449                 else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1450                 {
1451                         // Different path
1452                         m_commonBaseDirectory.Reset();
1453                         return false;
1454                 }
1455         }
1456         return true;
1457 }
1458
1459 CTGitPath CTGitPathList::GetCommonDirectory() const
1460 {
1461         if (m_commonBaseDirectory.IsEmpty())
1462         {
1463                 PathVector::const_iterator it;
1464                 for(it = m_paths.begin(); it != m_paths.end(); ++it)
1465                 {
1466                         const CTGitPath& baseDirectory = it->GetDirectory();
1467                         if(m_commonBaseDirectory.IsEmpty())
1468                         {
1469                                 m_commonBaseDirectory = baseDirectory;
1470                         }
1471                         else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1472                         {
1473                                 // Different path
1474                                 m_commonBaseDirectory.Reset();
1475                                 break;
1476                         }
1477                 }
1478         }
1479         // since we only checked strings, not paths,
1480         // we have to make sure now that we really return a *path* here
1481         PathVector::const_iterator iter;
1482         for(iter = m_paths.begin(); iter != m_paths.end(); ++iter)
1483         {
1484                 if (!m_commonBaseDirectory.IsAncestorOf(*iter))
1485                 {
1486                         m_commonBaseDirectory = m_commonBaseDirectory.GetContainingDirectory();
1487                         break;
1488                 }
1489         }
1490         return m_commonBaseDirectory;
1491 }
1492
1493 CTGitPath CTGitPathList::GetCommonRoot() const
1494 {
1495         if (IsEmpty())
1496                 return CTGitPath();
1497
1498         if (GetCount() == 1)
1499                 return m_paths[0];
1500
1501         // first entry is common root for itself
1502         // (add trailing '\\' to detect partial matches of the last path element)
1503         CString root = m_paths[0].GetWinPathString() + _T('\\');
1504         int rootLength = root.GetLength();
1505
1506         // determine common path string prefix
1507         for (PathVector::const_iterator it = m_paths.begin() + 1; it != m_paths.end(); ++it)
1508         {
1509                 CString path = it->GetWinPathString() + _T('\\');
1510
1511                 int newLength = CStringUtils::GetMatchingLength(root, path);
1512                 if (newLength != rootLength)
1513                 {
1514                         root.Delete(newLength, rootLength);
1515                         rootLength = newLength;
1516                 }
1517         }
1518
1519         // remove the last (partial) path element
1520         if (rootLength > 0)
1521                 root.Delete(root.ReverseFind(_T('\\')), rootLength);
1522
1523         // done
1524         return CTGitPath(root);
1525 }
1526
1527 void CTGitPathList::SortByPathname(bool bReverse /*= false*/)
1528 {
1529         std::sort(m_paths.begin(), m_paths.end());
1530         if (bReverse)
1531                 std::reverse(m_paths.begin(), m_paths.end());
1532 }
1533
1534 void CTGitPathList::DeleteAllFiles(bool bTrash, bool bFilesOnly)
1535 {
1536         PathVector::const_iterator it;
1537         SortByPathname(true); // nested ones first
1538
1539         CString sPaths;
1540         for (it = m_paths.begin(); it != m_paths.end(); ++it)
1541         {
1542                 if ((it->Exists()) && ((it->IsDirectory() != bFilesOnly) || !bFilesOnly))
1543                 {
1544                         if (!it->IsDirectory())
1545                                 ::SetFileAttributes(it->GetWinPath(), FILE_ATTRIBUTE_NORMAL);
1546
1547                         sPaths += it->GetWinPath();
1548                         sPaths += '\0';
1549                 }
1550         }
1551         sPaths += '\0';
1552         sPaths += '\0';
1553         DeleteViaShell((LPCTSTR)sPaths, bTrash);
1554         Clear();
1555 }
1556
1557 bool CTGitPathList::DeleteViaShell(LPCTSTR path, bool bTrash)
1558 {
1559         SHFILEOPSTRUCT shop = {0};
1560         shop.wFunc = FO_DELETE;
1561         shop.pFrom = path;
1562         shop.fFlags = FOF_NOCONFIRMATION|FOF_NOERRORUI|FOF_SILENT|FOF_NO_CONNECTED_ELEMENTS;
1563         if (bTrash)
1564                 shop.fFlags |= FOF_ALLOWUNDO;
1565         const bool bRet = (SHFileOperation(&shop) == 0);
1566         return bRet;
1567 }
1568
1569 void CTGitPathList::RemoveDuplicates()
1570 {
1571         SortByPathname();
1572         // Remove the duplicates
1573         // (Unique moves them to the end of the vector, then erase chops them off)
1574         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::PredLeftEquivalentToRight), m_paths.end());
1575 }
1576
1577 void CTGitPathList::RemoveAdminPaths()
1578 {
1579         PathVector::iterator it;
1580         for(it = m_paths.begin(); it != m_paths.end(); )
1581         {
1582                 if (it->IsAdminDir())
1583                 {
1584                         m_paths.erase(it);
1585                         it = m_paths.begin();
1586                 }
1587                 else
1588                         ++it;
1589         }
1590 }
1591
1592 void CTGitPathList::RemovePath(const CTGitPath& path)
1593 {
1594         PathVector::iterator it;
1595         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1596         {
1597                 if (it->IsEquivalentTo(path))
1598                 {
1599                         m_paths.erase(it);
1600                         return;
1601                 }
1602         }
1603 }
1604
1605 void CTGitPathList::RemoveItem(CTGitPath & path)
1606 {
1607         PathVector::iterator it;
1608         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1609         {
1610                 if (it->GetGitPathString()==path.GetGitPathString())
1611                 {
1612                         m_paths.erase(it);
1613                         return;
1614                 }
1615         }
1616 }
1617 void CTGitPathList::RemoveChildren()
1618 {
1619         SortByPathname();
1620         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::CheckChild), m_paths.end());
1621 }
1622
1623 bool CTGitPathList::IsEqual(const CTGitPathList& list)
1624 {
1625         if (list.GetCount() != GetCount())
1626                 return false;
1627         for (int i=0; i<list.GetCount(); ++i)
1628         {
1629                 if (!list[i].IsEquivalentTo(m_paths[i]))
1630                         return false;
1631         }
1632         return true;
1633 }
1634
1635 #if 0
1636 #if defined(_DEBUG)
1637 // Some test cases for these classes
1638 static class CTGitPathTests
1639 {
1640 public:
1641         CTGitPathTests()
1642         {
1643                 GetDirectoryTest();
1644                 AdminDirTest();
1645                 SortTest();
1646                 RawAppendTest();
1647                 PathAppendTest();
1648                 RemoveDuplicatesTest();
1649                 RemoveChildrenTest();
1650                 ContainingDirectoryTest();
1651                 AncestorTest();
1652                 SubversionPathTest();
1653                 GetCommonRootTest();
1654 #if defined(_MFC_VER)
1655                 ValidPathAndUrlTest();
1656                 ListLoadingTest();
1657 #endif
1658         }
1659
1660 private:
1661         void GetDirectoryTest()
1662         {
1663                 // Bit tricky, this test, because we need to know something about the file
1664                 // layout on the machine which is running the test
1665                 TCHAR winDir[MAX_PATH+1] = {0};
1666                 GetWindowsDirectory(winDir, MAX_PATH);
1667                 CString sWinDir(winDir);
1668
1669                 CTGitPath testPath;
1670                 // This is a file which we know will always be there
1671                 testPath.SetFromUnknown(sWinDir + _T("\\win.ini"));
1672                 ATLASSERT(!testPath.IsDirectory());
1673                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);
1674                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() == sWinDir);
1675
1676                 // Now do the test on the win directory itself - It's hard to be sure about the containing directory
1677                 // but we know it must be different to the directory itself
1678                 testPath.SetFromUnknown(sWinDir);
1679                 ATLASSERT(testPath.IsDirectory());
1680                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);
1681                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() != sWinDir);
1682                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString().GetLength() < sWinDir.GetLength());
1683
1684                 // Try a root path
1685                 testPath.SetFromUnknown(_T("C:\\"));
1686                 ATLASSERT(testPath.IsDirectory());
1687                 ATLASSERT(testPath.GetDirectory().GetWinPathString().CompareNoCase(_T("C:\\"))==0);
1688                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());
1689                 // Try a root UNC path
1690                 testPath.SetFromUnknown(_T("\\MYSTATION"));
1691                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());
1692         }
1693
1694         void AdminDirTest()
1695         {
1696                 CTGitPath testPath;
1697                 testPath.SetFromUnknown(_T("c:\\.svndir"));
1698                 ATLASSERT(!testPath.IsAdminDir());
1699                 testPath.SetFromUnknown(_T("c:\\test.svn"));
1700                 ATLASSERT(!testPath.IsAdminDir());
1701                 testPath.SetFromUnknown(_T("c:\\.svn"));
1702                 ATLASSERT(testPath.IsAdminDir());
1703                 testPath.SetFromUnknown(_T("c:\\.svndir\\test"));
1704                 ATLASSERT(!testPath.IsAdminDir());
1705                 testPath.SetFromUnknown(_T("c:\\.svn\\test"));
1706                 ATLASSERT(testPath.IsAdminDir());
1707
1708                 CTGitPathList pathList;
1709                 pathList.AddPath(CTGitPath(_T("c:\\.svndir")));
1710                 pathList.AddPath(CTGitPath(_T("c:\\.svn")));
1711                 pathList.AddPath(CTGitPath(_T("c:\\.svn\\test")));
1712                 pathList.AddPath(CTGitPath(_T("c:\\test")));
1713                 pathList.RemoveAdminPaths();
1714                 ATLASSERT(pathList.GetCount()==2);
1715                 pathList.Clear();
1716                 pathList.AddPath(CTGitPath(_T("c:\\test")));
1717                 pathList.RemoveAdminPaths();
1718                 ATLASSERT(pathList.GetCount()==1);
1719         }
1720
1721         void SortTest()
1722         {
1723                 CTGitPathList testList;
1724                 CTGitPath testPath;
1725                 testPath.SetFromUnknown(_T("c:/Z"));
1726                 testList.AddPath(testPath);
1727                 testPath.SetFromUnknown(_T("c:/B"));
1728                 testList.AddPath(testPath);
1729                 testPath.SetFromUnknown(_T("c:\\a"));
1730                 testList.AddPath(testPath);
1731                 testPath.SetFromUnknown(_T("c:/Test"));
1732                 testList.AddPath(testPath);
1733
1734                 testList.SortByPathname();
1735
1736                 ATLASSERT(testList[0].GetWinPathString() == _T("c:\\a"));
1737                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\B"));
1738                 ATLASSERT(testList[2].GetWinPathString() == _T("c:\\Test"));
1739                 ATLASSERT(testList[3].GetWinPathString() == _T("c:\\Z"));
1740         }
1741
1742         void RawAppendTest()
1743         {
1744                 CTGitPath testPath(_T("c:/test/"));
1745                 testPath.AppendRawString(_T("/Hello"));
1746                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));
1747
1748                 testPath.AppendRawString(_T("\\T2"));
1749                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));
1750
1751                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));
1752                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));
1753                 testBasePath.AppendRawString(testFilePath.GetFileExtension());
1754                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt.ini"));
1755         }
1756
1757         void PathAppendTest()
1758         {
1759                 CTGitPath testPath(_T("c:/test/"));
1760                 testPath.AppendPathString(_T("/Hello"));
1761                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));
1762
1763                 testPath.AppendPathString(_T("T2"));
1764                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));
1765
1766                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));
1767                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));
1768                 // You wouldn't want to do this in real life - you'd use append-raw
1769                 testBasePath.AppendPathString(testFilePath.GetFileExtension());
1770                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt\\.ini"));
1771         }
1772
1773         void RemoveDuplicatesTest()
1774         {
1775                 CTGitPathList list;
1776                 list.AddPath(CTGitPath(_T("Z")));
1777                 list.AddPath(CTGitPath(_T("A")));
1778                 list.AddPath(CTGitPath(_T("E")));
1779                 list.AddPath(CTGitPath(_T("E")));
1780
1781                 ATLASSERT(list[2].IsEquivalentTo(list[3]));
1782                 ATLASSERT(list[2]==list[3]);
1783
1784                 ATLASSERT(list.GetCount() == 4);
1785
1786                 list.RemoveDuplicates();
1787
1788                 ATLASSERT(list.GetCount() == 3);
1789
1790                 ATLASSERT(list[0].GetWinPathString() == _T("A"));
1791                 ATLASSERT(list[1].GetWinPathString().Compare(_T("E")) == 0);
1792                 ATLASSERT(list[2].GetWinPathString() == _T("Z"));
1793         }
1794
1795         void RemoveChildrenTest()
1796         {
1797                 CTGitPathList list;
1798                 list.AddPath(CTGitPath(_T("c:\\test")));
1799                 list.AddPath(CTGitPath(_T("c:\\test\\file")));
1800                 list.AddPath(CTGitPath(_T("c:\\testfile")));
1801                 list.AddPath(CTGitPath(_T("c:\\parent")));
1802                 list.AddPath(CTGitPath(_T("c:\\parent\\child")));
1803                 list.AddPath(CTGitPath(_T("c:\\parent\\child1")));
1804                 list.AddPath(CTGitPath(_T("c:\\parent\\child2")));
1805
1806                 ATLASSERT(list.GetCount() == 7);
1807
1808                 list.RemoveChildren();
1809
1810                 ATLTRACE("count = %d\n", list.GetCount());
1811                 ATLASSERT(list.GetCount() == 3);
1812
1813                 list.SortByPathname();
1814
1815                 ATLASSERT(list[0].GetWinPathString().Compare(_T("c:\\parent")) == 0);
1816                 ATLASSERT(list[1].GetWinPathString().Compare(_T("c:\\test")) == 0);
1817                 ATLASSERT(list[2].GetWinPathString().Compare(_T("c:\\testfile")) == 0);
1818         }
1819
1820 #if defined(_MFC_VER)
1821         void ListLoadingTest()
1822         {
1823                 TCHAR buf[MAX_PATH] = {0};
1824                 GetCurrentDirectory(MAX_PATH, buf);
1825                 CString sPathList(_T("Path1*c:\\path2 with spaces and stuff*\\funnypath\\*"));
1826                 CTGitPathList testList;
1827                 testList.LoadFromAsteriskSeparatedString(sPathList);
1828
1829                 ATLASSERT(testList.GetCount() == 3);
1830                 ATLASSERT(testList[0].GetWinPathString() == CString(buf) + _T("\\Path1"));
1831                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\path2 with spaces and stuff"));
1832                 ATLASSERT(testList[2].GetWinPathString() == _T("\\funnypath"));
1833
1834                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T(""));
1835                 testList.Clear();
1836                 sPathList = _T("c:\\path2 with spaces and stuff*c:\\funnypath\\*");
1837                 testList.LoadFromAsteriskSeparatedString(sPathList);
1838                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T("c:\\"));
1839         }
1840 #endif
1841
1842         void ContainingDirectoryTest()
1843         {
1844
1845                 CTGitPath testPath;
1846                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));
1847                 CTGitPath dir;
1848                 dir = testPath.GetContainingDirectory();
1849                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c\\d"));
1850                 dir = dir.GetContainingDirectory();
1851                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c"));
1852                 dir = dir.GetContainingDirectory();
1853                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b"));
1854                 dir = dir.GetContainingDirectory();
1855                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a"));
1856                 dir = dir.GetContainingDirectory();
1857                 ATLASSERT(dir.GetWinPathString() == _T("c:\\"));
1858                 dir = dir.GetContainingDirectory();
1859                 ATLASSERT(dir.IsEmpty());
1860                 ATLASSERT(dir.GetWinPathString() == _T(""));
1861         }
1862
1863         void AncestorTest()
1864         {
1865                 CTGitPath testPath;
1866                 testPath.SetFromWin(_T("c:\\windows"));
1867                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\")))==false);
1868                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows"))));
1869                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windowsdummy")))==false);
1870                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\test.txt"))));
1871                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\system32\\test.txt"))));
1872         }
1873
1874         void SubversionPathTest()
1875         {
1876                 CTGitPath testPath;
1877                 testPath.SetFromWin(_T("c:\\"));
1878                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:") == 0);
1879                 testPath.SetFromWin(_T("c:\\folder"));
1880                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/folder") == 0);
1881                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));
1882                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/a/b/c/d/e") == 0);
1883                 testPath.SetFromUnknown(_T("http://testing/"));
1884                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing") == 0);
1885                 testPath.SetFromGit(NULL);
1886                 ATLASSERT(strlen(testPath.GetGitApiPath(pool))==0);
1887 #if defined(_MFC_VER)
1888                 testPath.SetFromUnknown(_T("http://testing again"));
1889                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);
1890                 testPath.SetFromUnknown(_T("http://testing%20again"));
1891                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);
1892                 testPath.SetFromUnknown(_T("http://testing special chars \344\366\374"));
1893                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20special%20chars%20%c3%a4%c3%b6%c3%bc") == 0);
1894 #endif
1895         }
1896
1897         void GetCommonRootTest()
1898         {
1899                 CTGitPath pathA (_T("C:\\Development\\LogDlg.cpp"));
1900                 CTGitPath pathB (_T("C:\\Development\\LogDlg.h"));
1901                 CTGitPath pathC (_T("C:\\Development\\SomeDir\\LogDlg.h"));
1902
1903                 CTGitPathList list;
1904                 list.AddPath(pathA);
1905                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development\\LogDlg.cpp"))==0);
1906                 list.AddPath(pathB);
1907                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);
1908                 list.AddPath(pathC);
1909                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);
1910 #ifdef _MFC_VER
1911                 list.Clear();
1912                 CString sPathList = _T("D:\\Development\\StExBar\\StExBar\\src\\setup\\Setup64.wxs*D:\\Development\\StExBar\\StExBar\\src\\setup\\Setup.wxs*D:\\Development\\StExBar\\SKTimeStamp\\src\\setup\\Setup.wxs*D:\\Development\\StExBar\\SKTimeStamp\\src\\setup\\Setup64.wxs");
1913                 list.LoadFromAsteriskSeparatedString(sPathList);
1914                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("D:\\Development\\StExBar"))==0);
1915
1916                 list.Clear();
1917                 sPathList = _T("c:\\windows\\explorer.exe*c:\\windows");
1918                 list.LoadFromAsteriskSeparatedString(sPathList);
1919                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1920
1921                 list.Clear();
1922                 sPathList = _T("c:\\windows\\*c:\\windows");
1923                 list.LoadFromAsteriskSeparatedString(sPathList);
1924                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1925
1926                 list.Clear();
1927                 sPathList = _T("c:\\windows\\system32*c:\\windows\\system");
1928                 list.LoadFromAsteriskSeparatedString(sPathList);
1929                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1930
1931                 list.Clear();
1932                 sPathList = _T("c:\\windowsdummy*c:\\windows");
1933                 list.LoadFromAsteriskSeparatedString(sPathList);
1934                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\"))==0);
1935 #endif
1936         }
1937
1938         void ValidPathAndUrlTest()
1939         {
1940                 CTGitPath testPath;
1941                 testPath.SetFromWin(_T("c:\\a\\b\\c.test.txt"));
1942                 ATLASSERT(testPath.IsValidOnWindows());
1943                 testPath.SetFromWin(_T("c:\\"));
1944                 ATLASSERT(testPath.IsValidOnWindows());
1945                 testPath.SetFromWin(_T("D:\\.Net\\SpindleSearch\\"));
1946                 ATLASSERT(testPath.IsValidOnWindows());
1947                 testPath.SetFromWin(_T("c"));
1948                 ATLASSERT(testPath.IsValidOnWindows());
1949                 testPath.SetFromWin(_T("c:\\test folder\\file"));
1950                 ATLASSERT(testPath.IsValidOnWindows());
1951                 testPath.SetFromWin(_T("c:\\folder\\"));
1952                 ATLASSERT(testPath.IsValidOnWindows());
1953                 testPath.SetFromWin(_T("c:\\ext.ext.ext\\ext.ext.ext.ext"));
1954                 ATLASSERT(testPath.IsValidOnWindows());
1955                 testPath.SetFromWin(_T("c:\\.svn"));
1956                 ATLASSERT(testPath.IsValidOnWindows());
1957                 testPath.SetFromWin(_T("c:\\com\\file"));
1958                 ATLASSERT(testPath.IsValidOnWindows());
1959                 testPath.SetFromWin(_T("c:\\test\\conf"));
1960                 ATLASSERT(testPath.IsValidOnWindows());
1961                 testPath.SetFromWin(_T("c:\\LPT"));
1962                 ATLASSERT(testPath.IsValidOnWindows());
1963                 testPath.SetFromWin(_T("c:\\test\\LPT"));
1964                 ATLASSERT(testPath.IsValidOnWindows());
1965                 testPath.SetFromWin(_T("c:\\com1test"));
1966                 ATLASSERT(testPath.IsValidOnWindows());
1967                 testPath.SetFromWin(_T("\\\\?\\c:\\test\\com1test"));
1968                 ATLASSERT(testPath.IsValidOnWindows());
1969
1970                 testPath.SetFromWin(_T("\\\\Share\\filename"));
1971                 ATLASSERT(testPath.IsValidOnWindows());
1972                 testPath.SetFromWin(_T("\\\\Share\\filename.extension"));
1973                 ATLASSERT(testPath.IsValidOnWindows());
1974                 testPath.SetFromWin(_T("\\\\Share\\.svn"));
1975                 ATLASSERT(testPath.IsValidOnWindows());
1976
1977                 // now the negative tests
1978                 testPath.SetFromWin(_T("c:\\test:folder"));
1979                 ATLASSERT(!testPath.IsValidOnWindows());
1980                 testPath.SetFromWin(_T("c:\\file<name"));
1981                 ATLASSERT(!testPath.IsValidOnWindows());
1982                 testPath.SetFromWin(_T("c:\\something*else"));
1983                 ATLASSERT(!testPath.IsValidOnWindows());
1984                 testPath.SetFromWin(_T("c:\\folder\\file?nofile"));
1985                 ATLASSERT(!testPath.IsValidOnWindows());
1986                 testPath.SetFromWin(_T("c:\\ext.>ension"));
1987                 ATLASSERT(!testPath.IsValidOnWindows());
1988                 testPath.SetFromWin(_T("c:\\com1\\filename"));
1989                 ATLASSERT(!testPath.IsValidOnWindows());
1990                 testPath.SetFromWin(_T("c:\\com1"));
1991                 ATLASSERT(!testPath.IsValidOnWindows());
1992                 testPath.SetFromWin(_T("c:\\com1\\AuX"));
1993                 ATLASSERT(!testPath.IsValidOnWindows());
1994
1995                 testPath.SetFromWin(_T("\\\\Share\\lpt9\\filename"));
1996                 ATLASSERT(!testPath.IsValidOnWindows());
1997                 testPath.SetFromWin(_T("\\\\Share\\prn"));
1998                 ATLASSERT(!testPath.IsValidOnWindows());
1999                 testPath.SetFromWin(_T("\\\\Share\\NUL"));
2000                 ATLASSERT(!testPath.IsValidOnWindows());
2001
2002                 // now come some URL tests
2003                 testPath.SetFromGit(_T("http://myserver.com/repos/trunk"));
2004                 ATLASSERT(testPath.IsValidOnWindows());
2005                 testPath.SetFromGit(_T("https://myserver.com/repos/trunk/file%20with%20spaces"));
2006                 ATLASSERT(testPath.IsValidOnWindows());
2007                 testPath.SetFromGit(_T("svn://myserver.com/repos/trunk/file with spaces"));
2008                 ATLASSERT(testPath.IsValidOnWindows());
2009                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk"));
2010                 ATLASSERT(testPath.IsValidOnWindows());
2011                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk"));
2012                 ATLASSERT(testPath.IsValidOnWindows());
2013                 testPath.SetFromGit(_T("file:///C:/GitRepos/Tester/Proj1/tags/t2"));
2014                 ATLASSERT(testPath.IsValidOnWindows());
2015                 // and some negative URL tests
2016                 testPath.SetFromGit(_T("httpp://myserver.com/repos/trunk"));
2017                 ATLASSERT(!testPath.IsValidOnWindows());
2018                 testPath.SetFromGit(_T("https://myserver.com/rep:os/trunk/file%20with%20spaces"));
2019                 ATLASSERT(!testPath.IsValidOnWindows());
2020                 testPath.SetFromGit(_T("svn://myserver.com/rep<os/trunk/file with spaces"));
2021                 ATLASSERT(!testPath.IsValidOnWindows());
2022                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk/prn/"));
2023                 ATLASSERT(!testPath.IsValidOnWindows());
2024                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk/com1"));
2025                 ATLASSERT(!testPath.IsValidOnWindows());
2026
2027         }
2028
2029 } TGitPathTestobject;
2030 #endif
2031 #endif
2032
2033 CTGitPath * CTGitPathList::LookForGitPath(CString path)
2034 {
2035         int i=0;
2036         for (i = 0; i < this->GetCount(); ++i)
2037         {
2038                 if((*this)[i].GetGitPathString() == path )
2039                         return (CTGitPath*)&(*this)[i];
2040         }
2041         return NULL;
2042 }
2043 CString CTGitPath::GetActionName(int action)
2044 {
2045         if(action  & CTGitPath::LOGACTIONS_UNMERGED)
2046                 return MAKEINTRESOURCE(IDS_PATHACTIONS_CONFLICT);
2047         if(action  & CTGitPath::LOGACTIONS_ADDED)
2048                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ADD);
2049         if(action  & CTGitPath::LOGACTIONS_DELETED)
2050                 return MAKEINTRESOURCE(IDS_PATHACTIONS_DELETE);
2051         if(action  & CTGitPath::LOGACTIONS_MERGED )
2052                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MERGED);
2053
2054         if(action  & CTGitPath::LOGACTIONS_MODIFIED)
2055                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MODIFIED);
2056         if(action  & CTGitPath::LOGACTIONS_REPLACED)
2057                 return MAKEINTRESOURCE(IDS_PATHACTIONS_RENAME);
2058         if(action  & CTGitPath::LOGACTIONS_COPY)
2059                 return MAKEINTRESOURCE(IDS_PATHACTIONS_COPY);
2060
2061         if(action  & CTGitPath::LOGACTIONS_FORWORD )
2062                 return MAKEINTRESOURCE(IDS_PATHACTIONS_FORWARD);
2063
2064         if (action & CTGitPath::LOGACTIONS_ASSUMEVALID)
2065                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ASSUMEUNCHANGED);
2066         if (action & CTGitPath::LOGACTIONS_SKIPWORKTREE)
2067                 return MAKEINTRESOURCE(IDS_PATHACTIONS_SKIPWORKTREE);
2068
2069         return MAKEINTRESOURCE(IDS_PATHACTIONS_UNKNOWN);
2070 }
2071 CString CTGitPath::GetActionName()
2072 {
2073         return GetActionName(m_Action);
2074 }
2075
2076 int CTGitPathList::GetAction()
2077 {
2078         return m_Action;
2079 }
2080