OSDN Git Service

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