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