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         : m_nInit(0)
  28 //      , m_bVSNETHack(false)
  29 //      , m_pool(NULL)
  30 {
  31 }
  32
  33 GitAdminDir::~GitAdminDir()
  34 {
  35 //      if (m_nInit)
  36 //               (m_pool);
  37 }
  38
  39 bool GitAdminDir::Init()
  40 {
  41         if (m_nInit==0)
  42         {
  43 #if 0
  44                 m_bVSNETHack = false;
  45                 m_pool = svn_pool_create(NULL);
  46                 size_t ret = 0;
  47                 getenv_s(&ret, NULL, 0, "GIT_ASP_DOT_NET_HACK");
  48                 if (ret)
  49                 {
  50                         svn_error_clear(svn_wc_set_adm_dir("_git", m_pool));
  51                         m_bVSNETHack = true;
  52                 }
  53 #endif
  54         }
  55         m_nInit++;
  56         return true;
  57 }
  58
  59 bool GitAdminDir::Close()
  60 {
  61         m_nInit--;
  62         if (m_nInit>0)
  63                 return false;
  64 #if 0
  65         svn_pool_destroy(m_pool);
  66 #endif
  67         return true;
  68 }
  69
  70 CString GitAdminDir::GetSuperProjectRoot(const CString& path)
  71 {
  72         CString projectroot=path;
  73
  74         do
  75         {
  76                 if(CGit::GitPathFileExists(projectroot + _T("\\.gitmodules")))
  77                 {
  78                         return projectroot;
  79                 }
  80
  81                 projectroot = projectroot.Left(projectroot.ReverseFind('\\'));
  82
  83         }while(projectroot.ReverseFind('\\')>0);
  84
  85         return _T("");
  86
  87 }
  88
  89 bool GitAdminDir::IsAdminDirName(const CString& name) const
  90 {
  91 #if 0
  92         CStringA nameA = CUnicodeUtils::GetUTF8(name).MakeLower();
  93         return !!svn_wc_is_adm_dir(nameA, m_pool);
  94 #endif
  95         return name == ".git";
  96 }
  97 CString GitAdminDir::GetGitTopDir(const CString& path)
  98 {
  99         CString str;
 100         str=_T("");
 101         HasAdminDir(path,!!PathIsDirectory(path),&str);
 102         return str;
 103 }
 104
 105 bool GitAdminDir::HasAdminDir(const CString& path) const
 106 {
 107         return HasAdminDir(path, !!PathIsDirectory(path));
 108 }
 109
 110 bool GitAdminDir::HasAdminDir(const CString& path,CString *ProjectTopDir) const
 111 {
 112         return HasAdminDir(path, !!PathIsDirectory(path),ProjectTopDir);
 113 }
 114
 115 bool GitAdminDir::HasAdminDir(const CString& path, bool bDir,CString *ProjectTopDir) const
 116 {
 117         if (path.IsEmpty())
 118                 return false;
 119         CString sDirName = path;
 120         if (!bDir)
 121         {
 122                 sDirName = path.Left(path.ReverseFind(_T('\\')));
 123         }
 124
 125         // a .git dir or anything inside it should be left out, only interested in working copy files -- Myagi
 126         {
 127         int n = 0;
 128         for (;;)
 129         {
 130                 n = sDirName.Find(_T("\\.git"), n);
 131                 if (n < 0)
 132                 {
 133                         break;
 134                 }
 135
 136                 // check for actual .git dir (and not .gitignore or something else), continue search if false match
 137                 n += 5;
 138                 if (sDirName[n] == _T('\\') || sDirName[n] == 0)
 139                 {
 140                         return false;
 141                 }
 142         }
 143         }
 144
 145         for (;;)
 146         {
 147                 if(CGit::GitPathFileExists(sDirName + _T("\\.git")))
 148                 {
 149                         if(ProjectTopDir)
 150                         {
 151                                 *ProjectTopDir=sDirName;
 152                                 // Make sure to add the trailing slash to root paths such as 'C:'
 153                                 if (sDirName.GetLength() == 2 && sDirName[1] == _T(':'))
 154                                         (*ProjectTopDir) += _T("\\");
 155                         }
 156                         return true;
 157                 }
 158
 159                 int x = sDirName.ReverseFind(_T('\\'));
 160                 if (x < 2)
 161                         break;
 162
 163                 sDirName = sDirName.Left(x);
 164         }
 165
 166         return false;
 167
 168 }
 169 /**
 170  * Returns the .git-path (if .git is a file, read the repository path and return it)
 171  * adminDir always ends with "\"
 172  */
 173 bool GitAdminDir::GetAdminDirPath(const CString &projectTopDir, CString &adminDir) const
 174 {
 175         if (IsBareRepo(projectTopDir))
 176         {
 177                 adminDir = projectTopDir;
 178                 adminDir.TrimRight('\\');
 179                 adminDir.Append(_T("\\"));
 180                 return true;
 181         }
 182
 183         CString sDotGitPath = projectTopDir + _T("\\") + g_GitAdminDir.GetAdminDirName();
 184         if (CTGitPath(sDotGitPath).IsDirectory())
 185         {
 186                 sDotGitPath.TrimRight('\\');
 187                 sDotGitPath.Append(_T("\\"));
 188                 adminDir = sDotGitPath;
 189                 return true;
 190         }
 191         else
 192         {
 193                 FILE *pFile;
 194                 _tfopen_s(&pFile, sDotGitPath, _T("r"));
 195
 196                 if (!pFile)
 197                         return false;
 198
 199                 char s[MAX_PATH + 8] = {0};
 200                 fgets(s, sizeof(s), pFile);
 201
 202                 fclose(pFile);
 203                 CString gitPath(s);
 204                 if (gitPath.Find(L"gitdir: ") != 0)
 205                         return -1;
 206                 gitPath = gitPath.Trim().Mid(8); // 8 = len("gitdir: ")
 207                 gitPath.Replace('/', '\\');
 208                 gitPath.TrimRight('\\');
 209                 gitPath.Append(_T("\\"));
 210                 if (gitPath.GetLength() > 0 && gitPath[0] == _T('.'))
 211                 {
 212                         gitPath = projectTopDir + _T("\\") + gitPath;
 213                         PathCanonicalize(adminDir.GetBuffer(MAX_PATH), gitPath.GetBuffer());
 214                         adminDir.ReleaseBuffer();
 215                         gitPath.ReleaseBuffer();
 216                         return true;
 217                 }
 218                 adminDir = gitPath;
 219                 return true;
 220         }
 221 }
 222
 223 bool GitAdminDir::IsAdminDirPath(const CString& path) const
 224 {
 225         if (path.IsEmpty())
 226                 return false;
 227         bool bIsAdminDir = false;
 228         CString lowerpath = path;
 229         lowerpath.MakeLower();
 230         int ind = -1;
 231         int ind1 = 0;
 232         while ((ind1 = lowerpath.Find(_T("\\.git"), ind1))>=0)
 233         {
 234                 ind = ind1++;
 235                 if (ind == (lowerpath.GetLength() - 5))
 236                 {
 237                         bIsAdminDir = true;
 238                         break;
 239                 }
 240                 else if (lowerpath.Find(_T("\\.git\\"), ind)>=0)
 241                 {
 242                         bIsAdminDir = true;
 243                         break;
 244                 }
 245         }
 246
 247         return bIsAdminDir;
 248 }
 249
 250 bool GitAdminDir::IsBareRepo(const CString& path) const
 251 {
 252         if (path.IsEmpty())
 253                 return false;
 254
 255         if (IsAdminDirPath(path))
 256                 return false;
 257
 258         if (!PathFileExists(path + _T("\\HEAD")) || !PathFileExists(path + _T("\\config")))
 259                 return false;
 260
 261         if (!PathFileExists(path + _T("\\objects\\")) || !PathFileExists(path + _T("\\refs\\")))
 262                 return false;
 263
 264         return true;
 265 }