src/TortoiseProc/LogDataVector.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2009-2013, 2015 - 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 /*
  21         Description: start-up repository opening and reading
  22
  23         Author: Marco Costalba (C) 2005-2007
  24
  25         Copyright: See COPYING file that comes with this distribution
  26
  27 */
  28
  29 #include "stdafx.h"
  30 #include "TortoiseProc.h"
  31 #include "Git.h"
  32 #include "GitHash.h"
  33 #include "TGitPath.h"
  34 #include "GitLogListBase.h"
  35 #include "UnicodeUtils.h"
  36
  37 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  38
  39 void CLogDataVector::ClearAll()
  40 {
  41
  42         clear();
  43         m_HashMap.clear();
  44         m_Lns.clear();
  45
  46         m_FirstFreeLane=0;
  47         m_Lns.clear();
  48         if (m_pLogCache)
  49         {
  50                 m_pLogCache->ClearAllLanes();
  51         }
  52
  53         m_RawlogData.clear();
  54         m_RawLogStart.clear();
  55 }
  56
  57 //CLogDataVector Class
  58 int CLogDataVector::ParserFromLog(CTGitPath *path, int count, int infomask, CString *range)
  59 {
  60         // only enable --follow on files
  61         if ((path == NULL || path->IsDirectory()) && (infomask & CGit::LOG_INFO_FOLLOW))
  62                 infomask = infomask ^ CGit::LOG_INFO_FOLLOW;
  63
  64         CString gitrange = _T("HEAD");
  65         if (range != nullptr)
  66                 gitrange = *range;
  67         CString cmd = g_Git.GetLogCmd(gitrange, path, count, infomask, true);
  68
  69         if (!g_Git.CanParseRev(gitrange))
  70                 return 0;
  71
  72         try
  73         {
  74                 [] { git_init(); } ();
  75         }
  76         catch (const char* msg)
  77         {
  78                 MessageBox(NULL, _T("Could not initialize libgit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
  79                 return -1;
  80         }
  81
  82         GIT_LOG handle;
  83         try
  84         {
  85                 CAutoLocker lock(g_Git.m_critGitDllSec);
  86                 if (git_open_log(&handle,CUnicodeUtils::GetMulti(cmd, CP_UTF8).GetBuffer()))
  87                 {
  88                         return -1;
  89                 }
  90         }
  91         catch (char* msg)
  92         {
  93                 MessageBox(NULL, _T("Could not open log.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
  94                 return -1;
  95         }
  96
  97         try
  98         {
  99                 CAutoLocker lock(g_Git.m_critGitDllSec);
 100                 [&]{ git_get_log_firstcommit(handle); }();
 101         }
 102         catch (char* msg)
 103         {
 104                 MessageBox(NULL, _T("Could not get first commit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
 105                 return -1;
 106         }
 107
 108         int ret = 0;
 109         while (ret == 0)
 110         {
 111                 GIT_COMMIT commit;
 112
 113                 try
 114                 {
 115                         CAutoLocker lock(g_Git.m_critGitDllSec);
 116                         [&]{ ret = git_get_log_nextcommit(handle, &commit, infomask & CGit::LOG_INFO_FOLLOW); }();
 117                 }
 118                 catch (char* msg)
 119                 {
 120                         MessageBox(NULL, _T("Could not get next commit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
 121                         break;
 122                 }
 123
 124                 if (ret)
 125                 {
 126                         if (ret != -2) // other than end of revision walking
 127                                 MessageBox(nullptr, (_T("Could not get next commit.\nlibgit returns:") + std::to_wstring(ret)).c_str(), _T("TortoiseGit"), MB_ICONERROR);
 128                         break;
 129                 }
 130
 131                 if (commit.m_ignore == 1)
 132                 {
 133                         git_free_commit(&commit);
 134                         continue;
 135                 }
 136
 137                 CGitHash hash = (char*)commit.m_hash ;
 138
 139                 GitRevLoglist* pRev = this->m_pLogCache->GetCacheData(hash);
 140
 141                 char *pNote = nullptr;
 142                 {
 143                         CAutoLocker lock(g_Git.m_critGitDllSec);
 144                         git_get_notes(commit.m_hash, &pNote);
 145                 }
 146                 if (pNote)
 147                 {
 148                         pRev->m_Notes = CUnicodeUtils::GetUnicode(pNote);
 149                         free(pNote);
 150                         pNote = nullptr;
 151                 }
 152
 153                 ASSERT(pRev->m_CommitHash == hash);
 154                 pRev->ParserFromCommit(&commit);
 155                 pRev->ParserParentFromCommit(&commit);
 156                 git_free_commit(&commit);
 157                 // Must call free commit before SafeFetchFullInfo, commit parent is rewrite by log.
 158                 // file list will wrong if parent rewrite.
 159
 160                 if (!pRev->m_IsFull && (infomask & CGit::LOG_INFO_FULL_DIFF))
 161                 {
 162                         if (pRev->SafeFetchFullInfo(&g_Git))
 163                         {
 164                                 MessageBox(nullptr, pRev->GetLastErr(), _T("TortoiseGit"), MB_ICONERROR);
 165                                 return -1;
 166                         }
 167                 }
 168
 169                 this->push_back(pRev->m_CommitHash);
 170
 171                 m_HashMap[pRev->m_CommitHash] = (int)size() - 1;
 172
 173         }
 174
 175         {
 176                 CAutoLocker lock(g_Git.m_critGitDllSec);
 177                 git_close_log(handle);
 178         }
 179
 180         return 0;
 181 }
 182
 183 struct SortByParentDate
 184 {
 185         bool operator()(GitRevLoglist* pLhs, GitRevLoglist* pRhs)
 186         {
 187                 if (pLhs->m_CommitHash == pRhs->m_CommitHash)
 188                         return false;
 189                 for (auto it = pLhs->m_ParentHash.begin(); it != pLhs->m_ParentHash.end(); ++it)
 190                 {
 191                         if (*it == pRhs->m_CommitHash)
 192                                 return true;
 193                 }
 194                 for (auto it = pRhs->m_ParentHash.begin(); it != pRhs->m_ParentHash.end(); ++it)
 195                 {
 196                         if (*it == pLhs->m_CommitHash)
 197                                 return false;
 198                 }
 199                 return pLhs->GetCommitterDate()>pRhs->GetCommitterDate();
 200         }
 201 };
 202
 203 int CLogDataVector::Fill(std::set<CGitHash>& hashes)
 204 {
 205         try
 206         {
 207                 [] { git_init(); } ();
 208         }
 209         catch (const char* msg)
 210         {
 211                 MessageBox(nullptr, _T("Could not initialize libgit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
 212                 return -1;
 213         }
 214
 215         std::set<GitRevLoglist*, SortByParentDate> revs;
 216
 217         for (auto it = hashes.begin(); it != hashes.end(); ++it)
 218         {
 219                 CGitHash hash = *it;
 220                 GitRevLoglist* pRev = this->m_pLogCache->GetCacheData(hash);
 221                 ASSERT(pRev->m_CommitHash == hash);
 222
 223                 GIT_COMMIT commit;
 224                 try
 225                 {
 226                         CAutoLocker lock(g_Git.m_critGitDllSec);
 227                         if (git_get_commit_from_hash(&commit, hash.m_hash))
 228                         {
 229                                 return -1;
 230                         }
 231                 }
 232                 catch (char * msg)
 233                 {
 234                         MessageBox(nullptr, _T("Could not get commit \"") + hash.ToString() + _T("\".\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
 235                         return -1;
 236                 }
 237
 238                 // right now this code is only used by TortoiseGitBlame,
 239                 // as such git notes are not needed to be loaded
 240
 241                 pRev->ParserFromCommit(&commit);
 242                 pRev->ParserParentFromCommit(&commit);
 243                 git_free_commit(&commit);
 244
 245                 revs.insert(pRev);
 246         }
 247
 248         for (auto it = revs.begin(); it != revs.end(); ++it)
 249         {
 250                 GitRev *pRev = *it;
 251                 this->push_back(pRev->m_CommitHash);
 252                 m_HashMap[pRev->m_CommitHash] = (int)size() - 1;
 253         }
 254
 255         return 0;
 256 }
 257
 258 int AddTolist(unsigned char * /*osha1*/, unsigned char *nsha1, const char * /*name*/, unsigned long /*time*/, int /*sz*/, const char *msg, void *data)
 259 {
 260         CLogDataVector *vector = (CLogDataVector*)data;
 261         GitRevLoglist rev;
 262         rev.m_CommitHash = (char*)nsha1;
 263
 264         CString one = CUnicodeUtils::GetUnicode(msg);
 265
 266         int message = one.Find(_T(":"), 0);
 267         if (message > 0)
 268         {
 269                 rev.m_RefAction = one.Left(message);
 270                 rev.GetSubject() = one.Mid(message + 1);
 271         }
 272
 273         vector->m_pLogCache->m_HashMap[rev.m_CommitHash] = rev;
 274         vector->insert(vector->begin(),rev.m_CommitHash);
 275
 276         return 0;
 277 }
 278
 279 void CLogDataVector::append(CGitHash& sha, bool storeInVector)
 280 {
 281         if (storeInVector)
 282                 this->push_back(sha);
 283
 284         GitRevLoglist* r = &m_pLogCache->m_HashMap[sha];
 285         updateLanes(*r, this->m_Lns, sha);
 286 }
 287
 288 void CLogDataVector::setLane(CGitHash& sha)
 289 {
 290         Lanes* l = &(this->m_Lns);
 291         int i = m_FirstFreeLane;
 292
 293 //      QVector<QByteArray> ba;
 294 //      const ShaString& ss = toPersistentSha(sha, ba);
 295 //      const ShaVect& shaVec(fh->revOrder);
 296
 297         for (int cnt = (int)size(); i < cnt; ++i) {
 298
 299                 GitRevLoglist* r = &this->GetGitRevAt(i);
 300                 CGitHash curSha=r->m_CommitHash;
 301
 302                 if (r->m_Lanes.empty())
 303                         updateLanes(*r, *l, curSha);
 304
 305                 if (curSha == sha)
 306                         break;
 307         }
 308         m_FirstFreeLane = ++i;
 309
 310 #if 0
 311         Lanes* l = &(this->m_Lanes);
 312         int i = m_FirstFreeLane;
 313
 314         QVector<QByteArray> ba;
 315         const ShaString& ss = toPersistentSha(sha, ba);
 316         const ShaVect& shaVec(fh->revOrder);
 317
 318         for (uint cnt = shaVec.count(); i < cnt; ++i) {
 319
 320                 const ShaString& curSha = shaVec[i];
 321                 Rev* r = m_HashMap[curSha]const_cast<Rev*>(revLookup(curSha, fh));
 322                 if (r->lanes.count() == 0)
 323                         updateLanes(*r, *l, curSha);
 324
 325                 if (curSha == ss)
 326                         break;
 327         }
 328         fh->firstFreeLane = ++i;
 329 #endif
 330 }
 331
 332
 333 void CLogDataVector::updateLanes(GitRevLoglist& c, Lanes& lns, CGitHash& sha)
 334 {
 335 // we could get third argument from c.sha(), but we are in fast path here
 336 // and c.sha() involves a deep copy, so we accept a little redundancy
 337
 338         if (lns.isEmpty())
 339                 lns.init(sha);
 340
 341         bool isDiscontinuity;
 342         bool isFork = lns.isFork(sha, isDiscontinuity);
 343         bool isMerge = (c.ParentsCount() > 1);
 344         bool isInitial = (c.ParentsCount() == 0);
 345
 346         if (isDiscontinuity)
 347                 lns.changeActiveLane(sha); // uses previous isBoundary state
 348
 349         lns.setBoundary(c.IsBoundary() == TRUE); // update must be here
 350         TRACE(_T("%s %d"),c.m_CommitHash.ToString(),c.IsBoundary());
 351
 352         if (isFork)
 353                 lns.setFork(sha);
 354         if (isMerge)
 355                 lns.setMerge(c.m_ParentHash);
 356         //if (c.isApplied)
 357         //      lns.setApplied();
 358         if (isInitial)
 359                 lns.setInitial();
 360
 361         lns.getLanes(c.m_Lanes); // here lanes are snapshotted
 362
 363         CGitHash nextSha;
 364         if( !isInitial)
 365                 nextSha = c.m_ParentHash[0];
 366
 367         lns.nextParent(nextSha);
 368
 369         //if (c.isApplied)
 370         //      lns.afterApplied();
 371         if (isMerge)
 372                 lns.afterMerge();
 373         if (isFork)
 374                 lns.afterFork();
 375         if (lns.isBranch())
 376                 lns.afterBranch();
 377 }