src/Git/TGitPath.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control\r
   2 \r
   3 // Copyright (C) 2003-2008 - TortoiseGit\r
   4 \r
   5 // This program is free software; you can redistribute it and/or\r
   6 // modify it under the terms of the GNU General Public License\r
   7 // as published by the Free Software Foundation; either version 2\r
   8 // of the License, or (at your option) any later version.\r
   9 \r
  10 // This program is distributed in the hope that it will be useful,\r
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 // GNU General Public License for more details.\r
  14 \r
  15 // You should have received a copy of the GNU General Public License\r
  16 // along with this program; if not, write to the Free Software Foundation,\r
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
  18 //\r
  19 #include "StdAfx.h"\r
  20 #include "TGitPath.h"\r
  21 #include "UnicodeUtils.h"\r
  22 #include "GitAdminDir.h"\r
  23 #include "PathUtils.h"\r
  24 #include <regex>\r
  25 #include "git.h"\r
  26 #if defined(_MFC_VER)\r
  27 //#include "MessageBox.h"\r
  28 //#include "AppUtils.h"\r
  29 #endif\r
  30 \r
  31 #ifndef ASSERT\r
  32 #define ASSERT()\r
  33 #endif\r
  34 using namespace std;\r
  35 extern CGit g_Git;\r
  36 \r
  37 CTGitPath::CTGitPath(void) :\r
  38         m_bDirectoryKnown(false),\r
  39         m_bIsDirectory(false),\r
  40         m_bIsURL(false),\r
  41         m_bURLKnown(false),\r
  42         m_bHasAdminDirKnown(false),\r
  43         m_bHasAdminDir(false),\r
  44         m_bIsValidOnWindowsKnown(false),\r
  45         m_bIsReadOnly(false),\r
  46         m_bIsAdminDirKnown(false),\r
  47         m_bIsAdminDir(false),\r
  48         m_bExists(false),\r
  49         m_bExistsKnown(false),\r
  50         m_bLastWriteTimeKnown(0),\r
  51         m_lastWriteTime(0),\r
  52         m_customData(NULL),\r
  53         m_bIsSpecialDirectoryKnown(false),\r
  54         m_bIsSpecialDirectory(false)\r
  55 {\r
  56         m_Action=0;\r
  57 }\r
  58 \r
  59 CTGitPath::~CTGitPath(void)\r
  60 {\r
  61 }\r
  62 // Create a TGitPath object from an unknown path type (same as using SetFromUnknown)\r
  63 CTGitPath::CTGitPath(const CString& sUnknownPath) :\r
  64         m_bDirectoryKnown(false),\r
  65         m_bIsDirectory(false),\r
  66         m_bIsURL(false),\r
  67         m_bURLKnown(false),\r
  68         m_bHasAdminDirKnown(false),\r
  69         m_bHasAdminDir(false),\r
  70         m_bIsValidOnWindowsKnown(false),\r
  71         m_bIsReadOnly(false),\r
  72         m_bIsAdminDirKnown(false),\r
  73         m_bIsAdminDir(false),\r
  74         m_bExists(false),\r
  75         m_bExistsKnown(false),\r
  76         m_bLastWriteTimeKnown(0),\r
  77         m_lastWriteTime(0),\r
  78         m_customData(NULL),\r
  79         m_bIsSpecialDirectoryKnown(false),\r
  80         m_bIsSpecialDirectory(false)\r
  81 {\r
  82         SetFromUnknown(sUnknownPath);\r
  83         m_Action=0;\r
  84 }\r
  85 \r
  86 int CTGitPath::ParserAction(CString action)\r
  87 {\r
  88         action=action.TrimLeft();\r
  89         TCHAR c=action.GetAt(0);\r
  90         if(c == _T('M'))\r
  91                 m_Action|= LOGACTIONS_MODIFIED;\r
  92         if(c == _T('R'))\r
  93                 m_Action|= LOGACTIONS_REPLACED;\r
  94         if(c == _T('A'))\r
  95                 m_Action|= LOGACTIONS_ADDED;\r
  96         if(c == _T('D'))\r
  97                 m_Action|= LOGACTIONS_DELETED;\r
  98 \r
  99         return m_Action;\r
 100 }\r
 101 void CTGitPath::SetFromGit(const char* pPath)\r
 102 {\r
 103         Reset();\r
 104         if (pPath == NULL)\r
 105                 return;\r
 106         int len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, NULL, 0);\r
 107         if (len)\r
 108         {\r
 109                 len = MultiByteToWideChar(CP_UTF8, 0, pPath, -1, m_sFwdslashPath.GetBuffer(len+1), len+1);\r
 110                 m_sFwdslashPath.ReleaseBuffer(len-1);\r
 111         }\r
 112         SanitizeRootPath(m_sFwdslashPath, true);\r
 113 }\r
 114 \r
 115 void CTGitPath::SetFromGit(const char* pPath, bool bIsDirectory)\r
 116 {\r
 117         SetFromGit(pPath);\r
 118         m_bDirectoryKnown = true;\r
 119         m_bIsDirectory = bIsDirectory;\r
 120 }\r
 121 \r
 122 void CTGitPath::SetFromGit(const CString& sPath,CString *oldpath)\r
 123 {\r
 124         Reset();\r
 125         m_sFwdslashPath = sPath;\r
 126         SanitizeRootPath(m_sFwdslashPath, true);\r
 127         if(oldpath)\r
 128                 m_sOldFwdslashPath = *oldpath;\r
 129 }\r
 130 \r
 131 void CTGitPath::SetFromWin(LPCTSTR pPath)\r
 132 {\r
 133         Reset();\r
 134         m_sBackslashPath = pPath;\r
 135         SanitizeRootPath(m_sBackslashPath, false);\r
 136         ATLASSERT(m_sBackslashPath.Find('/')<0);\r
 137 }\r
 138 void CTGitPath::SetFromWin(const CString& sPath)\r
 139 {\r
 140         Reset();\r
 141         m_sBackslashPath = sPath;\r
 142         SanitizeRootPath(m_sBackslashPath, false);\r
 143 }\r
 144 void CTGitPath::SetFromWin(const CString& sPath, bool bIsDirectory)\r
 145 {\r
 146         Reset();\r
 147         m_sBackslashPath = sPath;\r
 148         m_bIsDirectory = bIsDirectory;\r
 149         m_bDirectoryKnown = true;\r
 150         SanitizeRootPath(m_sBackslashPath, false);\r
 151 }\r
 152 void CTGitPath::SetFromUnknown(const CString& sPath)\r
 153 {\r
 154         Reset();\r
 155         // Just set whichever path we think is most likely to be used\r
 156 //      GitAdminDir admin;\r
 157 //      CString p;\r
 158 //      if(admin.HasAdminDir(sPath,&p))\r
 159 //              SetFwdslashPath(sPath.Right(sPath.GetLength()-p.GetLength()));\r
 160 //      else\r
 161                 SetFwdslashPath(sPath);\r
 162 }\r
 163 \r
 164 LPCTSTR CTGitPath::GetWinPath() const\r
 165 {\r
 166         if(IsEmpty())\r
 167         {\r
 168                 return _T("");\r
 169         }\r
 170         if(m_sBackslashPath.IsEmpty())\r
 171         {\r
 172                 SetBackslashPath(m_sFwdslashPath);\r
 173         }\r
 174         return m_sBackslashPath;\r
 175 }\r
 176 // This is a temporary function, to be used during the migration to \r
 177 // the path class.  Ultimately, functions consuming paths should take a CTGitPath&, not a CString\r
 178 const CString& CTGitPath::GetWinPathString() const\r
 179 {\r
 180         if(m_sBackslashPath.IsEmpty())\r
 181         {\r
 182                 SetBackslashPath(m_sFwdslashPath);\r
 183         }\r
 184         return m_sBackslashPath;\r
 185 }\r
 186 \r
 187 const CString& CTGitPath::GetGitPathString() const\r
 188 {\r
 189         if(m_sFwdslashPath.IsEmpty())\r
 190         {\r
 191                 SetFwdslashPath(m_sBackslashPath);\r
 192         }\r
 193         return m_sFwdslashPath;\r
 194 }\r
 195 \r
 196 const CString &CTGitPath::GetGitOldPathString() const\r
 197 {\r
 198         return m_sOldFwdslashPath;\r
 199 }\r
 200 #if 0\r
 201 const char* CTGitPath::GetGitApiPath(apr_pool_t *pool) const\r
 202 {\r
 203         // This funny-looking 'if' is to avoid a subtle problem with empty paths, whereby\r
 204         // each call to GetGitApiPath returns a different pointer value.\r
 205         // If you made multiple calls to GetGitApiPath on the same string, only the last\r
 206         // one would give you a valid pointer to an empty string, because each \r
 207         // call would invalidate the previous call's return. \r
 208         if(IsEmpty())\r
 209         {\r
 210                 return "";\r
 211         }\r
 212         if(m_sFwdslashPath.IsEmpty())\r
 213         {\r
 214                 SetFwdslashPath(m_sBackslashPath);\r
 215         }\r
 216         if(m_sUTF8FwdslashPath.IsEmpty())\r
 217         {\r
 218                 SetUTF8FwdslashPath(m_sFwdslashPath);\r
 219         }\r
 220         if (svn_path_is_url(m_sUTF8FwdslashPath))\r
 221         {\r
 222                 m_sUTF8FwdslashPathEscaped = CPathUtils::PathEscape(m_sUTF8FwdslashPath);\r
 223                 m_sUTF8FwdslashPathEscaped.Replace("file:////", "file:///\\");\r
 224                 m_sUTF8FwdslashPathEscaped = svn_path_canonicalize(m_sUTF8FwdslashPathEscaped, pool);\r
 225                 return m_sUTF8FwdslashPathEscaped;\r
 226         }\r
 227         m_sUTF8FwdslashPath = svn_path_canonicalize(m_sUTF8FwdslashPath, pool);\r
 228 \r
 229         return m_sUTF8FwdslashPath;\r
 230 }\r
 231 #endif\r
 232 \r
 233 const CString& CTGitPath::GetUIPathString() const\r
 234 {\r
 235         if (m_sUIPath.IsEmpty())\r
 236         {\r
 237 #if defined(_MFC_VER)\r
 238                 //BUGBUG HORRIBLE!!! - CPathUtils::IsEscaped doesn't need to be MFC-only\r
 239                 if (IsUrl())\r
 240                 {\r
 241                         m_sUIPath = CPathUtils::PathUnescape(GetGitPathString());\r
 242                         m_sUIPath.Replace(_T("file:////"), _T("file:///\\"));\r
 243 \r
 244                 }\r
 245                 else\r
 246 #endif \r
 247                 {\r
 248                         m_sUIPath = GetWinPathString();\r
 249                 }\r
 250         }\r
 251         return m_sUIPath;\r
 252 }\r
 253 \r
 254 void CTGitPath::SetFwdslashPath(const CString& sPath) const\r
 255 {\r
 256         m_sFwdslashPath = sPath;\r
 257         m_sFwdslashPath.Replace('\\', '/');\r
 258 \r
 259         // We don't leave a trailing /\r
 260         m_sFwdslashPath.TrimRight('/'); \r
 261 \r
 262         SanitizeRootPath(m_sFwdslashPath, true);\r
 263 \r
 264         m_sFwdslashPath.Replace(_T("file:////"), _T("file:///\\"));\r
 265 \r
 266         m_sUTF8FwdslashPath.Empty();\r
 267 }\r
 268 \r
 269 void CTGitPath::SetBackslashPath(const CString& sPath) const\r
 270 {\r
 271         m_sBackslashPath = sPath;\r
 272         m_sBackslashPath.Replace('/', '\\');\r
 273         m_sBackslashPath.TrimRight('\\');\r
 274         SanitizeRootPath(m_sBackslashPath, false);\r
 275 }\r
 276 \r
 277 void CTGitPath::SetUTF8FwdslashPath(const CString& sPath) const\r
 278 {\r
 279         m_sUTF8FwdslashPath = CUnicodeUtils::GetUTF8(sPath);\r
 280 }\r
 281 \r
 282 void CTGitPath::SanitizeRootPath(CString& sPath, bool bIsForwardPath) const\r
 283 {\r
 284         // Make sure to add the trailing slash to root paths such as 'C:'\r
 285         if (sPath.GetLength() == 2 && sPath[1] == ':')\r
 286         {\r
 287                 sPath += (bIsForwardPath) ? _T("/") : _T("\\");\r
 288         }\r
 289 }\r
 290 \r
 291 bool CTGitPath::IsUrl() const\r
 292 {\r
 293 #if 0\r
 294         if (!m_bURLKnown)\r
 295         {\r
 296                 EnsureFwdslashPathSet();\r
 297                 if(m_sUTF8FwdslashPath.IsEmpty())\r
 298                 {\r
 299                         SetUTF8FwdslashPath(m_sFwdslashPath);\r
 300                 }\r
 301                 m_bIsURL = !!svn_path_is_url(m_sUTF8FwdslashPath);\r
 302                 m_bURLKnown = true;\r
 303         }\r
 304         return m_bIsURL;\r
 305 #endif \r
 306         return false;\r
 307 }\r
 308 \r
 309 bool CTGitPath::IsDirectory() const\r
 310 {\r
 311         if(!m_bDirectoryKnown)\r
 312         {\r
 313                 UpdateAttributes();\r
 314         }\r
 315         return m_bIsDirectory;\r
 316 }\r
 317 \r
 318 bool CTGitPath::Exists() const\r
 319 {\r
 320         if (!m_bExistsKnown)\r
 321         {\r
 322                 UpdateAttributes();\r
 323         }\r
 324         return m_bExists;\r
 325 }\r
 326 \r
 327 bool CTGitPath::Delete(bool bTrash) const\r
 328 {\r
 329         EnsureBackslashPathSet();\r
 330         ::SetFileAttributes(m_sBackslashPath, FILE_ATTRIBUTE_NORMAL);\r
 331         bool bRet = false;\r
 332         if (Exists())\r
 333         {\r
 334                 if ((bTrash)||(IsDirectory()))\r
 335                 {\r
 336                         TCHAR * buf = new TCHAR[m_sBackslashPath.GetLength()+2];\r
 337                         _tcscpy_s(buf, m_sBackslashPath.GetLength()+2, m_sBackslashPath);\r
 338                         buf[m_sBackslashPath.GetLength()] = 0;\r
 339                         buf[m_sBackslashPath.GetLength()+1] = 0;\r
 340                         SHFILEOPSTRUCT shop = {0};\r
 341                         shop.wFunc = FO_DELETE;\r
 342                         shop.pFrom = buf;\r
 343                         shop.fFlags = FOF_NOCONFIRMATION|FOF_NOERRORUI|FOF_SILENT;\r
 344                         if (bTrash)\r
 345                                 shop.fFlags |= FOF_ALLOWUNDO;\r
 346                         bRet = (SHFileOperation(&shop) == 0);\r
 347                         delete [] buf;\r
 348                 }\r
 349                 else\r
 350                 {\r
 351                         bRet = !!::DeleteFile(m_sBackslashPath);\r
 352                 }\r
 353         }\r
 354         m_bExists = false;\r
 355         m_bExistsKnown = true;\r
 356         return bRet;\r
 357 }\r
 358 \r
 359 __int64  CTGitPath::GetLastWriteTime() const\r
 360 {\r
 361         if(!m_bLastWriteTimeKnown)\r
 362         {\r
 363                 UpdateAttributes();\r
 364         }\r
 365         return m_lastWriteTime;\r
 366 }\r
 367 \r
 368 bool CTGitPath::IsReadOnly() const\r
 369 {\r
 370         if(!m_bLastWriteTimeKnown)\r
 371         {\r
 372                 UpdateAttributes();\r
 373         }\r
 374         return m_bIsReadOnly;\r
 375 }\r
 376 \r
 377 void CTGitPath::UpdateAttributes() const\r
 378 {\r
 379         EnsureBackslashPathSet();\r
 380         WIN32_FILE_ATTRIBUTE_DATA attribs;\r
 381         if(GetFileAttributesEx(m_sBackslashPath, GetFileExInfoStandard, &attribs))\r
 382         {\r
 383                 m_bIsDirectory = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);\r
 384                 m_lastWriteTime = *(__int64*)&attribs.ftLastWriteTime;\r
 385                 m_bIsReadOnly = !!(attribs.dwFileAttributes & FILE_ATTRIBUTE_READONLY);\r
 386                 m_bExists = true;\r
 387         }\r
 388         else\r
 389         {\r
 390                 DWORD err = GetLastError();\r
 391                 if ((err == ERROR_FILE_NOT_FOUND)||(err == ERROR_PATH_NOT_FOUND)||(err == ERROR_INVALID_NAME))\r
 392                 {\r
 393                         m_bIsDirectory = false;\r
 394                         m_lastWriteTime = 0;\r
 395                         m_bExists = false;\r
 396                 }\r
 397                 else\r
 398                 {\r
 399                         m_bIsDirectory = false;\r
 400                         m_lastWriteTime = 0;\r
 401                         m_bExists = true;\r
 402                         return;\r
 403                 }\r
 404         }\r
 405         m_bDirectoryKnown = true;\r
 406         m_bLastWriteTimeKnown = true;\r
 407         m_bExistsKnown = true;\r
 408 }\r
 409 \r
 410 \r
 411 void CTGitPath::EnsureBackslashPathSet() const\r
 412 {\r
 413         if(m_sBackslashPath.IsEmpty())\r
 414         {\r
 415                 SetBackslashPath(m_sFwdslashPath);\r
 416                 ATLASSERT(IsEmpty() || !m_sBackslashPath.IsEmpty());\r
 417         }\r
 418 }\r
 419 void CTGitPath::EnsureFwdslashPathSet() const\r
 420 {\r
 421         if(m_sFwdslashPath.IsEmpty())\r
 422         {\r
 423                 SetFwdslashPath(m_sBackslashPath);\r
 424                 ATLASSERT(IsEmpty() || !m_sFwdslashPath.IsEmpty());\r
 425         }\r
 426 }\r
 427 \r
 428 \r
 429 // Reset all the caches\r
 430 void CTGitPath::Reset()\r
 431 {\r
 432         m_bDirectoryKnown = false;\r
 433         m_bURLKnown = false;\r
 434         m_bLastWriteTimeKnown = false;\r
 435         m_bHasAdminDirKnown = false;\r
 436         m_bIsValidOnWindowsKnown = false;\r
 437         m_bIsAdminDirKnown = false;\r
 438         m_bExistsKnown = false;\r
 439         m_bIsSpecialDirectoryKnown = false;\r
 440         m_bIsSpecialDirectory = false;\r
 441 \r
 442         m_sBackslashPath.Empty();\r
 443         m_sFwdslashPath.Empty();\r
 444         m_sUTF8FwdslashPath.Empty();\r
 445         this->m_Action=0;\r
 446         this->m_StatAdd=_T("");\r
 447         this->m_StatDel=_T("");\r
 448         ATLASSERT(IsEmpty());\r
 449 }\r
 450 \r
 451 CTGitPath CTGitPath::GetDirectory() const\r
 452 {\r
 453         if ((IsDirectory())||(!Exists()))\r
 454         {\r
 455                 return *this;\r
 456         }\r
 457         return GetContainingDirectory();\r
 458 }\r
 459 \r
 460 CTGitPath CTGitPath::GetContainingDirectory() const\r
 461 {\r
 462         EnsureBackslashPathSet();\r
 463 \r
 464         CString sDirName = m_sBackslashPath.Left(m_sBackslashPath.ReverseFind('\\'));\r
 465         if(sDirName.GetLength() == 2 && sDirName[1] == ':')\r
 466         {\r
 467                 // This is a root directory, which needs a trailing slash\r
 468                 sDirName += '\\';\r
 469                 if(sDirName == m_sBackslashPath)\r
 470                 {\r
 471                         // We were clearly provided with a root path to start with - we should return nothing now\r
 472                         sDirName.Empty();\r
 473                 }\r
 474         }\r
 475         if(sDirName.GetLength() == 1 && sDirName[0] == '\\')\r
 476         {\r
 477                 // We have an UNC path and we already are the root\r
 478                 sDirName.Empty();\r
 479         }\r
 480         CTGitPath retVal;\r
 481         retVal.SetFromWin(sDirName);\r
 482         return retVal;\r
 483 }\r
 484 \r
 485 CString CTGitPath::GetRootPathString() const\r
 486 {\r
 487         EnsureBackslashPathSet();\r
 488         CString workingPath = m_sBackslashPath;\r
 489         LPTSTR pPath = workingPath.GetBuffer(MAX_PATH);         // MAX_PATH ok here.\r
 490         ATLVERIFY(::PathStripToRoot(pPath));\r
 491         workingPath.ReleaseBuffer();\r
 492         return workingPath;\r
 493 }\r
 494 \r
 495 \r
 496 CString CTGitPath::GetFilename() const\r
 497 {\r
 498         ATLASSERT(!IsDirectory());\r
 499         return GetFileOrDirectoryName();\r
 500 }\r
 501 \r
 502 CString CTGitPath::GetFileOrDirectoryName() const\r
 503 {\r
 504         EnsureBackslashPathSet();\r
 505         return m_sBackslashPath.Mid(m_sBackslashPath.ReverseFind('\\')+1);\r
 506 }\r
 507 \r
 508 CString CTGitPath::GetUIFileOrDirectoryName() const\r
 509 {\r
 510         GetUIPathString();\r
 511         return m_sUIPath.Mid(m_sUIPath.ReverseFind('\\')+1);\r
 512 }\r
 513 \r
 514 CString CTGitPath::GetFileExtension() const\r
 515 {\r
 516         if(!IsDirectory())\r
 517         {\r
 518                 EnsureBackslashPathSet();\r
 519                 int dotPos = m_sBackslashPath.ReverseFind('.');\r
 520                 int slashPos = m_sBackslashPath.ReverseFind('\\');\r
 521                 if (dotPos > slashPos)\r
 522                         return m_sBackslashPath.Mid(dotPos);\r
 523         }\r
 524         return CString();\r
 525 }\r
 526 CString CTGitPath::GetBaseFilename() const\r
 527 {\r
 528         int dot;\r
 529         CString filename=GetFilename();\r
 530         dot = filename.ReverseFind(_T('.'));\r
 531         if(dot>0)\r
 532                 return filename.Left(dot-1);\r
 533         else\r
 534                 return filename;\r
 535 }\r
 536 \r
 537 bool CTGitPath::ArePathStringsEqual(const CString& sP1, const CString& sP2)\r
 538 {\r
 539         int length = sP1.GetLength();\r
 540         if(length != sP2.GetLength())\r
 541         {\r
 542                 // Different lengths\r
 543                 return false;\r
 544         }\r
 545         // We work from the end of the strings, because path differences\r
 546         // are more likely to occur at the far end of a string\r
 547         LPCTSTR pP1Start = sP1;\r
 548         LPCTSTR pP1 = pP1Start+(length-1);\r
 549         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);\r
 550         while(length-- > 0)\r
 551         {\r
 552                 if(_totlower(*pP1--) != _totlower(*pP2--))\r
 553                 {\r
 554                         return false;\r
 555                 }\r
 556         }\r
 557         return true;\r
 558 }\r
 559 \r
 560 bool CTGitPath::ArePathStringsEqualWithCase(const CString& sP1, const CString& sP2)\r
 561 {\r
 562         int length = sP1.GetLength();\r
 563         if(length != sP2.GetLength())\r
 564         {\r
 565                 // Different lengths\r
 566                 return false;\r
 567         }\r
 568         // We work from the end of the strings, because path differences\r
 569         // are more likely to occur at the far end of a string\r
 570         LPCTSTR pP1Start = sP1;\r
 571         LPCTSTR pP1 = pP1Start+(length-1);\r
 572         LPCTSTR pP2 = ((LPCTSTR)sP2)+(length-1);\r
 573         while(length-- > 0)\r
 574         {\r
 575                 if((*pP1--) != (*pP2--))\r
 576                 {\r
 577                         return false;\r
 578                 }\r
 579         }\r
 580         return true;\r
 581 }\r
 582 \r
 583 bool CTGitPath::IsEmpty() const\r
 584 {\r
 585         // Check the backward slash path first, since the chance that this\r
 586         // one is set is higher. In case of a 'false' return value it's a little\r
 587         // bit faster.\r
 588         return m_sBackslashPath.IsEmpty() && m_sFwdslashPath.IsEmpty();\r
 589 }\r
 590 \r
 591 // Test if both paths refer to the same item\r
 592 // Ignores case and slash direction\r
 593 bool CTGitPath::IsEquivalentTo(const CTGitPath& rhs) const\r
 594 {\r
 595         // Try and find a slash direction which avoids having to convert\r
 596         // both filenames\r
 597         if(!m_sBackslashPath.IsEmpty())\r
 598         {\r
 599                 // *We've* got a \ path - make sure that the RHS also has a \ path\r
 600                 rhs.EnsureBackslashPathSet();\r
 601                 return ArePathStringsEqualWithCase(m_sBackslashPath, rhs.m_sBackslashPath);\r
 602         }\r
 603         else\r
 604         {\r
 605                 // Assume we've got a fwdslash path and make sure that the RHS has one\r
 606                 rhs.EnsureFwdslashPathSet();\r
 607                 return ArePathStringsEqualWithCase(m_sFwdslashPath, rhs.m_sFwdslashPath);\r
 608         }\r
 609 }\r
 610 \r
 611 bool CTGitPath::IsEquivalentToWithoutCase(const CTGitPath& rhs) const\r
 612 {\r
 613         // Try and find a slash direction which avoids having to convert\r
 614         // both filenames\r
 615         if(!m_sBackslashPath.IsEmpty())\r
 616         {\r
 617                 // *We've* got a \ path - make sure that the RHS also has a \ path\r
 618                 rhs.EnsureBackslashPathSet();\r
 619                 return ArePathStringsEqual(m_sBackslashPath, rhs.m_sBackslashPath);\r
 620         }\r
 621         else\r
 622         {\r
 623                 // Assume we've got a fwdslash path and make sure that the RHS has one\r
 624                 rhs.EnsureFwdslashPathSet();\r
 625                 return ArePathStringsEqual(m_sFwdslashPath, rhs.m_sFwdslashPath);\r
 626         }\r
 627 }\r
 628 \r
 629 bool CTGitPath::IsAncestorOf(const CTGitPath& possibleDescendant) const\r
 630 {\r
 631         possibleDescendant.EnsureBackslashPathSet();\r
 632         EnsureBackslashPathSet();\r
 633 \r
 634         bool bPathStringsEqual = ArePathStringsEqual(m_sBackslashPath, possibleDescendant.m_sBackslashPath.Left(m_sBackslashPath.GetLength()));\r
 635         if (m_sBackslashPath.GetLength() >= possibleDescendant.GetWinPathString().GetLength())\r
 636         {\r
 637                 return bPathStringsEqual;               \r
 638         }\r
 639         \r
 640         return (bPathStringsEqual && \r
 641                         ((possibleDescendant.m_sBackslashPath[m_sBackslashPath.GetLength()] == '\\')||\r
 642                         (m_sBackslashPath.GetLength()==3 && m_sBackslashPath[1]==':')));\r
 643 }\r
 644 \r
 645 // Get a string representing the file path, optionally with a base \r
 646 // section stripped off the front.\r
 647 CString CTGitPath::GetDisplayString(const CTGitPath* pOptionalBasePath /* = NULL*/) const\r
 648 {\r
 649         EnsureFwdslashPathSet();\r
 650         if(pOptionalBasePath != NULL)\r
 651         {\r
 652                 // Find the length of the base-path without having to do an 'ensure' on it\r
 653                 int baseLength = max(pOptionalBasePath->m_sBackslashPath.GetLength(), pOptionalBasePath->m_sFwdslashPath.GetLength());\r
 654 \r
 655                 // Now, chop that baseLength of the front of the path\r
 656                 return m_sFwdslashPath.Mid(baseLength).TrimLeft('/');\r
 657         }\r
 658         return m_sFwdslashPath;\r
 659 }\r
 660 \r
 661 int CTGitPath::Compare(const CTGitPath& left, const CTGitPath& right)\r
 662 {\r
 663         left.EnsureBackslashPathSet();\r
 664         right.EnsureBackslashPathSet();\r
 665         return left.m_sBackslashPath.CompareNoCase(right.m_sBackslashPath);\r
 666 }\r
 667 \r
 668 bool operator<(const CTGitPath& left, const CTGitPath& right)\r
 669 {\r
 670         return CTGitPath::Compare(left, right) < 0;\r
 671 }\r
 672 \r
 673 bool CTGitPath::PredLeftEquivalentToRight(const CTGitPath& left, const CTGitPath& right)\r
 674 {\r
 675         return left.IsEquivalentTo(right);\r
 676 }\r
 677 \r
 678 bool CTGitPath::PredLeftSameWCPathAsRight(const CTGitPath& left, const CTGitPath& right)\r
 679 {\r
 680         if (left.IsAdminDir() && right.IsAdminDir())\r
 681         {\r
 682                 CTGitPath l = left;\r
 683                 CTGitPath r = right;\r
 684                 do \r
 685                 {\r
 686                         l = l.GetContainingDirectory();\r
 687                 } while(l.HasAdminDir());\r
 688                 do \r
 689                 {\r
 690                         r = r.GetContainingDirectory();\r
 691                 } while(r.HasAdminDir());\r
 692                 return l.GetContainingDirectory().IsEquivalentTo(r.GetContainingDirectory());\r
 693         }\r
 694         return left.GetDirectory().IsEquivalentTo(right.GetDirectory());\r
 695 }\r
 696 \r
 697 bool CTGitPath::CheckChild(const CTGitPath &parent, const CTGitPath& child)\r
 698 {\r
 699         return parent.IsAncestorOf(child);\r
 700 }\r
 701 \r
 702 void CTGitPath::AppendRawString(const CString& sAppend)\r
 703 {\r
 704         EnsureFwdslashPathSet();\r
 705         CString strCopy = m_sFwdslashPath += sAppend;\r
 706         SetFromUnknown(strCopy);\r
 707 }\r
 708 \r
 709 void CTGitPath::AppendPathString(const CString& sAppend)\r
 710 {\r
 711         EnsureBackslashPathSet();\r
 712         CString cleanAppend(sAppend);\r
 713         cleanAppend.Replace('/', '\\');\r
 714         cleanAppend.TrimLeft('\\');\r
 715         m_sBackslashPath.TrimRight('\\');\r
 716         CString strCopy = m_sBackslashPath + _T("\\") + cleanAppend;\r
 717         SetFromWin(strCopy);\r
 718 }\r
 719 \r
 720 bool CTGitPath::HasAdminDir() const\r
 721 {\r
 722         if (m_bHasAdminDirKnown)\r
 723                 return m_bHasAdminDir;\r
 724 \r
 725         EnsureBackslashPathSet();\r
 726         m_bHasAdminDir = g_GitAdminDir.HasAdminDir(m_sBackslashPath, IsDirectory());\r
 727         m_bHasAdminDirKnown = true;\r
 728         return m_bHasAdminDir;\r
 729 }\r
 730 \r
 731 bool CTGitPath::IsAdminDir() const\r
 732 {\r
 733         if (m_bIsAdminDirKnown)\r
 734                 return m_bIsAdminDir;\r
 735         \r
 736         EnsureBackslashPathSet();\r
 737         m_bIsAdminDir = g_GitAdminDir.IsAdminDirPath(m_sBackslashPath);\r
 738         m_bIsAdminDirKnown = true;\r
 739         return m_bIsAdminDir;\r
 740 }\r
 741 \r
 742 bool CTGitPath::IsValidOnWindows() const\r
 743 {\r
 744         if (m_bIsValidOnWindowsKnown)\r
 745                 return m_bIsValidOnWindows;\r
 746 \r
 747         m_bIsValidOnWindows = false;\r
 748         EnsureBackslashPathSet();\r
 749         CString sMatch = m_sBackslashPath + _T("\r\n");\r
 750         wstring sPattern;\r
 751         // the 'file://' URL is just a normal windows path:\r
 752         if (sMatch.Left(7).CompareNoCase(_T("file:\\\\"))==0)\r
 753         {\r
 754                 sMatch = sMatch.Mid(7);\r
 755                 sMatch.TrimLeft(_T("\\"));\r
 756                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");\r
 757         }\r
 758         else if (IsUrl())\r
 759         {\r
 760                 sPattern = _T("^((http|https|svn|svn\\+ssh|file)\\:\\\\+([^\\\\@\\:]+\\:[^\\\\@\\:]+@)?\\\\[^\\\\]+(\\:\\d+)?)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<>\\. ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<>\\. ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");\r
 761         }\r
 762         else\r
 763         {\r
 764                 sPattern = _T("^(\\\\\\\\\\?\\\\)?(([a-zA-Z]:|\\\\)\\\\)?(((\\.)|(\\.\\.)|([^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?))\\\\)*[^\\\\/:\\*\\?\"\\|<> ](([^\\\\/:\\*\\?\"\\|<>\\. ])|([^\\\\/:\\*\\?\"\\|<>]*[^\\\\/:\\*\\?\"\\|<>\\. ]))?$");\r
 765         }\r
 766 \r
 767         try\r
 768         {\r
 769                 tr1::wregex rx(sPattern, tr1::regex_constants::icase | tr1::regex_constants::ECMAScript);\r
 770                 tr1::wsmatch match;\r
 771 \r
 772                 wstring rmatch = wstring((LPCTSTR)sMatch);\r
 773                 if (tr1::regex_match(rmatch, match, rx))\r
 774                 {\r
 775                         if (wstring(match[0]).compare(sMatch)==0)\r
 776                                 m_bIsValidOnWindows = true;\r
 777                 }\r
 778                 if (m_bIsValidOnWindows)\r
 779                 {\r
 780                         // now check for illegal filenames\r
 781                         tr1::wregex rx2(_T("\\\\(lpt\\d|com\\d|aux|nul|prn|con)(\\\\|$)"), tr1::regex_constants::icase | tr1::regex_constants::ECMAScript);\r
 782                         rmatch = m_sBackslashPath;\r
 783                         if (tr1::regex_search(rmatch, rx2, tr1::regex_constants::match_default))\r
 784                                 m_bIsValidOnWindows = false;\r
 785                 }\r
 786         }\r
 787         catch (exception) {}\r
 788 \r
 789         m_bIsValidOnWindowsKnown = true;\r
 790         return m_bIsValidOnWindows;\r
 791 }\r
 792 \r
 793 bool CTGitPath::IsSpecialDirectory() const\r
 794 {\r
 795         if (m_bIsSpecialDirectoryKnown)\r
 796                 return m_bIsSpecialDirectory;\r
 797 \r
 798         static LPCTSTR specialDirectories[]\r
 799                 = { _T("trunk"), _T("tags"), _T("branches") };\r
 800 \r
 801         for (int i=0 ; i<(sizeof(specialDirectories) / sizeof(specialDirectories[0])) ; ++i)\r
 802         {\r
 803                 CString name = GetFileOrDirectoryName();\r
 804                 if (0 == name.CompareNoCase(specialDirectories[i]))\r
 805                 {\r
 806                         m_bIsSpecialDirectory = true;\r
 807                         break;\r
 808                 }\r
 809         }\r
 810 \r
 811         m_bIsSpecialDirectoryKnown = true;\r
 812 \r
 813         return m_bIsSpecialDirectory;\r
 814 }\r
 815 \r
 816 //////////////////////////////////////////////////////////////////////////\r
 817 \r
 818 CTGitPathList::CTGitPathList()\r
 819 {\r
 820 \r
 821 }\r
 822 \r
 823 // A constructor which allows a path list to be easily built which one initial entry in\r
 824 CTGitPathList::CTGitPathList(const CTGitPath& firstEntry)\r
 825 {\r
 826         AddPath(firstEntry);\r
 827 }\r
 828 int CTGitPathList::FillUnRev(int action,CTGitPathList *list)\r
 829 {\r
 830         int pos=0;\r
 831         this->Clear();\r
 832         CTGitPath path;\r
 833 \r
 834         int count;\r
 835         if(list==NULL)\r
 836                 count=1;\r
 837         else\r
 838                 count=list->GetCount();\r
 839         for(int i=0;i<count;i++)\r
 840         {       \r
 841                 CString cmd;\r
 842                 pos=0;\r
 843                 \r
 844                 CString ignored;\r
 845                 if(action & CTGitPath::LOGACTIONS_IGNORE)\r
 846                         ignored= _T(" --ignored");\r
 847                 \r
 848                 if(list==NULL)\r
 849                 {\r
 850                         cmd=_T("git.exe ls-files --exclude-standard --full-name --others");\r
 851                         cmd+=ignored;\r
 852                         \r
 853                 }\r
 854                 else\r
 855                 {       cmd.Format(_T("git.exe ls-files --exclude-standard --full-name --others %s-- \"%s\""),\r
 856                                         ignored,\r
 857                                         (*list)[i].GetWinPathString());\r
 858                 }\r
 859                 \r
 860                 CString out;\r
 861                 g_Git.Run(cmd,&out);\r
 862 \r
 863                 CString one;\r
 864                 while( pos>=0 )\r
 865                 {\r
 866                         one=out.Tokenize(_T("\n"),pos);\r
 867                         if(!one.IsEmpty())\r
 868                         {\r
 869                                 //SetFromGit will clear all status\r
 870                                 path.SetFromGit(one);\r
 871                                 path.m_Action=action;\r
 872                                 AddPath(path);\r
 873                         }\r
 874                 }\r
 875         }\r
 876         return 0;\r
 877 }\r
 878 int CTGitPathList::ParserFromLog(CString &log)\r
 879 {\r
 880         this->Clear();\r
 881         int pos=0;\r
 882         CString one;\r
 883         CTGitPath path;\r
 884         m_Action=0;\r
 885         while( pos>=0 )\r
 886         {\r
 887                 one=log.Tokenize(_T("\n"),pos);\r
 888                 path.Reset();\r
 889                 if(one[0]==_T(':'))\r
 890                 {\r
 891                         int tabstart=0;\r
 892                         int actionstart=0;\r
 893                         CString pathname;\r
 894                         CString action;\r
 895                         one.Tokenize(_T("\t"),tabstart);\r
 896                         if(tabstart >0)\r
 897                         {\r
 898                                 action=one.Left(tabstart);\r
 899                                 actionstart=action.ReverseFind(_T(' '));\r
 900                                 if(actionstart>0)\r
 901                                 {\r
 902                                         action=action.Right(action.GetLength()-actionstart);\r
 903                                 }\r
 904                                 pathname=one.Right(one.GetLength()-tabstart);\r
 905                                                 \r
 906                                 CTGitPath *GitPath=LookForGitPath(pathname);\r
 907                                                 \r
 908                                 if(GitPath)\r
 909                                 {\r
 910                                         this->m_Action|=GitPath->ParserAction(action);  \r
 911                                                         \r
 912                                 }else\r
 913                                 {       \r
 914                                         int ac=path.ParserAction(action);\r
 915                                         if(ac & CTGitPath::LOGACTIONS_REPLACED)\r
 916                                         {\r
 917                                                 CString oldname;\r
 918                                                 int oldnametab=pathname.Find(_T("\t"));\r
 919                                                 if(oldnametab>0)\r
 920                                                         path.SetFromGit(pathname.Right(pathname.GetLength()-oldnametab-1),&pathname.Left(oldnametab));\r
 921                                                 else\r
 922                                                 {\r
 923                                                         ASSERT(FALSE);\r
 924                                                         path.SetFromGit(pathname);\r
 925                                                 }\r
 926                                         }else\r
 927                                                 path.SetFromGit(pathname);\r
 928                                         path.m_Action=ac;\r
 929                                         //action must be set after setfromgit. SetFromGit will clear all status. \r
 930                                         this->m_Action|=ac;\r
 931                                         AddPath(path);\r
 932                                 }\r
 933                         }\r
 934                                         \r
 935                 }else\r
 936                 {\r
 937 \r
 938                         int tabstart=0;\r
 939                         path.Reset();\r
 940                         CString StatAdd=(one.Tokenize(_T("\t"),tabstart));\r
 941                         if( tabstart< 0)\r
 942                                 break;\r
 943                         CString StatDel=(one.Tokenize(_T("\t"),tabstart));\r
 944                         //SetFromGit will reset all context of GitRev\r
 945                         one=one.Right(one.GetLength()-tabstart);\r
 946                         int rename=one.Find(_T(" => "));\r
 947                         if(rename>0)\r
 948                         {\r
 949                                 CString basepath;\r
 950                                 int include_left=one.Find(_T("/{"));\r
 951                                 if(include_left>0)\r
 952                                 {\r
 953                                         basepath=one.Left(include_left+1);\r
 954                                         CString newname=basepath+one.Mid(rename+4,one.GetLength()-rename-5);\r
 955                                         CString oldname=basepath+one.Mid(include_left+2,rename-include_left-2);\r
 956                                         path.SetFromGit(newname,&oldname        );\r
 957                                 }else\r
 958                                         path.SetFromGit(one.Right(one.GetLength()-rename-4),&one.Left(rename));\r
 959                         }else\r
 960                                 path.SetFromGit(one);\r
 961                                 \r
 962                         CTGitPath *GitPath=LookForGitPath(path.GetGitPathString());\r
 963                         if(GitPath)\r
 964                         {\r
 965                                 GitPath->m_StatAdd=StatAdd;\r
 966                                 GitPath->m_StatDel=StatDel;\r
 967                         }else\r
 968                         {\r
 969                                 //path.SetFromGit(pathname);\r
 970                                 path.m_StatAdd=StatAdd;\r
 971                                 path.m_StatDel=StatDel;\r
 972                                 AddPath(path);\r
 973                         }\r
 974                 }\r
 975 \r
 976         }\r
 977         return pos;\r
 978 }\r
 979 \r
 980 void CTGitPathList::AddPath(const CTGitPath& newPath)\r
 981 {\r
 982         m_paths.push_back(newPath);\r
 983         m_commonBaseDirectory.Reset();\r
 984 }\r
 985 int CTGitPathList::GetCount() const\r
 986 {\r
 987         return (int)m_paths.size();\r
 988 }\r
 989 void CTGitPathList::Clear()\r
 990 {\r
 991         m_paths.clear();\r
 992         m_commonBaseDirectory.Reset();\r
 993 }\r
 994 \r
 995 const CTGitPath& CTGitPathList::operator[](INT_PTR index) const\r
 996 {\r
 997         ATLASSERT(index >= 0 && index < (INT_PTR)m_paths.size());\r
 998         return m_paths[index];\r
 999 }\r
