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