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         CString path = sPath;
 258         path.Replace('\\', '/');
 259
 260         // We don't leave a trailing /
 261         path.TrimRight('/');
 262         path.Replace(L"//?/", L"");
 263
 264         SanitizeRootPath(path, true);
 265
 266         path.Replace(_T("file:////"), _T("file://"));
 267         m_sFwdslashPath = path;
 268
 269         m_sUTF8FwdslashPath.Empty();
 270 }
 271
 272 void CTGitPath::SetBackslashPath(const CString& sPath) const
 273 {
 274         CString path = sPath;
 275         path.Replace('/', '\\');
 276         path.TrimRight('\\');
 277         SanitizeRootPath(path, false);
 278         m_sBackslashPath = path;
 279 }
 280
 281 void CTGitPath::SetUTF8FwdslashPath(const CString& sPath) const
 282 {
 283         m_sUTF8FwdslashPath = CUnicodeUtils::GetUTF8(sPath);
 284 }
 285
 286 void CTGitPath::SanitizeRootPath(CString& sPath, bool bIsForwardPath) const
 287 {
 288         // Make sure to add the trailing slash to root paths such as 'C:'
 289         if (sPath.GetLength() == 2 && sPath[1] == ':')
 290         {
 291                 sPath += (bIsForwardPath) ? _T("/") : _T("\\");
 292         }
 293 }
 294
 295 bool CTGitPath::IsDirectory() const
 296 {
 297         if(!m_bDirectoryKnown)
 298         {
 299                 UpdateAttributes();
 300         }
 301         return m_bIsDirectory;
 302 }
 303
 304 bool CTGitPath::Exists() const
 305 {
 306         if (!m_bExistsKnown)
 307         {
 308                 UpdateAttributes();
 309         }
 310         return m_bExists;
 311 }
 312
 313 bool CTGitPath::Delete(bool bTrash) const
 314 {
 315         EnsureBackslashPathSet();
 316         ::SetFileAttributes(m_sBackslashPath, FILE_ATTRIBUTE_NORMAL);
 317         bool bRet = false;
 318         if (Exists())
 319         {
 320                 if ((bTrash)||(IsDirectory()))
 321                 {
 322                         std::unique_ptr<TCHAR[]> buf(new TCHAR[m_sBackslashPath.GetLength() + 2]);
 323                         _tcscpy_s(buf.get(), m_sBackslashPath.GetLength() + 2, m_sBackslashPath);
 324                         buf[m_sBackslashPath.GetLength()] = 0;
 325                         buf[m_sBackslashPath.GetLength()+1] = 0;
 326                         bRet = CTGitPathList::DeleteViaShell(buf.get(), bTrash);
 327                 }
 328                 else
 329                 {
 330                         bRet = !!::DeleteFile(m_sBackslashPath);
 331                 }
 332         }
 333         m_bExists = false;
 334         m_bExistsKnown = true;
 335         return bRet;
 336 }
 337
 338 __int64  CTGitPath::GetLastWriteTime() const
 339 {
 340         if(!m_bLastWriteTimeKnown)
 341         {
 342                 UpdateAttributes();
 343         }
 344         return m_lastWriteTime;
 345 }
 346
 347 __int64 CTGitPath::GetFileSize() const
 348 {
 349         if(!m_bDirectoryKnown)
 350         {
 351                 UpdateAttributes();
 352         }
 353         return m_fileSize;
 354 }
 355
 356 bool CTGitPath::IsReadOnly() const
 357 {
 358         if(!m_bLastWriteTimeKnown)
 359         {
 360                 UpdateAttributes();
 361         }
 362         return m_bIsReadOnly;
 363 }
 364
 365 void CTGitPath::UpdateAttributes() const
 366 {
 367         EnsureBackslashPathSet();
 368         WIN32_FILE_ATTRIBUTE_DATA attribs;
 369         if (m_sBackslashPath.GetLength() >= 248)
 370                 m_sLongBackslashPath = _T("\\\\?\\") + m_sBackslashPath;
 371         if(GetFileAttributesEx(m_sBackslashPath.GetLength() >= 248 ? m_sLongBackslashPath : m_sBackslashPath, GetFileExInfoStandard, &attribs))
 372         {
 373                 m_bIsDirectory = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 374                 m_lastWriteTime = *(__int64*)&attribs.ftLastWriteTime;
 375                 if (m_bIsDirectory)
 376                 {
 377                         m_fileSize = 0;
 378                 }
 379                 else
 380                 {
 381                         m_fileSize = ((INT64)( (DWORD)(attribs.nFileSizeLow) ) | ( (INT64)( (DWORD)(attribs.nFileSizeHigh) )<<32 ));
 382                 }
 383                 m_bIsReadOnly = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
 384                 m_bExists = true;
 385         }
 386         else
 387         {
 388                 m_bIsDirectory = false;
 389                 m_lastWriteTime = 0;
 390                 m_fileSize = 0;
 391                 DWORD err = GetLastError();
 392                 if ((err == ERROR_FILE_NOT_FOUND)||(err == ERROR_PATH_NOT_FOUND)||(err == ERROR_INVALID_NAME))
 393                 {
 394                         m_bExists = false;
 395                 }
 396                 else
 397                 {
 398                         m_bExists = true;
 399                         return;
 400                 }
 401         }
 402         m_bDirectoryKnown = true;
 403         m_bLastWriteTimeKnown = true;
 404         m_bExistsKnown = true;
 405 }
 406
 407 CTGitPath CTGitPath::GetSubPath(const CTGitPath &root)
 408 {
 409         CTGitPath path;
 410
 411         if(GetWinPathString().Left(root.GetWinPathString().GetLength()) == root.GetWinPathString())
 412         {
 413                 CString str=GetWinPathString();
 414                 path.SetFromWin(str.Right(str.GetLength()-root.GetWinPathString().GetLength()-1));
 415         }
 416         return path;
 417 }
 418
 419 void CTGitPath::EnsureBackslashPathSet() const
 420 {
 421         if(m_sBackslashPath.IsEmpty())
 422         {
 423                 SetBackslashPath(m_sFwdslashPath);
 424                 ATLASSERT(IsEmpty() || !m_sBackslashPath.IsEmpty());
 425         }
 426 }
 427 void CTGitPath::EnsureFwdslashPathSet() const
 428 {
 429         if(m_sFwdslashPath.IsEmpty())
 430         {
 431                 SetFwdslashPath(m_sBackslashPath);
 432                 ATLASSERT(IsEmpty() || !m_sFwdslashPath.IsEmpty());
 433         }
 434 }
 435
 436
 437 // Reset all the caches
 438 void CTGitPath::Reset()
 439 {
 440         m_bDirectoryKnown = false;
 441         m_bURLKnown = false;
 442         m_bLastWriteTimeKnown = false;
 443         m_bHasAdminDirKnown = false;
 444         m_bIsValidOnWindowsKnown = false;
 445         m_bIsAdminDirKnown = false;
 446         m_bExistsKnown = false;
 447         m_bIsSpecialDirectoryKnown = false;
 448         m_bIsSpecialDirectory = false;
 449
 450         m_sBackslashPath.Empty();
 451         m_sFwdslashPath.Empty();
 452         m_sUTF8FwdslashPath.Empty();
 453         this->m_Action=0;
 454         this->m_StatAdd=_T("");
 455         this->m_StatDel=_T("");
 456         m_ParentNo=0;
 457         ATLASSERT(IsEmpty());
 458 }
 459
 460 CTGitPath CTGitPath::GetDirectory() const
 461 {
 462         if ((IsDirectory())||(!Exists()))
 463         {
 464                 return *this;
 465         }
 466         return GetContainingDirectory();
 467 }
 468
 469 CTGitPath CTGitPath::GetContainingDirectory() const
 470 {
 471         EnsureBackslashPathSet();
 472
 473         CString sDirName = m_sBackslashPath.Left(m_sBackslashPath.ReverseFind('\\'));
 474         if(sDirName.GetLength() == 2 && sDirName[1] == ':')
 475         {
 476                 // This is a root directory, which needs a trailing slash
 477                 sDirName += '\\';
 478                 if(sDirName == m_sBackslashPath)
 479                 {
 480                         // We were clearly provided with a root path to start with - we should return nothing now
 481                         sDirName.Empty();
 482                 }
 483         }
 484         if(sDirName.GetLength() == 1 && sDirName[0] == '\\')
 485         {
 486                 // We have an UNC path and we already are the root
 487                 sDirName.Empty();
 488         }
 489         CTGitPath retVal;
 490         retVal.SetFromWin(sDirName);
 491         return retVal;
 492 }
 493
 494 CString CTGitPath::GetRootPathString() const
 495 {
 496         EnsureBackslashPathSet();
 497         CString workingPath = m_sBackslashPath;
 498         LPTSTR pPath = workingPath.GetBuffer(MAX_PATH);         // MAX_PATH ok here.
 499         ATLVERIFY(::PathStripToRoot(pPath));
 500         workingPath.ReleaseBuffer();
 501         return workingPath;
 502 }
 503
 504
 505 CString CTGitPath::GetFilename() const
 506 {
 507         //ATLASSERT(!IsDirectory());
 508         return GetFileOrDirectoryName();
 509 }
 510
 511 CString CTGitPath::GetFileOrDirectoryName() const
 512 {
 513         EnsureBackslashPathSet();
 514         return m_sBackslashPath.Mid(m_sBackslashPath.ReverseFind('\\')+1);
 515 }
 516
 517 CString CTGitPath::GetUIFileOrDirectoryName() const
 518 {
 519         GetUIPathString();
 520         return m_sUIPath.Mid(m_sUIPath.ReverseFind('\\')+1);
 521 }
 522
 523 CString CTGitPath::GetFileExtension() const
 524 {
 525         if(!IsDirectory())
 526         {
 527                 EnsureBackslashPathSet();
 528                 int dotPos = m_sBackslashPath.ReverseFind('.');
 529                 int slashPos = m_sBackslashPath.ReverseFind('\\');
 530                 if (dotPos > slashPos)
 531                         return m_sBackslashPath.Mid(dotPos);
 532         }
 533         return CString();
 534 }
 535 CString CTGitPath::GetBaseFilename() const
 536 {
 537         int dot;
 538         CString filename=GetFilename();
 539         dot = filename.ReverseFind(_T('.'));
 540         if(dot>0)
 541                 return filename.Left(dot);
 542         else
 543                 return filename;
 544 }
 545
 546 bool CTGitPath::ArePathStringsEqual(const CString& sP1, const CString& sP2)
 547 {
 548         int length = sP1.GetLength();
 549         if(length != sP2.GetLength())
 550         {
 551                 // Different lengths
 552                 return false;
 553         }
 554         // We work from the end of the strings, because path differences
 555         // are more likely to occur at the far end of a string
 556         LPCTSTR pP1Start = sP1;
 557         LPCTSTR pP1 = pP1Start+(length-1);
 558         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);
 559         while(length-- > 0)
 560         {
 561                 if(_totlower(*pP1--) != _totlower(*pP2--))
 562                 {
 563                         return false;
 564                 }
 565         }
 566         return true;
 567 }
 568
 569 bool CTGitPath::ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2)
 570 {
 571         int length = sP1.GetLength();
 572         if(length != sP2.GetLength())
 573         {
 574                 // Different lengths
 575                 return false;
 576         }
 577         // We work from the end of the strings, because path differences
 578         // are more likely to occur at the far end of a string
 579         LPCTSTR pP1Start = sP1;
 580         LPCTSTR pP1 = pP1Start+(length-1);
 581         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);
 582         while(length-- > 0)
 583         {
 584                 if((*pP1--) != (*pP2--))
 585                 {
 586                         return false;
 587                 }
 588         }
 589         return true;
 590 }
 591
 592 bool CTGitPath::IsEmpty() const
 593 {
 594         // Check the backward slash path first, since the chance that this
 595         // one is set is higher. In case of a 'false' return value it's a little
 596         // bit faster.
 597         return m_sBackslashPath.IsEmpty() && m_sFwdslashPath.IsEmpty();
 598 }
 599
 600 // Test if both paths refer to the same item
 601 // Ignores case and slash direction
 602 bool CTGitPath::IsEquivalentTo(const CTGitPath& rhs) const
 603 {
 604         // Try and find a slash direction which avoids having to convert
 605         // both filenames
 606         if(!m_sBackslashPath.IsEmpty())
 607         {
 608                 // *We've* got a \ path - make sure that the RHS also has a \ path
 609                 rhs.EnsureBackslashPathSet();
 610                 return ArePathStringsEqualWithCase(m_sBackslashPath, rhs.m_sBackslashPath);
 611         }
 612         else
 613         {
 614                 // Assume we've got a fwdslash path and make sure that the RHS has one
 615                 rhs.EnsureFwdslashPathSet();
 616                 return ArePathStringsEqualWithCase(m_sFwdslashPath, rhs.m_sFwdslashPath);
 617         }
 618 }
 619
 620 bool CTGitPath::IsEquivalentToWithoutCase(const CTGitPath& rhs) const
 621 {
 622         // Try and find a slash direction which avoids having to convert
 623         // both filenames
 624         if(!m_sBackslashPath.IsEmpty())
 625         {
 626                 // *We've* got a \ path - make sure that the RHS also has a \ path
 627                 rhs.EnsureBackslashPathSet();
 628                 return ArePathStringsEqual(m_sBackslashPath, rhs.m_sBackslashPath);
 629         }
 630         else
 631         {
 632                 // Assume we've got a fwdslash path and make sure that the RHS has one
 633                 rhs.EnsureFwdslashPathSet();
 634                 return ArePathStringsEqual(m_sFwdslashPath, rhs.m_sFwdslashPath);
 635         }
 636 }
 637
 638 bool CTGitPath::IsAncestorOf(const CTGitPath& possibleDescendant) const
 639 {
 640         possibleDescendant.EnsureBackslashPathSet();
 641         EnsureBackslashPathSet();
 642
 643         bool bPathStringsEqual = ArePathStringsEqual(m_sBackslashPath, possibleDescendant.m_sBackslashPath.Left(m_sBackslashPath.GetLength()));
 644         if (m_sBackslashPath.GetLength() >= possibleDescendant.GetWinPathString().GetLength())
 645         {
 646                 return bPathStringsEqual;
 647         }
 648
 649         return (bPathStringsEqual &&
 650                         ((possibleDescendant.m_sBackslashPath[m_sBackslashPath.GetLength()] == '\\')||
 651                         (m_sBackslashPath.GetLength()==3 && m_sBackslashPath[1]==':')));
 652 }
 653
 654 // Get a string representing the file path, optionally with a base
 655 // section stripped off the front.
 656 CString CTGitPath::GetDisplayString(const CTGitPath* pOptionalBasePath /* = NULL*/) const
 657 {
 658         EnsureFwdslashPathSet();
 659         if(pOptionalBasePath != NULL)
 660         {
 661                 // Find the length of the base-path without having to do an 'ensure' on it
 662                 int baseLength = max(pOptionalBasePath->m_sBackslashPath.GetLength(), pOptionalBasePath->m_sFwdslashPath.GetLength());
 663
 664                 // Now, chop that baseLength of the front of the path
 665                 return m_sFwdslashPath.Mid(baseLength).TrimLeft('/');
 666         }
 667         return m_sFwdslashPath;
 668 }
 669
 670 int CTGitPath::Compare(const CTGitPath& left, const CTGitPath& right)
 671 {
 672         left.EnsureBackslashPathSet();
 673         right.EnsureBackslashPathSet();
 674         return left.m_sBackslashPath.CompareNoCase(right.m_sBackslashPath);
 675 }
 676
 677 bool operator<(const CTGitPath& left, const CTGitPath& right)
 678 {
 679         return CTGitPath::Compare(left, right) < 0;
 680 }
 681
 682 bool CTGitPath::PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right)
 683 {
 684         return left.IsEquivalentTo(right);
 685 }
 686
 687 bool CTGitPath::PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right)
 688 {
 689         if (left.IsAdminDir() && right.IsAdminDir())
 690         {
 691                 CTGitPath l = left;
 692                 CTGitPath r = right;
 693                 do
 694                 {
 695                         l = l.GetContainingDirectory();
 696                 } while(l.HasAdminDir());
 697                 do
 698                 {
 699                         r = r.GetContainingDirectory();
 700                 } while(r.HasAdminDir());
 701                 return l.GetContainingDirectory().IsEquivalentTo(r.GetContainingDirectory());
 702         }
 703         return left.GetDirectory().IsEquivalentTo(right.GetDirectory());
 704 }
 705
 706 bool CTGitPath::CheckChild(const CTGitPath &parent, const CTGitPath& child)
 707 {
 708         return parent.IsAncestorOf(child);
 709 }
 710
 711 void CTGitPath::AppendRawString(const CString& sAppend)
 712 {
 713         EnsureFwdslashPathSet();
 714         CString strCopy = m_sFwdslashPath += sAppend;
 715         SetFromUnknown(strCopy);
 716 }
 717
 718 void CTGitPath::AppendPathString(const CString& sAppend)
 719 {
 720         EnsureBackslashPathSet();
 721         CString cleanAppend(sAppend);
 722         cleanAppend.Replace('/', '\\');
 723         cleanAppend.TrimLeft('\\');
 724         m_sBackslashPath.TrimRight('\\');
 725         CString strCopy = m_sBackslashPath + _T("\\") + cleanAppend;
 726         SetFromWin(strCopy);
 727 }
 728
 729 bool CTGitPath::IsWCRoot() const
 730 {
 731         if (m_bIsWCRootKnown)
 732                 return m_bIsWCRoot;
 733
 734         m_bIsWCRootKnown = true;
 735         m_bIsWCRoot = false;
 736
 737         CString topDirectory;
 738         if (!IsDirectory() || !HasAdminDir(&topDirectory))
 739         {
 740                 return m_bIsWCRoot;
 741         }
 742
 743         if (IsEquivalentToWithoutCase(topDirectory))
 744         {
 745                 m_bIsWCRoot = true;
 746         }
 747
 748         return m_bIsWCRoot;
 749 }
 750
 751 bool CTGitPath::HasAdminDir() const
 752 {
 753         if (m_bHasAdminDirKnown)
 754                 return m_bHasAdminDir;
 755
 756         EnsureBackslashPathSet();
 757         m_bHasAdminDir = g_GitAdminDir.HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
 758         m_bHasAdminDirKnown = true;
 759         return m_bHasAdminDir;
 760 }
 761
 762 bool CTGitPath::HasSubmodules() const
 763 {
 764         if (HasAdminDir())
 765         {
 766                 CString path = m_sProjectRoot;
 767                 path += _T("\\.gitmodules");
 768                 if( PathFileExists(path) )
 769                         return true;
 770         }
 771         return false;
 772 }
 773
 774 int CTGitPath::GetAdminDirMask() const
 775 {
 776         int status = 0;
 777         CString topdir;
 778         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 779         {
 780                 return status;
 781         }
 782
 783         // ITEMIS_INGIT will be revoked if necessary in TortoiseShell/ContextMenu.cpp
 784         status |= ITEMIS_INGIT|ITEMIS_INVERSIONEDFOLDER;
 785
 786         if (IsDirectory())
 787         {
 788                 status |= ITEMIS_FOLDERINGIT;
 789                 if (IsWCRoot())
 790                 {
 791                         status |= ITEMIS_WCROOT;
 792
 793                         CString topProjectDir;
 794                         if (g_GitAdminDir.HasAdminDir(GetWinPathString(), false, &topProjectDir))
 795                         {
 796                                 if (PathFileExists(topProjectDir + _T("\\.gitmodules")))
 797                                 {
 798                                         CAutoConfig config(true);
 799                                         git_config_add_file_ondisk(config, CGit::GetGitPathStringA(topProjectDir + _T("\\.gitmodules")), GIT_CONFIG_LEVEL_APP, FALSE);
 800                                         CString relativePath = GetWinPathString().Mid(topProjectDir.GetLength());
 801                                         relativePath.Replace(_T("\\"), _T("/"));
 802                                         relativePath.Trim(_T("/"));
 803                                         CStringA submodulePath = CUnicodeUtils::GetUTF8(relativePath);
 804                                         if (git_config_foreach_match(config, "submodule\\..*\\.path",
 805                                                 [](const git_config_entry *entry, void *data) { return entry->value == *(CStringA *)data ? GIT_EUSER : 0; }, &submodulePath) == GIT_EUSER)
 806                                                 status |= ITEMIS_SUBMODULE;
 807                                 }
 808                         }
 809                 }
 810         }
 811
 812         CString dotGitPath;
 813         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 814
 815         if (PathFileExists(dotGitPath + _T("BISECT_START")))
 816                 status |= ITEMIS_BISECT;
 817
 818         if (PathFileExists(dotGitPath + _T("MERGE_HEAD")))
 819                 status |= ITEMIS_MERGEACTIVE;
 820
 821         if (PathFileExists(dotGitPath + _T("refs\\stash")))
 822                 status |= ITEMIS_STASH;
 823
 824         if (PathFileExists(dotGitPath + _T("svn")))
 825                 status |= ITEMIS_GITSVN;
 826
 827         if (PathFileExists(topdir + _T("\\.gitmodules")))
 828                 status |= ITEMIS_SUBMODULECONTAINER;
 829
 830         return status;
 831 }
 832
 833 bool CTGitPath::HasStashDir() const
 834 {
 835         CString topdir;
 836         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 837         {
 838                 return false;
 839         }
 840
 841         CString dotGitPath;
 842         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 843
 844         return !!PathFileExists(dotGitPath + _T("\\refs\\stash"));
 845 }
 846 bool CTGitPath::HasGitSVNDir() const
 847 {
 848         CString topdir;
 849         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 850         {
 851                 return false;
 852         }
 853
 854         CString dotGitPath;
 855         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 856
 857         return !!PathFileExists(dotGitPath + _T("svn"));
 858 }
 859 bool CTGitPath::IsBisectActive() const
 860 {
 861         CString topdir;
 862         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 863         {
 864                 return false;
 865         }
 866
 867         CString dotGitPath;
 868         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 869
 870         return !!PathFileExists(dotGitPath + _T("BISECT_START"));
 871 }
 872 bool CTGitPath::IsMergeActive() const
 873 {
 874         CString topdir;
 875         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 876         {
 877                 return false;
 878         }
 879
 880         CString dotGitPath;
 881         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 882
 883         return !!PathFileExists(dotGitPath + _T("MERGE_HEAD"));
 884 }
 885 bool CTGitPath::HasRebaseApply() const
 886 {
 887         CString topdir;
 888         if(!g_GitAdminDir.HasAdminDir(GetWinPathString(),&topdir))
 889         {
 890                 return false;
 891         }
 892
 893         CString dotGitPath;
 894         g_GitAdminDir.GetAdminDirPath(topdir, dotGitPath);
 895
 896         return !!PathFileExists(dotGitPath + _T("rebase-apply"));
 897 }
 898
 899 bool CTGitPath::HasAdminDir(CString *ProjectTopDir) const
 900 {
 901         if (m_bHasAdminDirKnown)
 902         {
 903                 if (ProjectTopDir)
 904                         *ProjectTopDir = m_sProjectRoot;
 905                 return m_bHasAdminDir;
 906         }
 907
 908         EnsureBackslashPathSet();
 909         m_bHasAdminDir = g_GitAdminDir.HasAdminDir(m_sBackslashPath, IsDirectory(), &m_sProjectRoot);
 910         m_bHasAdminDirKnown = true;
 911         if (ProjectTopDir)
 912                 *ProjectTopDir = m_sProjectRoot;
 913         return m_bHasAdminDir;
 914 }
 915
 916 bool CTGitPath::IsAdminDir() const
 917 {
 918         if (m_bIsAdminDirKnown)
 919                 return m_bIsAdminDir;
 920
 921         EnsureBackslashPathSet();
 922         m_bIsAdminDir = g_GitAdminDir.IsAdminDirPath(m_sBackslashPath);
 923         m_bIsAdminDirKnown = true;
 924         return m_bIsAdminDir;
 925 }
 926
 927 bool CTGitPath::IsValidOnWindows() const
 928 {
 929         if (m_bIsValidOnWindowsKnown)
 930                 return m_bIsValidOnWindows;
 931
 932         m_bIsValidOnWindows = false;
 933         EnsureBackslashPathSet();
 934         CString sMatch = m_sBackslashPath + _T("\r\n");
 935         std::wstring sPattern;
 936         // the 'file://' URL is just a normal windows path:
 937         if (sMatch.Left(7).CompareNoCase(_T("file:\\\\"))==0)
 938         {
 939                 sMatch = sMatch.Mid(7);
 940                 sMatch.TrimLeft(_T("\\"));
 941                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
 942         }
 943         else
 944         {
 945                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");
 946         }
 947
 948         try
 949         {
 950                 std::tr1::wregex rx(sPattern, std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
 951                 std::tr1::wsmatch match;
 952
 953                 std::wstring rmatch = std::wstring((LPCTSTR)sMatch);
 954                 if (std::tr1::regex_match(rmatch, match, rx))
 955                 {
 956                         if (std::wstring(match[0]).compare(sMatch)==0)
 957                                 m_bIsValidOnWindows = true;
 958                 }
 959                 if (m_bIsValidOnWindows)
 960                 {
 961                         // now check for illegal filenames
 962                         std::tr1::wregex rx2(_T("\\\\(lpt\\d|com\\d|aux|nul|prn|con)(\\\\|$)"), std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
 963                         rmatch = m_sBackslashPath;
 964                         if (std::tr1::regex_search(rmatch, rx2, std::tr1::regex_constants::match_default))
 965                                 m_bIsValidOnWindows = false;
 966                 }
 967         }
 968         catch (std::exception) {}
 969
 970         m_bIsValidOnWindowsKnown = true;
 971         return m_bIsValidOnWindows;
 972 }
 973
 974 //////////////////////////////////////////////////////////////////////////
 975
 976 CTGitPathList::CTGitPathList()
 977 {
 978         m_Action = 0;
 979 }
 980
 981 // A constructor which allows a path list to be easily built which one initial entry in
 982 CTGitPathList::CTGitPathList(const CTGitPath& firstEntry)
 983 {
 984         m_Action = 0;
 985         AddPath(firstEntry);
 986 }
 987 int CTGitPathList::ParserFromLsFile(BYTE_VECTOR &out,bool /*staged*/)
 988 {
 989         unsigned int pos=0;
 990         CString one;
 991         CTGitPath path;
 992         CString part;
 993         this->Clear();
 994
 995         while(pos>=0 && pos<out.size())
 996         {
 997                 one.Empty();
 998                 path.Reset();
 999
1000                 g_Git.StringAppend(&one, &out[pos], CP_UTF8);
1001                 int tabstart=0;
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                                 g_Git.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                         g_Git.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         CString one;
1100
1101         CAutoRepository repository(g_Git.GetGitRepository());
1102         if (!repository)
1103                 return -1;
1104
1105         CAutoIndex index;
1106         if (git_repository_index(index.GetPointer(), repository))
1107                 return -1;
1108
1109         int count;
1110         if (list == nullptr)
1111                 count = 1;
1112         else
1113                 count = list->GetCount();
1114         for (int j = 0; j < count; ++j)
1115         {
1116                 for (size_t i = 0, ecount = git_index_entrycount(index); i < ecount; ++i)
1117                 {
1118                         const git_index_entry *e = git_index_get_byindex(index, i);
1119
1120                         if (!e || !((e->flags | e->flags_extended) & flag) || !e->path)
1121                                 continue;
1122
1123                         one.Empty();
1124                         g_Git.StringAppend(&one, (BYTE*)e->path, CP_UTF8);
1125
1126                         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)))
1127                                 continue;
1128
1129                         //SetFromGit will clear all status
1130                         path.SetFromGit(one);
1131                         if ((e->flags | e->flags_extended) & GIT_IDXENTRY_SKIP_WORKTREE)
1132                                 path.m_Action = CTGitPath::LOGACTIONS_SKIPWORKTREE;
1133                         else if ((e->flags | e->flags_extended) & GIT_IDXENTRY_VALID)
1134                                 path.m_Action = CTGitPath::LOGACTIONS_ASSUMEVALID;
1135                         AddPath(path);
1136                 }
1137         }
1138         RemoveDuplicates();
1139         return 0;
1140 }
1141 int CTGitPathList::ParserFromLog(BYTE_VECTOR &log, bool parseDeletes /*false*/)
1142 {
1143         this->Clear();
1144         int pos=0;
1145         //BYTE *p=&log[0];
1146         //CString one;
1147         CTGitPath path;
1148         m_Action=0;
1149         while (pos >= 0 && pos < (int)log.size())
1150         {
1151                 //one=log.Tokenize(_T("\n"),pos);
1152                 path.Reset();
1153                 if(log[pos]=='\n')
1154                         ++pos;
1155
1156                 if(log[pos]==':')
1157                 {
1158                         bool merged=false;
1159                         if(log[pos+1] ==':')
1160                         {
1161                                 merged=true;
1162                         }
1163                         int end=log.find(0,pos);
1164                         int actionstart=-1;
1165                         int file1=-1,file2=-1;
1166                         if( end>0 )
1167                         {
1168                                 actionstart=log.find(' ',end-6);
1169                                 pos=actionstart;
1170                         }
1171                         if( actionstart>0 )
1172                         {
1173                                 ++actionstart;
1174
1175                                 file1 = log.find(0,actionstart);
1176                                 if( file1>=0 )
1177                                 {
1178                                         ++file1;
1179                                         pos=file1;
1180                                 }
1181                                 if( log[actionstart] == 'C' || log[actionstart] == 'R' )
1182                                 {
1183                                         file2=file1;
1184                                         file1 = log.find(0,file1);
1185                                         if(file1>=0 )
1186                                         {
1187                                                 ++file1;
1188                                                 pos=file1;
1189                                         }
1190
1191                                 }
1192                         }
1193
1194                         CString pathname1;
1195                         CString pathname2;
1196
1197                         if( file1>=0 )
1198                                 g_Git.StringAppend(&pathname1, &log[file1], CP_UTF8);
1199                         if( file2>=0 )
1200                                 g_Git.StringAppend(&pathname2, &log[file2], CP_UTF8);
1201
1202                         CTGitPath *GitPath=LookForGitPath(pathname1);
1203
1204                         if(GitPath)
1205                         {
1206                                 GitPath->ParserAction( log[actionstart] );
1207
1208                                 if(merged)
1209                                 {
1210                                         GitPath->m_Action |= CTGitPath::LOGACTIONS_MERGED;
1211                                         GitPath->m_Action &= ~CTGitPath::LOGACTIONS_FORWORD;
1212                                 }
1213                                 m_Action |=GitPath->m_Action;
1214
1215                         }
1216                         else
1217                         {
1218                                 int ac=path.ParserAction(log[actionstart] );
1219                                 ac |= merged?CTGitPath::LOGACTIONS_MERGED:0;
1220
1221                                 path.SetFromGit(pathname1,&pathname2);
1222                                 path.m_Action=ac;
1223                                         //action must be set after setfromgit. SetFromGit will clear all status.
1224                                 this->m_Action|=ac;
1225
1226                                 AddPath(path);
1227
1228                         }
1229
1230                 }
1231                 else
1232                 {
1233                         int tabstart=0;
1234                         path.Reset();
1235                         CString StatAdd;
1236                         CString StatDel;
1237                         CString file1;
1238                         CString file2;
1239
1240                         tabstart=log.find('\t',pos);
1241                         if(tabstart >=0)
1242                         {
1243                                 log[tabstart]=0;
1244                                 g_Git.StringAppend(&StatAdd,&log[pos],CP_UTF8);
1245                                 pos=tabstart+1;
1246                         }
1247
1248                         tabstart=log.find('\t',pos);
1249                         if(tabstart >=0)
1250                         {
1251                                 log[tabstart]=0;
1252
1253                                 g_Git.StringAppend(&StatDel,&log[pos],CP_UTF8);
1254                                 pos=tabstart+1;
1255                         }
1256
1257                         if(log[pos] == 0) //rename
1258                         {
1259                                 ++pos;
1260                                 g_Git.StringAppend(&file2, &log[pos], CP_UTF8);
1261                                 int sec=log.find(0,pos);
1262                                 if(sec>=0)
1263                                 {
1264                                         ++sec;
1265                                         g_Git.StringAppend(&file1, &log[sec], CP_UTF8);
1266                                 }
1267                                 pos=sec;
1268
1269                         }
1270                         else
1271                         {
1272                                 g_Git.StringAppend(&file1, &log[pos], CP_UTF8);
1273                         }
1274                         path.SetFromGit(file1,&file2);
1275
1276                         CTGitPath *GitPath=LookForGitPath(path.GetGitPathString());
1277                         if(GitPath)
1278                         {
1279                                 GitPath->m_StatAdd=StatAdd;
1280                                 GitPath->m_StatDel=StatDel;
1281                         }
1282                         else
1283                         {
1284                                 //path.SetFromGit(pathname);
1285                                 if (parseDeletes)
1286                                 {
1287                                         path.m_StatAdd=_T("0");
1288                                         path.m_StatDel=_T("0");
1289                                         path.m_Action |= CTGitPath::LOGACTIONS_DELETED;
1290                                 }
1291                                 else
1292                                 {
1293                                         path.m_StatAdd=StatAdd;
1294                                         path.m_StatDel=StatDel;
1295                                         path.m_Action |= CTGitPath::LOGACTIONS_FORWORD;
1296                                 }
1297                                 AddPath(path);
1298                         }
1299
1300                 }
1301                 pos=log.findNextString(pos);
1302         }
1303         return pos;
1304 }
1305
1306 void CTGitPathList::AddPath(const CTGitPath& newPath)
1307 {
1308         m_paths.push_back(newPath);
1309         m_commonBaseDirectory.Reset();
1310 }
1311 int CTGitPathList::GetCount() const
1312 {
1313         return (int)m_paths.size();
1314 }
1315 bool CTGitPathList::IsEmpty() const
1316 {
1317         return m_paths.empty();
1318 }
1319 void CTGitPathList::Clear()
1320 {
1321         m_paths.clear();
1322         m_commonBaseDirectory.Reset();
1323 }
1324
1325 const CTGitPath& CTGitPathList::operator[](INT_PTR index) const
1326 {
1327         ATLASSERT(index >= 0 && index < (INT_PTR)m_paths.size());
1328         return m_paths[index];
1329 }
1330
1331 bool CTGitPathList::AreAllPathsFiles() const
1332 {
1333         // Look through the vector for any directories - if we find them, return false
1334         return std::find_if(m_paths.begin(), m_paths.end(), std::mem_fun_ref(&CTGitPath::IsDirectory)) == m_paths.end();
1335 }
1336
1337
1338 #if defined(_MFC_VER)
1339
1340 bool CTGitPathList::LoadFromFile(const CTGitPath& filename)
1341 {
1342         Clear();
1343         try
1344         {
1345                 CString strLine;
1346                 CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);
1347
1348                 // for every selected file/folder
1349                 CTGitPath path;
1350                 while (file.ReadString(strLine))
1351                 {
1352                         path.SetFromUnknown(strLine);
1353                         AddPath(path);
1354                 }
1355                 file.Close();
1356         }
1357         catch (CFileException* pE)
1358         {
1359                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading target file list\n");
1360                 TCHAR error[10000] = {0};
1361                 pE->GetErrorMessage(error, 10000);
1362 //              CMessageBox::Show(NULL, error, _T("TortoiseGit"), MB_ICONERROR);
1363                 pE->Delete();
1364                 return false;
1365         }
1366         return true;
1367 }
1368
1369 bool CTGitPathList::WriteToFile(const CString& sFilename, bool bANSI /* = false */) const
1370 {
1371         try
1372         {
1373                 if (bANSI)
1374                 {
1375                         CStdioFile file(sFilename, CFile::typeText | CFile::modeReadWrite | CFile::modeCreate);
1376                         PathVector::const_iterator it;
1377                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1378                         {
1379                                 CStringA line = CStringA(it->GetGitPathString()) + '\n';
1380                                 file.Write(line, line.GetLength());
1381                         }
1382                         file.Close();
1383                 }
1384                 else
1385                 {
1386                         CStdioFile file(sFilename, CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);
1387                         PathVector::const_iterator it;
1388                         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1389                         {
1390                                 file.WriteString(it->GetGitPathString()+_T("\n"));
1391                         }
1392                         file.Close();
1393                 }
1394         }
1395         catch (CFileException* pE)
1396         {
1397                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException in writing temp file\n");
1398                 pE->Delete();
1399                 return false;
1400         }
1401         return true;
1402 }
1403
1404
1405 void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString)
1406 {
1407         int pos = 0;
1408         CString temp;
1409         for(;;)
1410         {
1411                 temp = sPathString.Tokenize(_T("*"),pos);
1412                 if(temp.IsEmpty())
1413                 {
1414                         break;
1415                 }
1416                 AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));
1417         }
1418 }
1419
1420 CString CTGitPathList::CreateAsteriskSeparatedString() const
1421 {
1422         CString sRet;
1423         PathVector::const_iterator it;
1424         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1425         {
1426                 if (!sRet.IsEmpty())
1427                         sRet += _T("*");
1428                 sRet += it->GetWinPathString();
1429         }
1430         return sRet;
1431 }
1432 #endif // _MFC_VER
1433
1434 bool
1435 CTGitPathList::AreAllPathsFilesInOneDirectory() const
1436 {
1437         // Check if all the paths are files and in the same directory
1438         PathVector::const_iterator it;
1439         m_commonBaseDirectory.Reset();
1440         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1441         {
1442                 if(it->IsDirectory())
1443                 {
1444                         return false;
1445                 }
1446                 const CTGitPath& baseDirectory = it->GetDirectory();
1447                 if(m_commonBaseDirectory.IsEmpty())
1448                 {
1449                         m_commonBaseDirectory = baseDirectory;
1450                 }
1451                 else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1452                 {
1453                         // Different path
1454                         m_commonBaseDirectory.Reset();
1455                         return false;
1456                 }
1457         }
1458         return true;
1459 }
1460
1461 CTGitPath CTGitPathList::GetCommonDirectory() const
1462 {
1463         if (m_commonBaseDirectory.IsEmpty())
1464         {
1465                 PathVector::const_iterator it;
1466                 for(it = m_paths.begin(); it != m_paths.end(); ++it)
1467                 {
1468                         const CTGitPath& baseDirectory = it->GetDirectory();
1469                         if(m_commonBaseDirectory.IsEmpty())
1470                         {
1471                                 m_commonBaseDirectory = baseDirectory;
1472                         }
1473                         else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))
1474                         {
1475                                 // Different path
1476                                 m_commonBaseDirectory.Reset();
1477                                 break;
1478                         }
1479                 }
1480         }
1481         // since we only checked strings, not paths,
1482         // we have to make sure now that we really return a *path* here
1483         PathVector::const_iterator iter;
1484         for(iter = m_paths.begin(); iter != m_paths.end(); ++iter)
1485         {
1486                 if (!m_commonBaseDirectory.IsAncestorOf(*iter))
1487                 {
1488                         m_commonBaseDirectory = m_commonBaseDirectory.GetContainingDirectory();
1489                         break;
1490                 }
1491         }
1492         return m_commonBaseDirectory;
1493 }
1494
1495 CTGitPath CTGitPathList::GetCommonRoot() const
1496 {
1497         if (IsEmpty())
1498                 return CTGitPath();
1499
1500         if (GetCount() == 1)
1501                 return m_paths[0];
1502
1503         // first entry is common root for itself
1504         // (add trailing '\\' to detect partial matches of the last path element)
1505         CString root = m_paths[0].GetWinPathString() + _T('\\');
1506         int rootLength = root.GetLength();
1507
1508         // determine common path string prefix
1509         for (PathVector::const_iterator it = m_paths.begin() + 1; it != m_paths.end(); ++it)
1510         {
1511                 CString path = it->GetWinPathString() + _T('\\');
1512
1513                 int newLength = CStringUtils::GetMatchingLength(root, path);
1514                 if (newLength != rootLength)
1515                 {
1516                         root.Delete(newLength, rootLength);
1517                         rootLength = newLength;
1518                 }
1519         }
1520
1521         // remove the last (partial) path element
1522         if (rootLength > 0)
1523                 root.Delete(root.ReverseFind(_T('\\')), rootLength);
1524
1525         // done
1526         return CTGitPath(root);
1527 }
1528
1529 void CTGitPathList::SortByPathname(bool bReverse /*= false*/)
1530 {
1531         std::sort(m_paths.begin(), m_paths.end());
1532         if (bReverse)
1533                 std::reverse(m_paths.begin(), m_paths.end());
1534 }
1535
1536 void CTGitPathList::DeleteAllFiles(bool bTrash, bool bFilesOnly)
1537 {
1538         PathVector::const_iterator it;
1539         SortByPathname(true); // nested ones first
1540
1541         CString sPaths;
1542         for (it = m_paths.begin(); it != m_paths.end(); ++it)
1543         {
1544                 if ((it->Exists()) && ((it->IsDirectory() != bFilesOnly) || !bFilesOnly))
1545                 {
1546                         if (!it->IsDirectory())
1547                                 ::SetFileAttributes(it->GetWinPath(), FILE_ATTRIBUTE_NORMAL);
1548
1549                         sPaths += it->GetWinPath();
1550                         sPaths += '\0';
1551                 }
1552         }
1553         sPaths += '\0';
1554         sPaths += '\0';
1555         DeleteViaShell((LPCTSTR)sPaths, bTrash);
1556         Clear();
1557 }
1558
1559 bool CTGitPathList::DeleteViaShell(LPCTSTR path, bool bTrash)
1560 {
1561         SHFILEOPSTRUCT shop = {0};
1562         shop.wFunc = FO_DELETE;
1563         shop.pFrom = path;
1564         shop.fFlags = FOF_NOCONFIRMATION|FOF_NOERRORUI|FOF_SILENT|FOF_NO_CONNECTED_ELEMENTS;
1565         if (bTrash)
1566                 shop.fFlags |= FOF_ALLOWUNDO;
1567         const bool bRet = (SHFileOperation(&shop) == 0);
1568         return bRet;
1569 }
1570
1571 void CTGitPathList::RemoveDuplicates()
1572 {
1573         SortByPathname();
1574         // Remove the duplicates
1575         // (Unique moves them to the end of the vector, then erase chops them off)
1576         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::PredLeftEquivalentToRight), m_paths.end());
1577 }
1578
1579 void CTGitPathList::RemoveAdminPaths()
1580 {
1581         PathVector::iterator it;
1582         for(it = m_paths.begin(); it != m_paths.end(); )
1583         {
1584                 if (it->IsAdminDir())
1585                 {
1586                         m_paths.erase(it);
1587                         it = m_paths.begin();
1588                 }
1589                 else
1590                         ++it;
1591         }
1592 }
1593
1594 void CTGitPathList::RemovePath(const CTGitPath& path)
1595 {
1596         PathVector::iterator it;
1597         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1598         {
1599                 if (it->IsEquivalentTo(path))
1600                 {
1601                         m_paths.erase(it);
1602                         return;
1603                 }
1604         }
1605 }
1606
1607 void CTGitPathList::RemoveItem(CTGitPath & path)
1608 {
1609         PathVector::iterator it;
1610         for(it = m_paths.begin(); it != m_paths.end(); ++it)
1611         {
1612                 if (it->GetGitPathString()==path.GetGitPathString())
1613                 {
1614                         m_paths.erase(it);
1615                         return;
1616                 }
1617         }
1618 }
1619 void CTGitPathList::RemoveChildren()
1620 {
1621         SortByPathname();
1622         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::CheckChild), m_paths.end());
1623 }
1624
1625 bool CTGitPathList::IsEqual(const CTGitPathList& list)
1626 {
1627         if (list.GetCount() != GetCount())
1628                 return false;
1629         for (int i=0; i<list.GetCount(); ++i)
1630         {
1631                 if (!list[i].IsEquivalentTo(m_paths[i]))
1632                         return false;
1633         }
1634         return true;
1635 }
1636
1637 #if 0
1638 #if defined(_DEBUG)
1639 // Some test cases for these classes
1640 static class CTGitPathTests
1641 {
1642 public:
1643         CTGitPathTests()
1644         {
1645                 GetDirectoryTest();
1646                 AdminDirTest();
1647                 SortTest();
1648                 RawAppendTest();
1649                 PathAppendTest();
1650                 RemoveDuplicatesTest();
1651                 RemoveChildrenTest();
1652                 ContainingDirectoryTest();
1653                 AncestorTest();
1654                 SubversionPathTest();
1655                 GetCommonRootTest();
1656 #if defined(_MFC_VER)
1657                 ValidPathAndUrlTest();
1658                 ListLoadingTest();
1659 #endif
1660         }
1661
1662 private:
1663         void GetDirectoryTest()
1664         {
1665                 // Bit tricky, this test, because we need to know something about the file
1666                 // layout on the machine which is running the test
1667                 TCHAR winDir[MAX_PATH+1] = {0};
1668                 GetWindowsDirectory(winDir, MAX_PATH);
1669                 CString sWinDir(winDir);
1670
1671                 CTGitPath testPath;
1672                 // This is a file which we know will always be there
1673                 testPath.SetFromUnknown(sWinDir + _T("\\win.ini"));
1674                 ATLASSERT(!testPath.IsDirectory());
1675                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);
1676                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() == sWinDir);
1677
1678                 // Now do the test on the win directory itself - It's hard to be sure about the containing directory
1679                 // but we know it must be different to the directory itself
1680                 testPath.SetFromUnknown(sWinDir);
1681                 ATLASSERT(testPath.IsDirectory());
1682                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);
1683                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() != sWinDir);
1684                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString().GetLength() < sWinDir.GetLength());
1685
1686                 // Try a root path
1687                 testPath.SetFromUnknown(_T("C:\\"));
1688                 ATLASSERT(testPath.IsDirectory());
1689                 ATLASSERT(testPath.GetDirectory().GetWinPathString().CompareNoCase(_T("C:\\"))==0);
1690                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());
1691                 // Try a root UNC path
1692                 testPath.SetFromUnknown(_T("\\MYSTATION"));
1693                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());
1694         }
1695
1696         void AdminDirTest()
1697         {
1698                 CTGitPath testPath;
1699                 testPath.SetFromUnknown(_T("c:\\.svndir"));
1700                 ATLASSERT(!testPath.IsAdminDir());
1701                 testPath.SetFromUnknown(_T("c:\\test.svn"));
1702                 ATLASSERT(!testPath.IsAdminDir());
1703                 testPath.SetFromUnknown(_T("c:\\.svn"));
1704                 ATLASSERT(testPath.IsAdminDir());
1705                 testPath.SetFromUnknown(_T("c:\\.svndir\\test"));
1706                 ATLASSERT(!testPath.IsAdminDir());
1707                 testPath.SetFromUnknown(_T("c:\\.svn\\test"));
1708                 ATLASSERT(testPath.IsAdminDir());
1709
1710                 CTGitPathList pathList;
1711                 pathList.AddPath(CTGitPath(_T("c:\\.svndir")));
1712                 pathList.AddPath(CTGitPath(_T("c:\\.svn")));
1713                 pathList.AddPath(CTGitPath(_T("c:\\.svn\\test")));
1714                 pathList.AddPath(CTGitPath(_T("c:\\test")));
1715                 pathList.RemoveAdminPaths();
1716                 ATLASSERT(pathList.GetCount()==2);
1717                 pathList.Clear();
1718                 pathList.AddPath(CTGitPath(_T("c:\\test")));
1719                 pathList.RemoveAdminPaths();
1720                 ATLASSERT(pathList.GetCount()==1);
1721         }
1722
1723         void SortTest()
1724         {
1725                 CTGitPathList testList;
1726                 CTGitPath testPath;
1727                 testPath.SetFromUnknown(_T("c:/Z"));
1728                 testList.AddPath(testPath);
1729                 testPath.SetFromUnknown(_T("c:/B"));
1730                 testList.AddPath(testPath);
1731                 testPath.SetFromUnknown(_T("c:\\a"));
1732                 testList.AddPath(testPath);
1733                 testPath.SetFromUnknown(_T("c:/Test"));
1734                 testList.AddPath(testPath);
1735
1736                 testList.SortByPathname();
1737
1738                 ATLASSERT(testList[0].GetWinPathString() == _T("c:\\a"));
1739                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\B"));
1740                 ATLASSERT(testList[2].GetWinPathString() == _T("c:\\Test"));
1741                 ATLASSERT(testList[3].GetWinPathString() == _T("c:\\Z"));
1742         }
1743
1744         void RawAppendTest()
1745         {
1746                 CTGitPath testPath(_T("c:/test/"));
1747                 testPath.AppendRawString(_T("/Hello"));
1748                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));
1749
1750                 testPath.AppendRawString(_T("\\T2"));
1751                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));
1752
1753                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));
1754                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));
1755                 testBasePath.AppendRawString(testFilePath.GetFileExtension());
1756                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt.ini"));
1757         }
1758
1759         void PathAppendTest()
1760         {
1761                 CTGitPath testPath(_T("c:/test/"));
1762                 testPath.AppendPathString(_T("/Hello"));
1763                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));
1764
1765                 testPath.AppendPathString(_T("T2"));
1766                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));
1767
1768                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));
1769                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));
1770                 // You wouldn't want to do this in real life - you'd use append-raw
1771                 testBasePath.AppendPathString(testFilePath.GetFileExtension());
1772                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt\\.ini"));
1773         }
1774
1775         void RemoveDuplicatesTest()
1776         {
1777                 CTGitPathList list;
1778                 list.AddPath(CTGitPath(_T("Z")));
1779                 list.AddPath(CTGitPath(_T("A")));
1780                 list.AddPath(CTGitPath(_T("E")));
1781                 list.AddPath(CTGitPath(_T("E")));
1782
1783                 ATLASSERT(list[2].IsEquivalentTo(list[3]));
1784                 ATLASSERT(list[2]==list[3]);
1785
1786                 ATLASSERT(list.GetCount() == 4);
1787
1788                 list.RemoveDuplicates();
1789
1790                 ATLASSERT(list.GetCount() == 3);
1791
1792                 ATLASSERT(list[0].GetWinPathString() == _T("A"));
1793                 ATLASSERT(list[1].GetWinPathString().Compare(_T("E")) == 0);
1794                 ATLASSERT(list[2].GetWinPathString() == _T("Z"));
1795         }
1796
1797         void RemoveChildrenTest()
1798         {
1799                 CTGitPathList list;
1800                 list.AddPath(CTGitPath(_T("c:\\test")));
1801                 list.AddPath(CTGitPath(_T("c:\\test\\file")));
1802                 list.AddPath(CTGitPath(_T("c:\\testfile")));
1803                 list.AddPath(CTGitPath(_T("c:\\parent")));
1804                 list.AddPath(CTGitPath(_T("c:\\parent\\child")));
1805                 list.AddPath(CTGitPath(_T("c:\\parent\\child1")));
1806                 list.AddPath(CTGitPath(_T("c:\\parent\\child2")));
1807
1808                 ATLASSERT(list.GetCount() == 7);
1809
1810                 list.RemoveChildren();
1811
1812                 ATLTRACE("count = %d\n", list.GetCount());
1813                 ATLASSERT(list.GetCount() == 3);
1814
1815                 list.SortByPathname();
1816
1817                 ATLASSERT(list[0].GetWinPathString().Compare(_T("c:\\parent")) == 0);
1818                 ATLASSERT(list[1].GetWinPathString().Compare(_T("c:\\test")) == 0);
1819                 ATLASSERT(list[2].GetWinPathString().Compare(_T("c:\\testfile")) == 0);
1820         }
1821
1822 #if defined(_MFC_VER)
1823         void ListLoadingTest()
1824         {
1825                 TCHAR buf[MAX_PATH] = {0};
1826                 GetCurrentDirectory(MAX_PATH, buf);
1827                 CString sPathList(_T("Path1*c:\\path2 with spaces and stuff*\\funnypath\\*"));
1828                 CTGitPathList testList;
1829                 testList.LoadFromAsteriskSeparatedString(sPathList);
1830
1831                 ATLASSERT(testList.GetCount() == 3);
1832                 ATLASSERT(testList[0].GetWinPathString() == CString(buf) + _T("\\Path1"));
1833                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\path2 with spaces and stuff"));
1834                 ATLASSERT(testList[2].GetWinPathString() == _T("\\funnypath"));
1835
1836                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T(""));
1837                 testList.Clear();
1838                 sPathList = _T("c:\\path2 with spaces and stuff*c:\\funnypath\\*");
1839                 testList.LoadFromAsteriskSeparatedString(sPathList);
1840                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T("c:\\"));
1841         }
1842 #endif
1843
1844         void ContainingDirectoryTest()
1845         {
1846
1847                 CTGitPath testPath;
1848                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));
1849                 CTGitPath dir;
1850                 dir = testPath.GetContainingDirectory();
1851                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c\\d"));
1852                 dir = dir.GetContainingDirectory();
1853                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c"));
1854                 dir = dir.GetContainingDirectory();
1855                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b"));
1856                 dir = dir.GetContainingDirectory();
1857                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a"));
1858                 dir = dir.GetContainingDirectory();
1859                 ATLASSERT(dir.GetWinPathString() == _T("c:\\"));
1860                 dir = dir.GetContainingDirectory();
1861                 ATLASSERT(dir.IsEmpty());
1862                 ATLASSERT(dir.GetWinPathString() == _T(""));
1863         }
1864
1865         void AncestorTest()
1866         {
1867                 CTGitPath testPath;
1868                 testPath.SetFromWin(_T("c:\\windows"));
1869                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\")))==false);
1870                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows"))));
1871                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windowsdummy")))==false);
1872                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\test.txt"))));
1873                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\system32\\test.txt"))));
1874         }
1875
1876         void SubversionPathTest()
1877         {
1878                 CTGitPath testPath;
1879                 testPath.SetFromWin(_T("c:\\"));
1880                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:") == 0);
1881                 testPath.SetFromWin(_T("c:\\folder"));
1882                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/folder") == 0);
1883                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));
1884                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/a/b/c/d/e") == 0);
1885                 testPath.SetFromUnknown(_T("http://testing/"));
1886                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing") == 0);
1887                 testPath.SetFromGit(NULL);
1888                 ATLASSERT(strlen(testPath.GetGitApiPath(pool))==0);
1889 #if defined(_MFC_VER)
1890                 testPath.SetFromUnknown(_T("http://testing again"));
1891                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);
1892                 testPath.SetFromUnknown(_T("http://testing%20again"));
1893                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);
1894                 testPath.SetFromUnknown(_T("http://testing special chars \344\366\374"));
1895                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20special%20chars%20%c3%a4%c3%b6%c3%bc") == 0);
1896 #endif
1897         }
1898
1899         void GetCommonRootTest()
1900         {
1901                 CTGitPath pathA (_T("C:\\Development\\LogDlg.cpp"));
1902                 CTGitPath pathB (_T("C:\\Development\\LogDlg.h"));
1903                 CTGitPath pathC (_T("C:\\Development\\SomeDir\\LogDlg.h"));
1904
1905                 CTGitPathList list;
1906                 list.AddPath(pathA);
1907                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development\\LogDlg.cpp"))==0);
1908                 list.AddPath(pathB);
1909                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);
1910                 list.AddPath(pathC);
1911                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);
1912 #ifdef _MFC_VER
1913                 list.Clear();
1914                 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");
1915                 list.LoadFromAsteriskSeparatedString(sPathList);
1916                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("D:\\Development\\StExBar"))==0);
1917
1918                 list.Clear();
1919                 sPathList = _T("c:\\windows\\explorer.exe*c:\\windows");
1920                 list.LoadFromAsteriskSeparatedString(sPathList);
1921                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1922
1923                 list.Clear();
1924                 sPathList = _T("c:\\windows\\*c:\\windows");
1925                 list.LoadFromAsteriskSeparatedString(sPathList);
1926                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1927
1928                 list.Clear();
1929                 sPathList = _T("c:\\windows\\system32*c:\\windows\\system");
1930                 list.LoadFromAsteriskSeparatedString(sPathList);
1931                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);
1932
1933                 list.Clear();
1934                 sPathList = _T("c:\\windowsdummy*c:\\windows");
1935                 list.LoadFromAsteriskSeparatedString(sPathList);
1936                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\"))==0);
1937 #endif
1938         }
1939
1940         void ValidPathAndUrlTest()
1941         {
1942                 CTGitPath testPath;
1943                 testPath.SetFromWin(_T("c:\\a\\b\\c.test.txt"));
1944                 ATLASSERT(testPath.IsValidOnWindows());
1945                 testPath.SetFromWin(_T("c:\\"));
1946                 ATLASSERT(testPath.IsValidOnWindows());
1947                 testPath.SetFromWin(_T("D:\\.Net\\SpindleSearch\\"));
1948                 ATLASSERT(testPath.IsValidOnWindows());
1949                 testPath.SetFromWin(_T("c"));
1950                 ATLASSERT(testPath.IsValidOnWindows());
1951                 testPath.SetFromWin(_T("c:\\test folder\\file"));
1952                 ATLASSERT(testPath.IsValidOnWindows());
1953                 testPath.SetFromWin(_T("c:\\folder\\"));
1954                 ATLASSERT(testPath.IsValidOnWindows());
1955                 testPath.SetFromWin(_T("c:\\ext.ext.ext\\ext.ext.ext.ext"));
1956                 ATLASSERT(testPath.IsValidOnWindows());
1957                 testPath.SetFromWin(_T("c:\\.svn"));
1958                 ATLASSERT(testPath.IsValidOnWindows());
1959                 testPath.SetFromWin(_T("c:\\com\\file"));
1960                 ATLASSERT(testPath.IsValidOnWindows());
1961                 testPath.SetFromWin(_T("c:\\test\\conf"));
1962                 ATLASSERT(testPath.IsValidOnWindows());
1963                 testPath.SetFromWin(_T("c:\\LPT"));
1964                 ATLASSERT(testPath.IsValidOnWindows());
1965                 testPath.SetFromWin(_T("c:\\test\\LPT"));
1966                 ATLASSERT(testPath.IsValidOnWindows());
1967                 testPath.SetFromWin(_T("c:\\com1test"));
1968                 ATLASSERT(testPath.IsValidOnWindows());
1969                 testPath.SetFromWin(_T("\\\\?\\c:\\test\\com1test"));
1970                 ATLASSERT(testPath.IsValidOnWindows());
1971
1972                 testPath.SetFromWin(_T("\\\\Share\\filename"));
1973                 ATLASSERT(testPath.IsValidOnWindows());
1974                 testPath.SetFromWin(_T("\\\\Share\\filename.extension"));
1975                 ATLASSERT(testPath.IsValidOnWindows());
1976                 testPath.SetFromWin(_T("\\\\Share\\.svn"));
1977                 ATLASSERT(testPath.IsValidOnWindows());
1978
1979                 // now the negative tests
1980                 testPath.SetFromWin(_T("c:\\test:folder"));
1981                 ATLASSERT(!testPath.IsValidOnWindows());
1982                 testPath.SetFromWin(_T("c:\\file<name"));
1983                 ATLASSERT(!testPath.IsValidOnWindows());
1984                 testPath.SetFromWin(_T("c:\\something*else"));
1985                 ATLASSERT(!testPath.IsValidOnWindows());
1986                 testPath.SetFromWin(_T("c:\\folder\\file?nofile"));
1987                 ATLASSERT(!testPath.IsValidOnWindows());
1988                 testPath.SetFromWin(_T("c:\\ext.>ension"));
1989                 ATLASSERT(!testPath.IsValidOnWindows());
1990                 testPath.SetFromWin(_T("c:\\com1\\filename"));
1991                 ATLASSERT(!testPath.IsValidOnWindows());
1992                 testPath.SetFromWin(_T("c:\\com1"));
1993                 ATLASSERT(!testPath.IsValidOnWindows());
1994                 testPath.SetFromWin(_T("c:\\com1\\AuX"));
1995                 ATLASSERT(!testPath.IsValidOnWindows());
1996
1997                 testPath.SetFromWin(_T("\\\\Share\\lpt9\\filename"));
1998                 ATLASSERT(!testPath.IsValidOnWindows());
1999                 testPath.SetFromWin(_T("\\\\Share\\prn"));
2000                 ATLASSERT(!testPath.IsValidOnWindows());
2001                 testPath.SetFromWin(_T("\\\\Share\\NUL"));
2002                 ATLASSERT(!testPath.IsValidOnWindows());
2003
2004                 // now come some URL tests
2005                 testPath.SetFromGit(_T("http://myserver.com/repos/trunk"));
2006                 ATLASSERT(testPath.IsValidOnWindows());
2007                 testPath.SetFromGit(_T("https://myserver.com/repos/trunk/file%20with%20spaces"));
2008                 ATLASSERT(testPath.IsValidOnWindows());
2009                 testPath.SetFromGit(_T("svn://myserver.com/repos/trunk/file with spaces"));
2010                 ATLASSERT(testPath.IsValidOnWindows());
2011                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk"));
2012                 ATLASSERT(testPath.IsValidOnWindows());
2013                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk"));
2014                 ATLASSERT(testPath.IsValidOnWindows());
2015                 testPath.SetFromGit(_T("file:///C:/GitRepos/Tester/Proj1/tags/t2"));
2016                 ATLASSERT(testPath.IsValidOnWindows());
2017                 // and some negative URL tests
2018                 testPath.SetFromGit(_T("httpp://myserver.com/repos/trunk"));
2019                 ATLASSERT(!testPath.IsValidOnWindows());
2020                 testPath.SetFromGit(_T("https://myserver.com/rep:os/trunk/file%20with%20spaces"));
2021                 ATLASSERT(!testPath.IsValidOnWindows());
2022                 testPath.SetFromGit(_T("svn://myserver.com/rep<os/trunk/file with spaces"));
2023                 ATLASSERT(!testPath.IsValidOnWindows());
2024                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk/prn/"));
2025                 ATLASSERT(!testPath.IsValidOnWindows());
2026                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk/com1"));
2027                 ATLASSERT(!testPath.IsValidOnWindows());
2028
2029         }
2030
2031 } TGitPathTestobject;
2032 #endif
2033 #endif
2034
2035 CTGitPath * CTGitPathList::LookForGitPath(CString path)
2036 {
2037         int i=0;
2038         for (i = 0; i < this->GetCount(); ++i)
2039         {
2040                 if((*this)[i].GetGitPathString() == path )
2041                         return (CTGitPath*)&(*this)[i];
2042         }
2043         return NULL;
2044 }
2045 CString CTGitPath::GetActionName(int action)
2046 {
2047         if(action  & CTGitPath::LOGACTIONS_UNMERGED)
2048                 return MAKEINTRESOURCE(IDS_PATHACTIONS_CONFLICT);
2049         if(action  & CTGitPath::LOGACTIONS_ADDED)
2050                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ADD);
2051         if(action  & CTGitPath::LOGACTIONS_DELETED)
2052                 return MAKEINTRESOURCE(IDS_PATHACTIONS_DELETE);
2053         if(action  & CTGitPath::LOGACTIONS_MERGED )
2054                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MERGED);
2055
2056         if(action  & CTGitPath::LOGACTIONS_MODIFIED)
2057                 return MAKEINTRESOURCE(IDS_PATHACTIONS_MODIFIED);
2058         if(action  & CTGitPath::LOGACTIONS_REPLACED)
2059                 return MAKEINTRESOURCE(IDS_PATHACTIONS_RENAME);
2060         if(action  & CTGitPath::LOGACTIONS_COPY)
2061                 return MAKEINTRESOURCE(IDS_PATHACTIONS_COPY);
2062
2063         if(action  & CTGitPath::LOGACTIONS_FORWORD )
2064                 return MAKEINTRESOURCE(IDS_PATHACTIONS_FORWARD);
2065
2066         if (action & CTGitPath::LOGACTIONS_ASSUMEVALID)
2067                 return MAKEINTRESOURCE(IDS_PATHACTIONS_ASSUMEUNCHANGED);
2068         if (action & CTGitPath::LOGACTIONS_SKIPWORKTREE)
2069                 return MAKEINTRESOURCE(IDS_PATHACTIONS_SKIPWORKTREE);
2070
2071         return MAKEINTRESOURCE(IDS_PATHACTIONS_UNKNOWN);
2072 }
2073 CString CTGitPath::GetActionName()
2074 {
2075         return GetActionName(m_Action);
2076 }
2077
2078 int CTGitPathList::GetAction()
2079 {
2080         return m_Action;
2081 }
2082