1000 \r
1001 bool CTGitPathList::AreAllPathsFiles() const\r
1002 {\r
1003         // Look through the vector for any directories - if we find them, return false\r
1004         return std::find_if(m_paths.begin(), m_paths.end(), std::mem_fun_ref(&CTGitPath::IsDirectory)) == m_paths.end();\r
1005 }\r
1006 \r
1007 \r
1008 #if defined(_MFC_VER)\r
1009 \r
1010 bool CTGitPathList::LoadFromFile(const CTGitPath& filename)\r
1011 {\r
1012         Clear();\r
1013         try\r
1014         {\r
1015                 CString strLine;\r
1016                 CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);\r
1017 \r
1018                 // for every selected file/folder\r
1019                 CTGitPath path;\r
1020                 while (file.ReadString(strLine))\r
1021                 {\r
1022                         path.SetFromUnknown(strLine);\r
1023                         AddPath(path);\r
1024                 }\r
1025                 file.Close();\r
1026         }\r
1027         catch (CFileException* pE)\r
1028         {\r
1029                 TRACE("CFileException loading target file list\n");\r
1030                 TCHAR error[10000] = {0};\r
1031                 pE->GetErrorMessage(error, 10000);\r
1032 //              CMessageBox::Show(NULL, error, _T("TortoiseGit"), MB_ICONERROR);\r
1033                 pE->Delete();\r
1034                 return false;\r
1035         }\r
1036         return true;\r
1037 }\r
1038 \r
1039 bool CTGitPathList::WriteToFile(const CString& sFilename, bool bANSI /* = false */) const\r
1040 {\r
1041         try\r
1042         {\r
1043                 if (bANSI)\r
1044                 {\r
1045                         CStdioFile file(sFilename, CFile::typeText | CFile::modeReadWrite | CFile::modeCreate);\r
1046                         PathVector::const_iterator it;\r
1047                         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1048                         {\r
1049                                 CStringA line = CStringA(it->GetGitPathString()) + '\n';\r
1050                                 file.Write(line, line.GetLength());\r
1051                         } \r
1052                         file.Close();\r
1053                 }\r
1054                 else\r
1055                 {\r
1056                         CStdioFile file(sFilename, CFile::typeBinary | CFile::modeReadWrite | CFile::modeCreate);\r
1057                         PathVector::const_iterator it;\r
1058                         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1059                         {\r
1060                                 file.WriteString(it->GetGitPathString()+_T("\n"));\r
1061                         } \r
1062                         file.Close();\r
1063                 }\r
1064         }\r
1065         catch (CFileException* pE)\r
1066         {\r
1067                 TRACE("CFileException in writing temp file\n");\r
1068                 pE->Delete();\r
1069                 return false;\r
1070         }\r
1071         return true;\r
1072 }\r
1073 \r
1074 \r
1075 void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString)\r
1076 {\r
1077         int pos = 0;\r
1078         CString temp;\r
1079         for(;;)\r
1080         {\r
1081                 temp = sPathString.Tokenize(_T("*"),pos);\r
1082                 if(temp.IsEmpty())\r
1083                 {\r
1084                         break;\r
1085                 }\r
1086                 AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));\r
1087         } \r
1088 }\r
1089 \r
1090 CString CTGitPathList::CreateAsteriskSeparatedString() const\r
1091 {\r
1092         CString sRet;\r
1093         PathVector::const_iterator it;\r
1094         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1095         {\r
1096                 if (!sRet.IsEmpty())\r
1097                         sRet += _T("*");\r
1098                 sRet += it->GetWinPathString();\r
1099         }\r
1100         return sRet;\r
1101 }\r
1102 #endif // _MFC_VER\r
1103 \r
1104 bool \r
1105 CTGitPathList::AreAllPathsFilesInOneDirectory() const\r
1106 {\r
1107         // Check if all the paths are files and in the same directory\r
1108         PathVector::const_iterator it;\r
1109         m_commonBaseDirectory.Reset();\r
1110         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1111         {\r
1112                 if(it->IsDirectory())\r
1113                 {\r
1114                         return false;\r
1115                 }\r
1116                 const CTGitPath& baseDirectory = it->GetDirectory();\r
1117                 if(m_commonBaseDirectory.IsEmpty())\r
1118                 {\r
1119                         m_commonBaseDirectory = baseDirectory;\r
1120                 }\r
1121                 else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))\r
1122                 {\r
1123                         // Different path\r
1124                         m_commonBaseDirectory.Reset();\r
1125                         return false;\r
1126                 }\r
1127         }\r
1128         return true;\r
1129 }\r
1130 \r
1131 CTGitPath CTGitPathList::GetCommonDirectory() const\r
1132 {\r
1133         if (m_commonBaseDirectory.IsEmpty())\r
1134         {\r
1135                 PathVector::const_iterator it;\r
1136                 for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1137                 {\r
1138                         const CTGitPath& baseDirectory = it->GetDirectory();\r
1139                         if(m_commonBaseDirectory.IsEmpty())\r
1140                         {\r
1141                                 m_commonBaseDirectory = baseDirectory;\r
1142                         }\r
1143                         else if(!m_commonBaseDirectory.IsEquivalentTo(baseDirectory))\r
1144                         {\r
1145                                 // Different path\r
1146                                 m_commonBaseDirectory.Reset();\r
1147                                 break;\r
1148                         }\r
1149                 }\r
1150         }\r
1151         // since we only checked strings, not paths,\r
1152         // we have to make sure now that we really return a *path* here\r
1153         PathVector::const_iterator iter;\r
1154         for(iter = m_paths.begin(); iter != m_paths.end(); ++iter)\r
1155         {\r
1156                 if (!m_commonBaseDirectory.IsAncestorOf(*iter))\r
1157                 {\r
1158                         m_commonBaseDirectory = m_commonBaseDirectory.GetContainingDirectory();\r
1159                         break;\r
1160                 }\r
1161         }       \r
1162         return m_commonBaseDirectory;\r
1163 }\r
1164 \r
1165 CTGitPath CTGitPathList::GetCommonRoot() const\r
1166 {\r
1167         PathVector::const_iterator it;\r
1168         CString sRoot, sTempRoot;\r
1169         bool bEqual = true;\r
1170 \r
1171         if (GetCount() == 1)\r
1172                 return m_paths[0];\r
1173 \r
1174         int backSlashPos = 0;\r
1175         int searchStartPos = 0;\r
1176         while (bEqual)\r
1177         {\r
1178                 for (it = m_paths.begin(); it != m_paths.end(); ++it)\r
1179                 {\r
1180                         if (backSlashPos == 0)\r
1181                         {\r
1182                                 backSlashPos = it->GetWinPathString().Find('\\', searchStartPos+1);\r
1183                                 if ((backSlashPos < 0)&&(searchStartPos != it->GetWinPathString().GetLength()))\r
1184                                         backSlashPos = it->GetWinPathString().GetLength();\r
1185                         }\r
1186                         else if (it->GetWinPathString().Find('\\', searchStartPos+1) != backSlashPos)\r
1187                         {\r
1188                                 if (it->GetWinPathString().Find('\\', searchStartPos+1) < 0)\r
1189                                 {\r
1190                                         if (it->GetWinPathString().GetLength() != backSlashPos)\r
1191                                         {\r
1192                                                 bEqual = false;\r
1193                                                 break;\r
1194                                         }\r
1195                                 }\r
1196                                 else\r
1197                                 {\r
1198                                         bEqual = false;\r
1199                                         break;\r
1200                                 }\r
1201                         }\r
1202                         if (backSlashPos < 0)\r
1203                         {\r
1204                                 bEqual = false;\r
1205                                 break;\r
1206                         }\r
1207                 }\r
1208                 if (bEqual == false)\r
1209                 {\r
1210                         if (searchStartPos)\r
1211                                 sRoot = m_paths[0].GetWinPathString().Left(searchStartPos+1);\r
1212                 }\r
1213                 else\r
1214                 {\r
1215                         searchStartPos = backSlashPos;\r
1216                 }\r
1217                 backSlashPos = 0;\r
1218         }\r
1219 \r
1220         return CTGitPath(sRoot.TrimRight('\\'));\r
1221 }\r
1222 \r
1223 void CTGitPathList::SortByPathname(bool bReverse /*= false*/)\r
1224 {\r
1225         std::sort(m_paths.begin(), m_paths.end());\r
1226         if (bReverse)\r
1227                 std::reverse(m_paths.begin(), m_paths.end());\r
1228 }\r
1229 \r
1230 void CTGitPathList::DeleteAllFiles(bool bTrash)\r
1231 {\r
1232         PathVector::const_iterator it;\r
1233         if (bTrash)\r
1234         {\r
1235                 SortByPathname();\r
1236                 CString sPaths;\r
1237                 for (it = m_paths.begin(); it != m_paths.end(); ++it)\r
1238                 {\r
1239                         if ((it->Exists())&&(!it->IsDirectory()))\r
1240                         {\r
1241                                 ::SetFileAttributes(it->GetWinPath(), FILE_ATTRIBUTE_NORMAL);\r
1242                                 sPaths += it->GetWinPath();\r
1243                                 sPaths += '\0';\r
1244                         }\r
1245                 }\r
1246                 sPaths += '\0';\r
1247                 sPaths += '\0';\r
1248                 SHFILEOPSTRUCT shop = {0};\r
1249                 shop.wFunc = FO_DELETE;\r
1250                 shop.pFrom = (LPCTSTR)sPaths;\r
1251                 shop.fFlags = FOF_ALLOWUNDO|FOF_NOCONFIRMATION|FOF_NOERRORUI|FOF_SILENT;\r
1252                 SHFileOperation(&shop);\r
1253         }\r
1254         else\r
1255         {\r
1256                 for (it = m_paths.begin(); it != m_paths.end(); ++it)\r
1257                 {\r
1258                         if (!it->IsDirectory())\r
1259                         {\r
1260                                 ::SetFileAttributes(it->GetWinPath(), FILE_ATTRIBUTE_NORMAL);\r
1261                                 ::DeleteFile(it->GetWinPath());\r
1262                         }\r
1263                 }\r
1264         }\r
1265         Clear();\r
1266 }\r
1267 \r
1268 void CTGitPathList::RemoveDuplicates()\r
1269 {\r
1270         SortByPathname();\r
1271         // Remove the duplicates\r
1272         // (Unique moves them to the end of the vector, then erase chops them off)\r
1273         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::PredLeftEquivalentToRight), m_paths.end());\r
1274 }\r
1275 \r
1276 void CTGitPathList::RemoveAdminPaths()\r
1277 {\r
1278         PathVector::iterator it;\r
1279         for(it = m_paths.begin(); it != m_paths.end(); )\r
1280         {\r
1281                 if (it->IsAdminDir())\r
1282                 {\r
1283                         m_paths.erase(it);\r
1284                         it = m_paths.begin();\r
1285                 }\r
1286                 else\r
1287                         ++it;\r
1288         }\r
1289 }\r
1290 \r
1291 void CTGitPathList::RemovePath(const CTGitPath& path)\r
1292 {\r
1293         PathVector::iterator it;\r
1294         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1295         {\r
1296                 if (it->IsEquivalentTo(path))\r
1297                 {\r
1298                         m_paths.erase(it);\r
1299                         return;\r
1300                 }\r
1301         }\r
1302 }\r
1303 \r
1304 void CTGitPathList::RemoveItem(CTGitPath & path)\r
1305 {\r
1306         PathVector::iterator it;\r
1307         for(it = m_paths.begin(); it != m_paths.end(); ++it)\r
1308         {\r
1309                 if (it->GetGitPathString()==path.GetGitPathString())\r
1310                 {\r
1311                         m_paths.erase(it);\r
1312                         return;\r
1313                 }\r
1314         }\r
1315 }\r
1316 void CTGitPathList::RemoveChildren()\r
1317 {\r
1318         SortByPathname();\r
1319         m_paths.erase(std::unique(m_paths.begin(), m_paths.end(), &CTGitPath::CheckChild), m_paths.end());\r
1320 }\r
1321 \r
1322 bool CTGitPathList::IsEqual(const CTGitPathList& list)\r
1323 {\r
1324         if (list.GetCount() != GetCount())\r
1325                 return false;\r
1326         for (int i=0; i<list.GetCount(); ++i)\r
1327         {\r
1328                 if (!list[i].IsEquivalentTo(m_paths[i]))\r
1329                         return false;\r
1330         }\r
1331         return true;\r
1332 }\r
1333 \r
1334 //////////////////////////////////////////////////////////////////////////\r
1335 #if 0\r
1336 apr_array_header_t * CTGitPathList::MakePathArray (apr_pool_t *pool) const\r
1337 {\r
1338         apr_array_header_t *targets = apr_array_make (pool, GetCount(), sizeof(const char *));\r
1339 \r
1340         for(int nItem = 0; nItem < GetCount(); nItem++)\r
1341         {\r
1342                 const char * target = m_paths[nItem].GetGitApiPath(pool);\r
1343                 (*((const char **) apr_array_push (targets))) = target;\r
1344         }\r
1345 \r
1346         return targets;\r
1347 }\r
1348 #endif\r
1349 //////////////////////////////////////////////////////////////////////////\r
1350 \r
1351 #if 0\r
1352 #if defined(_DEBUG)\r
1353 // Some test cases for these classes\r
1354 static class CTGitPathTests\r
1355 {\r
1356 public:\r
1357         CTGitPathTests()\r
1358         {\r
1359                 apr_initialize();\r
1360                 pool = svn_pool_create(NULL);\r
1361                 GetDirectoryTest();\r
1362                 AdminDirTest();\r
1363                 SortTest();\r
1364                 RawAppendTest();\r
1365                 PathAppendTest();\r
1366                 RemoveDuplicatesTest();\r
1367                 RemoveChildrenTest();\r
1368                 ContainingDirectoryTest();\r
1369                 AncestorTest();\r
1370                 SubversionPathTest();\r
1371                 GetCommonRootTest();\r
1372 #if defined(_MFC_VER)\r
1373                 ValidPathAndUrlTest();\r
1374                 ListLoadingTest();\r
1375 #endif\r
1376                 apr_terminate();\r
1377         }\r
1378 \r
1379 private:\r
1380 //      apr_pool_t * pool;\r
1381         void GetDirectoryTest()\r
1382         {\r
1383                 // Bit tricky, this test, because we need to know something about the file\r
1384                 // layout on the machine which is running the test\r
1385                 TCHAR winDir[MAX_PATH+1];\r
1386                 GetWindowsDirectory(winDir, MAX_PATH);\r
1387                 CString sWinDir(winDir);\r
1388 \r
1389                 CTGitPath testPath;\r
1390                 // This is a file which we know will always be there\r
1391                 testPath.SetFromUnknown(sWinDir + _T("\\win.ini"));\r
1392                 ATLASSERT(!testPath.IsDirectory());\r
1393                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);\r
1394                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() == sWinDir);\r
1395 \r
1396                 // Now do the test on the win directory itself - It's hard to be sure about the containing directory\r
1397                 // but we know it must be different to the directory itself\r
1398                 testPath.SetFromUnknown(sWinDir);\r
1399                 ATLASSERT(testPath.IsDirectory());\r
1400                 ATLASSERT(testPath.GetDirectory().GetWinPathString() == sWinDir);\r
1401                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString() != sWinDir);\r
1402                 ATLASSERT(testPath.GetContainingDirectory().GetWinPathString().GetLength() < sWinDir.GetLength());\r
1403 \r
1404                 // Try a root path\r
1405                 testPath.SetFromUnknown(_T("C:\\"));\r
1406                 ATLASSERT(testPath.IsDirectory());\r
1407                 ATLASSERT(testPath.GetDirectory().GetWinPathString().CompareNoCase(_T("C:\\"))==0);\r
1408                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());\r
1409                 // Try a root UNC path\r
1410                 testPath.SetFromUnknown(_T("\\MYSTATION"));\r
1411                 ATLASSERT(testPath.GetContainingDirectory().IsEmpty());\r
1412         }\r
1413 \r
1414         void AdminDirTest()\r
1415         {\r
1416                 CTGitPath testPath;\r
1417                 testPath.SetFromUnknown(_T("c:\\.svndir"));\r
1418                 ATLASSERT(!testPath.IsAdminDir());\r
1419                 testPath.SetFromUnknown(_T("c:\\test.svn"));\r
1420                 ATLASSERT(!testPath.IsAdminDir());\r
1421                 testPath.SetFromUnknown(_T("c:\\.svn"));\r
1422                 ATLASSERT(testPath.IsAdminDir());\r
1423                 testPath.SetFromUnknown(_T("c:\\.svndir\\test"));\r
1424                 ATLASSERT(!testPath.IsAdminDir());\r
1425                 testPath.SetFromUnknown(_T("c:\\.svn\\test"));\r
1426                 ATLASSERT(testPath.IsAdminDir());\r
1427                 \r
1428                 CTGitPathList pathList;\r
1429                 pathList.AddPath(CTGitPath(_T("c:\\.svndir")));\r
1430                 pathList.AddPath(CTGitPath(_T("c:\\.svn")));\r
1431                 pathList.AddPath(CTGitPath(_T("c:\\.svn\\test")));\r
1432                 pathList.AddPath(CTGitPath(_T("c:\\test")));\r
1433                 pathList.RemoveAdminPaths();\r
1434                 ATLASSERT(pathList.GetCount()==2);\r
1435                 pathList.Clear();\r
1436                 pathList.AddPath(CTGitPath(_T("c:\\test")));\r
1437                 pathList.RemoveAdminPaths();\r
1438                 ATLASSERT(pathList.GetCount()==1);\r
1439         }\r
1440         \r
1441         void SortTest()\r
1442         {\r
1443                 CTGitPathList testList;\r
1444                 CTGitPath testPath;\r
1445                 testPath.SetFromUnknown(_T("c:/Z"));\r
1446                 testList.AddPath(testPath);\r
1447                 testPath.SetFromUnknown(_T("c:/B"));\r
1448                 testList.AddPath(testPath);\r
1449                 testPath.SetFromUnknown(_T("c:\\a"));\r
1450                 testList.AddPath(testPath);\r
1451                 testPath.SetFromUnknown(_T("c:/Test"));\r
1452                 testList.AddPath(testPath);\r
1453 \r
1454                 testList.SortByPathname();\r
1455 \r
1456                 ATLASSERT(testList[0].GetWinPathString() == _T("c:\\a"));\r
1457                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\B"));\r
1458                 ATLASSERT(testList[2].GetWinPathString() == _T("c:\\Test"));\r
1459                 ATLASSERT(testList[3].GetWinPathString() == _T("c:\\Z"));\r
1460         }\r
1461 \r
1462         void RawAppendTest()\r
1463         {\r
1464                 CTGitPath testPath(_T("c:/test/"));\r
1465                 testPath.AppendRawString(_T("/Hello"));\r
1466                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));\r
1467 \r
1468                 testPath.AppendRawString(_T("\\T2"));\r
1469                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));\r
1470 \r
1471                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));\r
1472                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));\r
1473                 testBasePath.AppendRawString(testFilePath.GetFileExtension());\r
1474                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt.ini"));\r
1475         }\r
1476 \r
1477         void PathAppendTest()\r
1478         {\r
1479                 CTGitPath testPath(_T("c:/test/"));\r
1480                 testPath.AppendPathString(_T("/Hello"));\r
1481                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello"));\r
1482 \r
1483                 testPath.AppendPathString(_T("T2"));\r
1484                 ATLASSERT(testPath.GetWinPathString() == _T("c:\\test\\Hello\\T2"));\r
1485 \r
1486                 CTGitPath testFilePath(_T("C:\\windows\\win.ini"));\r
1487                 CTGitPath testBasePath(_T("c:/temp/myfile.txt"));\r
1488                 // You wouldn't want to do this in real life - you'd use append-raw\r
1489                 testBasePath.AppendPathString(testFilePath.GetFileExtension());\r
1490                 ATLASSERT(testBasePath.GetWinPathString() == _T("c:\\temp\\myfile.txt\\.ini"));\r
1491         }\r
1492 \r
1493         void RemoveDuplicatesTest()\r
1494         {\r
1495                 CTGitPathList list;\r
1496                 list.AddPath(CTGitPath(_T("Z")));\r
1497                 list.AddPath(CTGitPath(_T("A")));\r
1498                 list.AddPath(CTGitPath(_T("E")));\r
1499                 list.AddPath(CTGitPath(_T("E")));\r
1500 \r
1501                 ATLASSERT(list[2].IsEquivalentTo(list[3]));\r
1502                 ATLASSERT(list[2]==list[3]);\r
1503                 \r
1504                 ATLASSERT(list.GetCount() == 4);\r
1505 \r
1506                 list.RemoveDuplicates();\r
1507 \r
1508                 ATLASSERT(list.GetCount() == 3);\r
1509 \r
1510                 ATLASSERT(list[0].GetWinPathString() == _T("A"));\r
1511                 ATLASSERT(list[1].GetWinPathString().Compare(_T("E")) == 0);\r
1512                 ATLASSERT(list[2].GetWinPathString() == _T("Z"));\r
1513         }\r
1514         \r
1515         void RemoveChildrenTest()\r
1516         {\r
1517                 CTGitPathList list;\r
1518                 list.AddPath(CTGitPath(_T("c:\\test")));\r
1519                 list.AddPath(CTGitPath(_T("c:\\test\\file")));\r
1520                 list.AddPath(CTGitPath(_T("c:\\testfile")));\r
1521                 list.AddPath(CTGitPath(_T("c:\\parent")));\r
1522                 list.AddPath(CTGitPath(_T("c:\\parent\\child")));\r
1523                 list.AddPath(CTGitPath(_T("c:\\parent\\child1")));\r
1524                 list.AddPath(CTGitPath(_T("c:\\parent\\child2")));\r
1525                 \r
1526                 ATLASSERT(list.GetCount() == 7);\r
1527 \r
1528                 list.RemoveChildren();\r
1529                 \r
1530                 ATLTRACE("count = %d\n", list.GetCount());\r
1531                 ATLASSERT(list.GetCount() == 3);\r
1532 \r
1533                 list.SortByPathname();\r
1534 \r
1535                 ATLASSERT(list[0].GetWinPathString().Compare(_T("c:\\parent")) == 0);\r
1536                 ATLASSERT(list[1].GetWinPathString().Compare(_T("c:\\test")) == 0);\r
1537                 ATLASSERT(list[2].GetWinPathString().Compare(_T("c:\\testfile")) == 0);\r
1538         }\r
1539 \r
1540 #if defined(_MFC_VER)\r
1541         void ListLoadingTest()\r
1542         {\r
1543                 TCHAR buf[MAX_PATH];\r
1544                 GetCurrentDirectory(MAX_PATH, buf);\r
1545                 CString sPathList(_T("Path1*c:\\path2 with spaces and stuff*\\funnypath\\*"));\r
1546                 CTGitPathList testList;\r
1547                 testList.LoadFromAsteriskSeparatedString(sPathList);\r
1548 \r
1549                 ATLASSERT(testList.GetCount() == 3);\r
1550                 ATLASSERT(testList[0].GetWinPathString() == CString(buf) + _T("\\Path1"));\r
1551                 ATLASSERT(testList[1].GetWinPathString() == _T("c:\\path2 with spaces and stuff"));\r
1552                 ATLASSERT(testList[2].GetWinPathString() == _T("\\funnypath"));\r
1553                 \r
1554                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T(""));\r
1555                 testList.Clear();\r
1556                 sPathList = _T("c:\\path2 with spaces and stuff*c:\\funnypath\\*");\r
1557                 testList.LoadFromAsteriskSeparatedString(sPathList);\r
1558                 ATLASSERT(testList.GetCommonRoot().GetWinPathString() == _T("c:\\"));\r
1559         }\r
1560 #endif \r
1561 \r
1562         void ContainingDirectoryTest()\r
1563         {\r
1564 \r
1565                 CTGitPath testPath;\r
1566                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));\r
1567                 CTGitPath dir;\r
1568                 dir = testPath.GetContainingDirectory();\r
1569                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c\\d"));\r
1570                 dir = dir.GetContainingDirectory();\r
1571                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b\\c"));\r
1572                 dir = dir.GetContainingDirectory();\r
1573                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a\\b"));\r
1574                 dir = dir.GetContainingDirectory();\r
1575                 ATLASSERT(dir.GetWinPathString() == _T("c:\\a"));\r
1576                 dir = dir.GetContainingDirectory();\r
1577                 ATLASSERT(dir.GetWinPathString() == _T("c:\\"));\r
1578                 dir = dir.GetContainingDirectory();\r
1579                 ATLASSERT(dir.IsEmpty());\r
1580                 ATLASSERT(dir.GetWinPathString() == _T(""));\r
1581         }\r
1582         \r
1583         void AncestorTest()\r
1584         {\r
1585                 CTGitPath testPath;\r
1586                 testPath.SetFromWin(_T("c:\\windows"));\r
1587                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\")))==false);\r
1588                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows"))));\r
1589                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windowsdummy")))==false);\r
1590                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\test.txt"))));\r
1591                 ATLASSERT(testPath.IsAncestorOf(CTGitPath(_T("c:\\windows\\system32\\test.txt"))));\r
1592         }\r
1593 \r
1594         void SubversionPathTest()\r
1595         {\r
1596                 CTGitPath testPath;\r
1597                 testPath.SetFromWin(_T("c:\\"));\r
1598                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:") == 0);\r
1599                 testPath.SetFromWin(_T("c:\\folder"));\r
1600                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/folder") == 0);\r
1601                 testPath.SetFromWin(_T("c:\\a\\b\\c\\d\\e"));\r
1602                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "c:/a/b/c/d/e") == 0);\r
1603                 testPath.SetFromUnknown(_T("http://testing/"));\r
1604                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing") == 0);\r
1605                 testPath.SetFromGit(NULL);\r
1606                 ATLASSERT(strlen(testPath.GetGitApiPath(pool))==0);\r
1607 #if defined(_MFC_VER)\r
1608                 testPath.SetFromUnknown(_T("http://testing again"));\r
1609                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);\r
1610                 testPath.SetFromUnknown(_T("http://testing%20again"));\r
1611                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20again") == 0);\r
1612                 testPath.SetFromUnknown(_T("http://testing special chars \344\366\374"));\r
1613                 ATLASSERT(strcmp(testPath.GetGitApiPath(pool), "http://testing%20special%20chars%20%c3%a4%c3%b6%c3%bc") == 0);          \r
1614 #endif\r
1615         }\r
1616 \r
1617         void GetCommonRootTest()\r
1618         {\r
1619                 CTGitPath pathA (_T("C:\\Development\\LogDlg.cpp"));\r
1620                 CTGitPath pathB (_T("C:\\Development\\LogDlg.h"));\r
1621                 CTGitPath pathC (_T("C:\\Development\\SomeDir\\LogDlg.h"));\r
1622                 \r
1623                 CTGitPathList list;\r
1624                 list.AddPath(pathA);\r
1625                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development\\LogDlg.cpp"))==0);\r
1626                 list.AddPath(pathB);\r
1627                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);\r
1628                 list.AddPath(pathC);\r
1629                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("C:\\Development"))==0);\r
1630 #ifdef _MFC_VER\r
1631                 list.Clear();\r
1632                 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");\r
1633                 list.LoadFromAsteriskSeparatedString(sPathList);\r
1634                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("D:\\Development\\StExBar"))==0);\r
1635 \r
1636                 list.Clear();\r
1637                 sPathList = _T("c:\\windows\\explorer.exe*c:\\windows");\r
1638                 list.LoadFromAsteriskSeparatedString(sPathList);\r
1639                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);\r
1640 \r
1641                 list.Clear();\r
1642                 sPathList = _T("c:\\windows\\*c:\\windows");\r
1643                 list.LoadFromAsteriskSeparatedString(sPathList);\r
1644                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);\r
1645 \r
1646                 list.Clear();\r
1647                 sPathList = _T("c:\\windows\\system32*c:\\windows\\system");\r
1648                 list.LoadFromAsteriskSeparatedString(sPathList);\r
1649                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\windows"))==0);\r
1650 \r
1651                 list.Clear();\r
1652                 sPathList = _T("c:\\windowsdummy*c:\\windows");\r
1653                 list.LoadFromAsteriskSeparatedString(sPathList);\r
1654                 ATLASSERT(list.GetCommonRoot().GetWinPathString().CompareNoCase(_T("c:\\"))==0);\r
1655 #endif\r
1656         }\r
1657         \r
1658         void ValidPathAndUrlTest()\r
1659         {\r
1660                 CTGitPath testPath;\r
1661                 testPath.SetFromWin(_T("c:\\a\\b\\c.test.txt"));\r
1662                 ATLASSERT(testPath.IsValidOnWindows());\r
1663                 testPath.SetFromWin(_T("c:\\"));\r
1664                 ATLASSERT(testPath.IsValidOnWindows());\r
1665                 testPath.SetFromWin(_T("D:\\.Net\\SpindleSearch\\"));\r
1666                 ATLASSERT(testPath.IsValidOnWindows());\r
1667                 testPath.SetFromWin(_T("c"));\r
1668                 ATLASSERT(testPath.IsValidOnWindows());\r
1669                 testPath.SetFromWin(_T("c:\\test folder\\file"));\r
1670                 ATLASSERT(testPath.IsValidOnWindows());\r
1671                 testPath.SetFromWin(_T("c:\\folder\\"));\r
1672                 ATLASSERT(testPath.IsValidOnWindows());\r
1673                 testPath.SetFromWin(_T("c:\\ext.ext.ext\\ext.ext.ext.ext"));\r
1674                 ATLASSERT(testPath.IsValidOnWindows());\r
1675                 testPath.SetFromWin(_T("c:\\.svn"));\r
1676                 ATLASSERT(testPath.IsValidOnWindows());\r
1677                 testPath.SetFromWin(_T("c:\\com\\file"));\r
1678                 ATLASSERT(testPath.IsValidOnWindows());\r
1679                 testPath.SetFromWin(_T("c:\\test\\conf"));\r
1680                 ATLASSERT(testPath.IsValidOnWindows());\r
1681                 testPath.SetFromWin(_T("c:\\LPT"));\r
1682                 ATLASSERT(testPath.IsValidOnWindows());\r
1683                 testPath.SetFromWin(_T("c:\\test\\LPT"));\r
1684                 ATLASSERT(testPath.IsValidOnWindows());\r
1685                 testPath.SetFromWin(_T("c:\\com1test"));\r
1686                 ATLASSERT(testPath.IsValidOnWindows());\r
1687                 testPath.SetFromWin(_T("\\\\?\\c:\\test\\com1test"));\r
1688                 ATLASSERT(testPath.IsValidOnWindows());\r
1689 \r
1690                 testPath.SetFromWin(_T("\\\\Share\\filename"));\r
1691                 ATLASSERT(testPath.IsValidOnWindows());\r
1692                 testPath.SetFromWin(_T("\\\\Share\\filename.extension"));\r
1693                 ATLASSERT(testPath.IsValidOnWindows());\r
1694                 testPath.SetFromWin(_T("\\\\Share\\.svn"));\r
1695                 ATLASSERT(testPath.IsValidOnWindows());\r
1696 \r
1697                 // now the negative tests\r
1698                 testPath.SetFromWin(_T("c:\\test:folder"));\r
1699                 ATLASSERT(!testPath.IsValidOnWindows());\r
1700                 testPath.SetFromWin(_T("c:\\file<name"));\r
1701                 ATLASSERT(!testPath.IsValidOnWindows());\r
1702                 testPath.SetFromWin(_T("c:\\something*else"));\r
1703                 ATLASSERT(!testPath.IsValidOnWindows());\r
1704                 testPath.SetFromWin(_T("c:\\folder\\file?nofile"));\r
1705                 ATLASSERT(!testPath.IsValidOnWindows());\r
1706                 testPath.SetFromWin(_T("c:\\ext.>ension"));\r
1707                 ATLASSERT(!testPath.IsValidOnWindows());\r
1708                 testPath.SetFromWin(_T("c:\\com1\\filename"));\r
1709                 ATLASSERT(!testPath.IsValidOnWindows());\r
1710                 testPath.SetFromWin(_T("c:\\com1"));\r
1711                 ATLASSERT(!testPath.IsValidOnWindows());\r
1712                 testPath.SetFromWin(_T("c:\\com1\\AuX"));\r
1713                 ATLASSERT(!testPath.IsValidOnWindows());\r
1714 \r
1715                 testPath.SetFromWin(_T("\\\\Share\\lpt9\\filename"));\r
1716                 ATLASSERT(!testPath.IsValidOnWindows());\r
1717                 testPath.SetFromWin(_T("\\\\Share\\prn"));\r
1718                 ATLASSERT(!testPath.IsValidOnWindows());\r
1719                 testPath.SetFromWin(_T("\\\\Share\\NUL"));\r
1720                 ATLASSERT(!testPath.IsValidOnWindows());\r
1721                 \r
1722                 // now come some URL tests\r
1723                 testPath.SetFromGit(_T("http://myserver.com/repos/trunk"));\r
1724                 ATLASSERT(testPath.IsValidOnWindows());\r
1725                 testPath.SetFromGit(_T("https://myserver.com/repos/trunk/file%20with%20spaces"));\r
1726                 ATLASSERT(testPath.IsValidOnWindows());\r
1727                 testPath.SetFromGit(_T("svn://myserver.com/repos/trunk/file with spaces"));\r
1728                 ATLASSERT(testPath.IsValidOnWindows());\r
1729                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk"));\r
1730                 ATLASSERT(testPath.IsValidOnWindows());\r
1731                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk"));\r
1732                 ATLASSERT(testPath.IsValidOnWindows());\r
1733                 testPath.SetFromGit(_T("file:///C:/GitRepos/Tester/Proj1/tags/t2"));\r
1734                 ATLASSERT(testPath.IsValidOnWindows());\r
1735                 // and some negative URL tests\r
1736                 testPath.SetFromGit(_T("httpp://myserver.com/repos/trunk"));\r
1737                 ATLASSERT(!testPath.IsValidOnWindows());\r
1738                 testPath.SetFromGit(_T("https://myserver.com/rep:os/trunk/file%20with%20spaces"));\r
1739                 ATLASSERT(!testPath.IsValidOnWindows());\r
1740                 testPath.SetFromGit(_T("svn://myserver.com/rep<os/trunk/file with spaces"));\r
1741                 ATLASSERT(!testPath.IsValidOnWindows());\r
1742                 testPath.SetFromGit(_T("svn+ssh://www.myserver.com/repos/trunk/prn/"));\r
1743                 ATLASSERT(!testPath.IsValidOnWindows());\r
1744                 testPath.SetFromGit(_T("http://localhost:90/repos/trunk/com1"));\r
1745                 ATLASSERT(!testPath.IsValidOnWindows());\r
1746                 \r
1747         }\r
1748 \r
1749 } TGitPathTestobject;\r
1750 #endif\r
1751 #endif\r
1752 \r
1753 CTGitPath * CTGitPathList::LookForGitPath(CString path)\r
1754 {\r
1755         int i=0;\r
1756         for(i=0;i<this->GetCount();i++)\r
1757         {\r
1758                 if((*this)[i].GetGitPathString() == path )\r
1759                         return (CTGitPath*)&(*this)[i];\r
1760         }\r
1761         return NULL;\r
1762 }\r
1763 \r
1764 CString CTGitPath::GetActionName()\r
1765 {\r
1766         if(m_Action  & CTGitPath::LOGACTIONS_ADDED)\r
1767                 return _T("Added");\r
1768         if(m_Action  & CTGitPath::LOGACTIONS_DELETED)\r
1769                 return _T("Deleted");\r
1770         if(m_Action  & CTGitPath::LOGACTIONS_MODIFIED)\r
1771                 return _T("Modified");\r
1772         if(m_Action  & CTGitPath::LOGACTIONS_REPLACED)\r
1773                 return _T("Rename");\r
1774         return _T("Unknown");\r
1775 }\r
1776 \r
1777 int CTGitPathList::GetAction()\r
1778 {\r
1779         return m_Action;\r
1780 }\r