src/TortoiseProc/LogDataVector.cpp

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