src/TortoiseProc/Commands/CleanupCommand.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2009, 2011-2017 - TortoiseGit
   4 // Copyright (C) 2007-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 "CleanupCommand.h"
  22
  23 #include "MessageBox.h"
  24 #include "ProgressDlg.h"
  25 #include "ShellUpdater.h"
  26 #include "CleanTypeDlg.h"
  27 #include "../Utils/UnicodeUtils.h"
  28 #include "SysProgressDlg.h"
  29
  30 static CString UnescapeQuotePath(CString s)
  31 {
  32         CStringA t;
  33         for (int i = 0; i < s.GetLength(); ++i)
  34         {
  35                 if (s[i] == '\\' && i + 3 < s.GetLength())
  36                 {
  37                         char c = (char)((s[i + 1] - '0') * 64 + (s[i + 2] - '0') * 8 + (s[i + 3] - '0'));
  38                         t += c;
  39                         i += 3;
  40                 }
  41                 else
  42                         t += s[i];
  43         }
  44
  45         return CUnicodeUtils::GetUnicode(t);
  46 }
  47
  48 struct SubmodulePayload
  49 {
  50         STRING_VECTOR &list;
  51         CString basePath;
  52         STRING_VECTOR prefixList;
  53         SubmodulePayload(STRING_VECTOR &alist, CString abasePath = L"", STRING_VECTOR aprefixList = STRING_VECTOR())
  54                 : list(alist)
  55                 , basePath(abasePath)
  56                 , prefixList(aprefixList)
  57         {
  58         }
  59 };
  60
  61 static bool GetSubmodulePathList(SubmodulePayload &payload);
  62
  63 static int SubmoduleCallback(git_submodule *sm, const char * /*name*/, void *payload)
  64 {
  65         auto spayload = reinterpret_cast<SubmodulePayload*>(payload);
  66         CString path = CUnicodeUtils::GetUnicode(git_submodule_path(sm));
  67         CString fullPath(spayload->basePath);
  68         fullPath += L'\\';
  69         fullPath += path;
  70         if (!PathIsDirectory(fullPath))
  71                 return 0;
  72         if (spayload->prefixList.empty())
  73         {
  74                 CTGitPath subPath(spayload->basePath);
  75                 subPath.AppendPathString(path);
  76                 spayload->list.push_back(subPath.GetGitPathString());
  77                 SubmodulePayload tpayload(spayload->list, subPath.GetGitPathString());
  78                 GetSubmodulePathList(tpayload);
  79         }
  80         else
  81         {
  82                 for (size_t i = 0; i < spayload->prefixList.size(); ++i)
  83                 {
  84                         CString prefix = spayload->prefixList.at(i) + L'/';
  85                         if (CStringUtils::StartsWith(path, prefix))
  86                         {
  87                                 CTGitPath subPath(spayload->basePath);
  88                                 subPath.AppendPathString(path);
  89                                 spayload->list.push_back(subPath.GetGitPathString());
  90                                 SubmodulePayload tpayload(spayload->list, subPath.GetGitPathString());
  91                                 GetSubmodulePathList(tpayload);
  92                         }
  93                 }
  94         }
  95         return 0;
  96 }
  97
  98 static bool GetSubmodulePathList(SubmodulePayload &payload)
  99 {
 100         CAutoRepository repo(payload.basePath);
 101         if (!repo)
 102         {
 103                 // Silence the warning message, submodule may not be initialized yet.
 104                 return false;
 105         }
 106
 107         if (git_submodule_foreach(repo, SubmoduleCallback, &payload))
 108         {
 109                 MessageBox(hWndExplorer, CGit::GetLibGit2LastErr(L"Could not get submodule list."), L"TortoiseGit", MB_ICONERROR);
 110                 return false;
 111         }
 112
 113         return true;
 114 }
 115
 116 static bool GetFilesToCleanUp(CTGitPathList& delList, const CString& baseCmd, CGit *pGit, const CString& path, const boolean quotepath, CSysProgressDlg& sysProgressDlg)
 117 {
 118         CString cmd(baseCmd);
 119         if (!path.IsEmpty())
 120                 cmd += L" -- \"" + path + L'"';
 121
 122         CString cmdout, cmdouterr;
 123         if (pGit->Run(cmd, &cmdout, &cmdouterr, CP_UTF8))
 124         {
 125                 if (cmdouterr.IsEmpty())
 126                         cmdouterr.Format(IDS_GITEXEERROR_NOMESSAGE, (LPCTSTR)cmdout);
 127                 MessageBox(hWndExplorer, cmdouterr, L"TortoiseGit", MB_ICONERROR);
 128                 return false;
 129         }
 130
 131         if (sysProgressDlg.HasUserCancelled())
 132         {
 133                 CMessageBox::Show(hWndExplorer, IDS_USERCANCELLED, IDS_APPNAME, MB_OK);
 134                 return false;
 135         }
 136
 137         int pos = 0;
 138         CString token = cmdout.Tokenize(L"\n", pos);
 139         while (!token.IsEmpty())
 140         {
 141                 if (token.Mid(0, 13) == L"Would remove ")
 142                 {
 143                         CString tempPath = token.Mid(13).TrimRight();
 144                         if (quotepath)
 145                                 tempPath = UnescapeQuotePath(tempPath.Trim(L'"'));
 146                         delList.AddPath(pGit->CombinePath(tempPath));
 147                 }
 148
 149                 token = cmdout.Tokenize(L"\n", pos);
 150         }
 151
 152         if (sysProgressDlg.HasUserCancelled())
 153         {
 154                 CMessageBox::Show(hWndExplorer, IDS_USERCANCELLED, IDS_APPNAME, MB_OK);
 155                 return false;
 156         }
 157
 158         return true;
 159 }
 160
 161 static bool DoCleanUp(const CTGitPathList& pathList, int cleanType, bool bDir, bool bSubmodules, bool bDryRun, bool bNoRecycleBin)
 162 {
 163         CString cmd;
 164         cmd.Format(L"git.exe clean");
 165         if (bDryRun || !bNoRecycleBin)
 166                 cmd += L" -n ";
 167         if (bDir)
 168                 cmd += L" -d ";
 169         switch (cleanType)
 170         {
 171         case 0:
 172                 cmd += L" -fx";
 173                 break;
 174         case 1:
 175                 cmd += L" -f";
 176                 break;
 177         case 2:
 178                 cmd += L" -fX";
 179                 break;
 180         }
 181
 182         STRING_VECTOR submoduleList;
 183         if (bSubmodules)
 184         {
 185                 SubmodulePayload payload(submoduleList);
 186                 payload.basePath = CTGitPath(g_Git.m_CurrentDir).GetGitPathString();
 187                 if (pathList.GetCount() != 1 || pathList.GetCount() == 1 && !pathList[0].IsEmpty())
 188                 {
 189                         for (int i = 0; i < pathList.GetCount(); ++i)
 190                         {
 191                                 CString path;
 192                                 if (pathList[i].IsDirectory())
 193                                         payload.prefixList.push_back(pathList[i].GetGitPathString());
 194                                 else
 195                                         payload.prefixList.push_back(pathList[i].GetContainingDirectory().GetGitPathString());
 196                         }
 197                 }
 198                 if (!GetSubmodulePathList(payload))
 199                         return false;
 200                 std::sort(submoduleList.begin(), submoduleList.end());
 201         }
 202
 203         if (bDryRun || bNoRecycleBin)
 204         {
 205                 CProgressDlg progress;
 206                 for (int i = 0; i < pathList.GetCount(); ++i)
 207                 {
 208                         CString path;
 209                         if (pathList[i].IsDirectory())
 210                                 path = pathList[i].GetGitPathString();
 211                         else
 212                                 path = pathList[i].GetContainingDirectory().GetGitPathString();
 213
 214                         progress.m_GitDirList.push_back(g_Git.m_CurrentDir);
 215                         progress.m_GitCmdList.push_back(cmd + (path.IsEmpty() ? L"" : (L" -- \"" + path + L'"')));
 216                 }
 217
 218                 for (CString dir : submoduleList)
 219                 {
 220                         progress.m_GitDirList.push_back(CTGitPath(dir).GetWinPathString());
 221                         progress.m_GitCmdList.push_back(cmd);
 222                 }
 223
 224                 progress.m_PostCmdCallback = [&](DWORD status, PostCmdList& postCmdList)
 225                 {
 226                         if (status)
 227                                 postCmdList.emplace_back(IDS_MSGBOX_RETRY, [&]{ DoCleanUp(pathList, cleanType, bDir, bSubmodules, bDryRun, bNoRecycleBin); });
 228
 229                         if (status || !bDryRun)
 230                                 return;
 231
 232                         if (bNoRecycleBin)
 233                         {
 234                                 postCmdList.emplace_back(IDS_CLEAN_NO_RECYCLEBIN, [&]{ DoCleanUp(pathList, cleanType, bDir, bSubmodules, FALSE, TRUE); });
 235                                 postCmdList.emplace_back(IDS_CLEAN_TO_RECYCLEBIN, [&]{ DoCleanUp(pathList, cleanType, bDir, bSubmodules, FALSE, FALSE); });
 236                         }
 237                         else
 238                         {
 239                                 postCmdList.emplace_back(IDS_CLEAN_TO_RECYCLEBIN, [&]{ DoCleanUp(pathList, cleanType, bDir, bSubmodules, FALSE, FALSE); });
 240                                 postCmdList.emplace_back(IDS_CLEAN_NO_RECYCLEBIN, [&]{ DoCleanUp(pathList, cleanType, bDir, bSubmodules, FALSE, TRUE); });
 241                         }
 242                 };
 243
 244                 INT_PTR result = progress.DoModal();
 245                 return result == IDOK;
 246         }
 247         else
 248         {
 249                 CSysProgressDlg sysProgressDlg;
 250                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
 251                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_CLEANUP_INFO1)));
 252                 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
 253                 sysProgressDlg.SetShowProgressBar(false);
 254                 sysProgressDlg.ShowModeless((HWND)nullptr, true);
 255
 256                 bool quotepath = g_Git.GetConfigValueBool(L"core.quotepath");
 257
 258                 CTGitPathList delList;
 259                 for (int i = 0; i < pathList.GetCount(); ++i)
 260                 {
 261                         CString path;
 262                         if (pathList[i].IsDirectory())
 263                                 path = pathList[i].GetGitPathString();
 264                         else
 265                                 path = pathList[i].GetContainingDirectory().GetGitPathString();
 266
 267                         if (!GetFilesToCleanUp(delList, cmd, &g_Git, path, quotepath, sysProgressDlg))
 268                                 return false;
 269                 }
 270
 271                 for (CString dir : submoduleList)
 272                 {
 273                         CGit git;
 274                         git.m_CurrentDir = dir;
 275                         if (!GetFilesToCleanUp(delList, cmd, &git, L"", quotepath, sysProgressDlg))
 276                                 return false;
 277                 }
 278
 279                 delList.DeleteAllFiles(true, false, true);
 280
 281                 sysProgressDlg.Stop();
 282         }
 283
 284         return true;
 285 }
 286
 287 bool CleanupCommand::Execute()
 288 {
 289         bool bRet = false;
 290
 291         CCleanTypeDlg dlg;
 292         dlg.m_pathList = pathList;
 293         if (dlg.DoModal() == IDOK)
 294         {
 295                 bRet = DoCleanUp(pathList, dlg.m_CleanType, dlg.m_bDir == BST_CHECKED, dlg.m_bSubmodules == BST_CHECKED, dlg.m_bDryRun == BST_CHECKED, dlg.m_bNoRecycleBin == BST_CHECKED);
 296
 297                 CShellUpdater::Instance().Flush();
 298         }
 299         return bRet;
 300 }