src/Git/GitAdminDir.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2012 - TortoiseGit
   4 // Copyright (C) 2003-2008 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19
  20 #include "StdAfx.h"
  21 #include "UnicodeUtils.h"
  22 #include "GitAdminDir.h"
  23 #include "Git.h"
  24 GitAdminDir g_GitAdminDir;
  25
  26 GitAdminDir::GitAdminDir()
  27 {
  28 }
  29
  30 GitAdminDir::~GitAdminDir()
  31 {
  32 }
  33
  34 CString GitAdminDir::GetSuperProjectRoot(const CString& path)
  35 {
  36         CString projectroot=path;
  37
  38         do
  39         {
  40                 if(CGit::GitPathFileExists(projectroot + _T("\\.gitmodules")))
  41                 {
  42                         return projectroot;
  43                 }
  44
  45                 projectroot = projectroot.Left(projectroot.ReverseFind('\\'));
  46
  47         }while(projectroot.ReverseFind('\\')>0);
  48
  49         return _T("");
  50
  51 }
  52
  53 CString GitAdminDir::GetGitTopDir(const CString& path)
  54 {
  55         CString str;
  56         str=_T("");
  57         HasAdminDir(path,!!PathIsDirectory(path),&str);
  58         return str;
  59 }
  60
  61 bool GitAdminDir::HasAdminDir(const CString& path) const
  62 {
  63         return HasAdminDir(path, !!PathIsDirectory(path));
  64 }
  65
  66 bool GitAdminDir::HasAdminDir(const CString& path,CString *ProjectTopDir) const
  67 {
  68         return HasAdminDir(path, !!PathIsDirectory(path),ProjectTopDir);
  69 }
  70
  71 bool GitAdminDir::HasAdminDir(const CString& path, bool bDir,CString *ProjectTopDir) const
  72 {
  73         if (path.IsEmpty())
  74                 return false;
  75         CString sDirName = path;
  76         if (!bDir)
  77         {
  78                 sDirName = path.Left(path.ReverseFind(_T('\\')));
  79         }
  80
  81         // a .git dir or anything inside it should be left out, only interested in working copy files -- Myagi
  82         {
  83         int n = 0;
  84         for (;;)
  85         {
  86                 n = sDirName.Find(_T("\\.git"), n);
  87                 if (n < 0)
  88                 {
  89                         break;
  90                 }
  91
  92                 // check for actual .git dir (and not .gitignore or something else), continue search if false match
  93                 n += 5;
  94                 if (sDirName[n] == _T('\\') || sDirName[n] == 0)
  95                 {
  96                         return false;
  97                 }
  98         }
  99         }
 100
 101         for (;;)
 102         {
 103                 if(CGit::GitPathFileExists(sDirName + _T("\\.git")))
 104                 {
 105                         if(ProjectTopDir)
 106                         {
 107                                 *ProjectTopDir=sDirName;
 108                                 // Make sure to add the trailing slash to root paths such as 'C:'
 109                                 if (sDirName.GetLength() == 2 && sDirName[1] == _T(':'))
 110                                         (*ProjectTopDir) += _T("\\");
 111                         }
 112                         return true;
 113                 }
 114
 115                 int x = sDirName.ReverseFind(_T('\\'));
 116                 if (x < 2)
 117                         break;
 118
 119                 sDirName = sDirName.Left(x);
 120         }
 121
 122         return false;
 123
 124 }
 125 /**
 126  * Returns the .git-path (if .git is a file, read the repository path and return it)
 127  * adminDir always ends with "\"
 128  */
 129 bool GitAdminDir::GetAdminDirPath(const CString &projectTopDir, CString &adminDir) const
 130 {
 131         if (IsBareRepo(projectTopDir))
 132         {
 133                 adminDir = projectTopDir;
 134                 adminDir.TrimRight('\\');
 135                 adminDir.Append(_T("\\"));
 136                 return true;
 137         }
 138
 139         CString sDotGitPath = projectTopDir + _T("\\") + g_GitAdminDir.GetAdminDirName();
 140         if (CTGitPath(sDotGitPath).IsDirectory())
 141         {
 142                 sDotGitPath.TrimRight('\\');
 143                 sDotGitPath.Append(_T("\\"));
 144                 adminDir = sDotGitPath;
 145                 return true;
 146         }
 147         else
 148         {
 149                 FILE *pFile;
 150                 _tfopen_s(&pFile, sDotGitPath, _T("r"));
 151
 152                 if (!pFile)
 153                         return false;
 154
 155                 char s[MAX_PATH + 8] = {0};
 156                 fgets(s, sizeof(s), pFile);
 157
 158                 fclose(pFile);
 159                 CString gitPath(s);
 160                 if (gitPath.Find(L"gitdir: ") != 0)
 161                         return false;
 162                 gitPath = gitPath.Trim().Mid(8); // 8 = len("gitdir: ")
 163                 gitPath.Replace('/', '\\');
 164                 gitPath.TrimRight('\\');
 165                 gitPath.Append(_T("\\"));
 166                 if (gitPath.GetLength() > 0 && gitPath[0] == _T('.'))
 167                 {
 168                         gitPath = projectTopDir + _T("\\") + gitPath;
 169                         PathCanonicalize(adminDir.GetBuffer(MAX_PATH), gitPath.GetBuffer());
 170                         adminDir.ReleaseBuffer();
 171                         gitPath.ReleaseBuffer();
 172                         return true;
 173                 }
 174                 adminDir = gitPath;
 175                 return true;
 176         }
 177 }
 178
 179 bool GitAdminDir::IsAdminDirPath(const CString& path) const
 180 {
 181         if (path.IsEmpty())
 182                 return false;
 183         bool bIsAdminDir = false;
 184         CString lowerpath = path;
 185         lowerpath.MakeLower();
 186         int ind = -1;
 187         int ind1 = 0;
 188         while ((ind1 = lowerpath.Find(_T("\\.git"), ind1))>=0)
 189         {
 190                 ind = ind1++;
 191                 if (ind == (lowerpath.GetLength() - 5))
 192                 {
 193                         bIsAdminDir = true;
 194                         break;
 195                 }
 196                 else if (lowerpath.Find(_T("\\.git\\"), ind)>=0)
 197                 {
 198                         bIsAdminDir = true;
 199                         break;
 200                 }
 201         }
 202
 203         return bIsAdminDir;
 204 }
 205
 206 bool GitAdminDir::IsBareRepo(const CString& path) const
 207 {
 208         if (path.IsEmpty())
 209                 return false;
 210
 211         if (IsAdminDirPath(path))
 212                 return false;
 213
 214         if (!PathFileExists(path + _T("\\HEAD")) || !PathFileExists(path + _T("\\config")))
 215                 return false;
 216
 217         if (!PathFileExists(path + _T("\\objects\\")) || !PathFileExists(path + _T("\\refs\\")))
 218                 return false;
 219
 220         return true;
 221 }