src/TortoiseProc/ProjectProperties.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2011,2013-2015 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "ProjectProperties.h"
  21 #include "CommonAppUtils.h"
  22 #include "Git.h"
  23 #include "UnicodeUtils.h"
  24
  25
  26 struct num_compare
  27 {
  28         bool operator() (const CString& lhs, const CString& rhs) const
  29         {
  30                 return StrCmpLogicalW(lhs, rhs) < 0;
  31         }
  32 };
  33
  34 ProjectProperties::ProjectProperties(void)
  35         : regExNeedUpdate (true)
  36         , nBugIdPos(-1)
  37         , bWarnNoSignedOffBy(FALSE)
  38 {
  39         bNumber = TRUE;
  40         bWarnIfNoIssue = FALSE;
  41         nLogWidthMarker = 0;
  42         nMinLogSize = 0;
  43         bFileListInEnglish = TRUE;
  44         bAppend = TRUE;
  45         lProjectLanguage = 0;
  46 }
  47
  48 int ProjectProperties::ReadProps()
  49 {
  50         CAutoConfig gitconfig(true);
  51         CString adminDirPath;
  52         if (GitAdminDir::GetAdminDirPath(g_Git.m_CurrentDir, adminDirPath))
  53                 git_config_add_file_ondisk(gitconfig, CGit::GetGitPathStringA(adminDirPath + L"config"), GIT_CONFIG_LEVEL_APP, FALSE); // this needs to have the highest priority in order to override .tgitconfig settings
  54
  55         if (!GitAdminDir::IsBareRepo(g_Git.m_CurrentDir))
  56                 git_config_add_file_ondisk(gitconfig, CGit::GetGitPathStringA(g_Git.CombinePath(L".tgitconfig")), GIT_CONFIG_LEVEL_LOCAL, FALSE); // this needs to have the second highest priority
  57         else
  58         {
  59                 CString tmpFile = GetTempFile();
  60                 CTGitPath path(_T(".tgitconfig"));
  61                 if (g_Git.GetOneFile(_T("HEAD"), path, tmpFile) == 0)
  62                         git_config_add_file_ondisk(gitconfig, CGit::GetGitPathStringA(tmpFile), GIT_CONFIG_LEVEL_LOCAL, FALSE); // this needs to have the second highest priority
  63         }
  64
  65         git_config_add_file_ondisk(gitconfig, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
  66         git_config_add_file_ondisk(gitconfig,CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, FALSE);
  67         git_config_add_file_ondisk(gitconfig, CGit::GetGitPathStringA(g_Git.ms_LastMsysGitDir + _T("\\..\\etc\\gitconfig")), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
  68         giterr_clear();
  69
  70         CString sPropVal;
  71
  72         gitconfig.GetString(BUGTRAQPROPNAME_LABEL, sLabel);
  73         gitconfig.GetString(BUGTRAQPROPNAME_MESSAGE, sMessage);
  74         nBugIdPos = sMessage.Find(L"%BUGID%");
  75         gitconfig.GetString(BUGTRAQPROPNAME_URL, sUrl);
  76
  77         gitconfig.GetBOOL(BUGTRAQPROPNAME_WARNIFNOISSUE, bWarnIfNoIssue);
  78         gitconfig.GetBOOL(BUGTRAQPROPNAME_NUMBER, bNumber);
  79         gitconfig.GetBOOL(BUGTRAQPROPNAME_APPEND, bAppend);
  80
  81         gitconfig.GetString(BUGTRAQPROPNAME_PROVIDERUUID, sProviderUuid);
  82         gitconfig.GetString(BUGTRAQPROPNAME_PROVIDERUUID64, sProviderUuid64);
  83         gitconfig.GetString(BUGTRAQPROPNAME_PROVIDERPARAMS, sProviderParams);
  84
  85         gitconfig.GetBOOL(PROJECTPROPNAME_WARNNOSIGNEDOFFBY, bWarnNoSignedOffBy);
  86         gitconfig.GetString(PROJECTPROPNAME_ICON, sIcon);
  87
  88         gitconfig.GetString(BUGTRAQPROPNAME_LOGREGEX, sPropVal);
  89
  90         sCheckRe = sPropVal;
  91         if (sCheckRe.Find('\n')>=0)
  92         {
  93                 sBugIDRe = sCheckRe.Mid(sCheckRe.Find('\n')).Trim();
  94                 sCheckRe = sCheckRe.Left(sCheckRe.Find('\n')).Trim();
  95         }
  96         if (!sCheckRe.IsEmpty())
  97         {
  98                 sCheckRe = sCheckRe.Trim();
  99         }
 100
 101         if (gitconfig.GetString(PROJECTPROPNAME_LOGWIDTHLINE, sPropVal) == 0)
 102         {
 103                 CString val;
 104                 val = sPropVal;
 105                 if (!val.IsEmpty())
 106                         nLogWidthMarker = _ttoi(val) + 2; // HACK, + 2 needed
 107         }
 108
 109         if (gitconfig.GetString(PROJECTPROPNAME_PROJECTLANGUAGE, sPropVal) == 0)
 110         {
 111                 CString val;
 112                 val = sPropVal;
 113                 if (val == _T("-1"))
 114                         lProjectLanguage = -1;
 115                 if (!val.IsEmpty())
 116                 {
 117                         LPTSTR strEnd;
 118                         lProjectLanguage = _tcstol(val, &strEnd, 0);
 119                 }
 120         }
 121
 122         if (gitconfig.GetString(PROJECTPROPNAME_LOGMINSIZE, sPropVal) == 0)
 123         {
 124                 CString val;
 125                 val = sPropVal;
 126                 if (!val.IsEmpty())
 127                         nMinLogSize = _ttoi(val);
 128         }
 129
 130         return 0;
 131 }
 132
 133 CString ProjectProperties::GetBugIDFromLog(CString& msg)
 134 {
 135         CString sBugID;
 136
 137         if (!sMessage.IsEmpty())
 138         {
 139                 CString sBugLine;
 140                 CString sFirstPart;
 141                 CString sLastPart;
 142                 BOOL bTop = FALSE;
 143                 if (nBugIdPos < 0)
 144                         return sBugID;
 145                 sFirstPart = sMessage.Left(nBugIdPos);
 146                 sLastPart = sMessage.Mid(nBugIdPos + 7);
 147                 msg.TrimRight('\n');
 148                 if (msg.ReverseFind('\n')>=0)
 149                 {
 150                         if (bAppend)
 151                                 sBugLine = msg.Mid(msg.ReverseFind('\n')+1);
 152                         else
 153                         {
 154                                 sBugLine = msg.Left(msg.Find('\n'));
 155                                 bTop = TRUE;
 156                         }
 157                 }
 158                 else
 159                 {
 160                         if (bNumber)
 161                         {
 162                                 // find out if the message consists only of numbers
 163                                 bool bOnlyNumbers = true;
 164                                 for (int i=0; i<msg.GetLength(); ++i)
 165                                 {
 166                                         if (!_istdigit(msg[i]))
 167                                         {
 168                                                 bOnlyNumbers = false;
 169                                                 break;
 170                                         }
 171                                 }
 172                                 if (bOnlyNumbers)
 173                                         sBugLine = msg;
 174                         }
 175                         else
 176                                 sBugLine = msg;
 177                 }
 178                 if (sBugLine.IsEmpty() && (msg.ReverseFind('\n') < 0))
 179                 {
 180                         sBugLine = msg.Mid(msg.ReverseFind('\n')+1);
 181                 }
 182                 if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 183                         sBugLine.Empty();
 184                 if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 185                         sBugLine.Empty();
 186                 if (sBugLine.IsEmpty())
 187                 {
 188                         if (msg.Find('\n')>=0)
 189                                 sBugLine = msg.Left(msg.Find('\n'));
 190                         if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 191                                 sBugLine.Empty();
 192                         if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 193                                 sBugLine.Empty();
 194                         bTop = TRUE;
 195                 }
 196                 if (sBugLine.IsEmpty())
 197                         return sBugID;
 198                 sBugID = sBugLine.Mid(sFirstPart.GetLength(), sBugLine.GetLength() - sFirstPart.GetLength() - sLastPart.GetLength());
 199                 if (bTop)
 200                 {
 201                         msg = msg.Mid(sBugLine.GetLength());
 202                         msg.TrimLeft('\n');
 203                 }
 204                 else
 205                 {
 206                         msg = msg.Left(msg.GetLength()-sBugLine.GetLength());
 207                         msg.TrimRight('\n');
 208                 }
 209         }
 210         return sBugID;
 211 }
 212
 213 void ProjectProperties::AutoUpdateRegex()
 214 {
 215         if (regExNeedUpdate)
 216         {
 217                 try
 218                 {
 219                         regCheck = std::tr1::wregex(sCheckRe);
 220                         regBugID = std::tr1::wregex(sBugIDRe);
 221                 }
 222                 catch (std::exception)
 223                 {
 224                 }
 225
 226                 regExNeedUpdate = false;
 227         }
 228 }
 229
 230 std::vector<CHARRANGE> ProjectProperties::FindBugIDPositions(const CString& msg)
 231 {
 232         size_t offset1 = 0;
 233         size_t offset2 = 0;
 234         std::vector<CHARRANGE> result;
 235
 236         // first use the checkre string to find bug ID's in the message
 237         if (!sCheckRe.IsEmpty())
 238         {
 239                 if (!sBugIDRe.IsEmpty())
 240                 {
 241
 242                         // match with two regex strings (without grouping!)
 243                         try
 244                         {
 245                                 AutoUpdateRegex();
 246                                 const std::tr1::wsregex_iterator end;
 247                                 std::wstring s = msg;
 248                                 for (std::tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 249                                 {
 250                                         // (*it)[0] is the matched string
 251                                         std::wstring matchedString = (*it)[0];
 252                                         ptrdiff_t matchpos = it->position(0);
 253                                         for (std::tr1::wsregex_iterator it2(matchedString.begin(), matchedString.end(), regBugID); it2 != end; ++it2)
 254                                         {
 255                                                 ATLTRACE(_T("matched id : %s\n"), (*it2)[0].str().c_str());
 256                                                 ptrdiff_t matchposID = it2->position(0);
 257                                                 CHARRANGE range = {(LONG)(matchpos+matchposID), (LONG)(matchpos+matchposID+(*it2)[0].str().size())};
 258                                                 result.push_back(range);
 259                                         }
 260                                 }
 261                         }
 262                         catch (std::exception) {}
 263                 }
 264                 else
 265                 {
 266                         try
 267                         {
 268                                 AutoUpdateRegex();
 269                                 const std::tr1::wsregex_iterator end;
 270                                 std::wstring s = msg;
 271                                 for (std::tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 272                                 {
 273                                         const std::tr1::wsmatch match = *it;
 274                                         // we define group 1 as the whole issue text and
 275                                         // group 2 as the bug ID
 276                                         if (match.size() >= 2)
 277                                         {
 278                                                 ATLTRACE(_T("matched id : %s\n"), std::wstring(match[1]).c_str());
 279                                                 CHARRANGE range = {(LONG)(match[1].first-s.begin()), (LONG)(match[1].second-s.begin())};
 280                                                 result.push_back(range);
 281                                         }
 282                                 }
 283                         }
 284                         catch (std::exception) {}
 285                 }
 286         }
 287         else if (result.empty() && (!sMessage.IsEmpty()))
 288         {
 289                 CString sBugLine;
 290                 CString sFirstPart;
 291                 CString sLastPart;
 292                 BOOL bTop = FALSE;
 293                 if (nBugIdPos < 0)
 294                         return result;
 295
 296                 sFirstPart = sMessage.Left(nBugIdPos);
 297                 sLastPart = sMessage.Mid(nBugIdPos + 7);
 298                 CString sMsg = msg;
 299                 sMsg.TrimRight('\n');
 300                 if (sMsg.ReverseFind('\n')>=0)
 301                 {
 302                         if (bAppend)
 303                                 sBugLine = sMsg.Mid(sMsg.ReverseFind('\n')+1);
 304                         else
 305                         {
 306                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 307                                 bTop = TRUE;
 308                         }
 309                 }
 310                 else
 311                         sBugLine = sMsg;
 312                 if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 313                         sBugLine.Empty();
 314                 if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 315                         sBugLine.Empty();
 316                 if (sBugLine.IsEmpty())
 317                 {
 318                         if (sMsg.Find('\n')>=0)
 319                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 320                         if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 321                                 sBugLine.Empty();
 322                         if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 323                                 sBugLine.Empty();
 324                         bTop = TRUE;
 325                 }
 326                 if (sBugLine.IsEmpty())
 327                         return result;
 328
 329                 CString sBugIDPart = sBugLine.Mid(sFirstPart.GetLength(), sBugLine.GetLength() - sFirstPart.GetLength() - sLastPart.GetLength());
 330                 if (sBugIDPart.IsEmpty())
 331                         return result;
 332
 333                 //the bug id part can contain several bug id's, separated by commas
 334                 if (!bTop)
 335                         offset1 = sMsg.GetLength() - sBugLine.GetLength() + sFirstPart.GetLength();
 336                 else
 337                         offset1 = sFirstPart.GetLength();
 338                 sBugIDPart.Trim(_T(","));
 339                 while (sBugIDPart.Find(',')>=0)
 340                 {
 341                         offset2 = offset1 + sBugIDPart.Find(',');
 342                         CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 343                         result.push_back(range);
 344                         sBugIDPart = sBugIDPart.Mid(sBugIDPart.Find(',')+1);
 345                         offset1 = offset2 + 1;
 346                 }
 347                 offset2 = offset1 + sBugIDPart.GetLength();
 348                 CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 349                 result.push_back(range);
 350         }
 351
 352         return result;
 353 }
 354
 355 BOOL ProjectProperties::FindBugID(const CString& msg, CWnd * pWnd)
 356 {
 357         std::vector<CHARRANGE> positions = FindBugIDPositions(msg);
 358         CCommonAppUtils::SetCharFormat(pWnd, CFM_LINK, CFE_LINK, positions);
 359
 360         return positions.empty() ? FALSE : TRUE;
 361 }
 362
 363 std::set<CString> ProjectProperties::FindBugIDs (const CString& msg)
 364 {
 365         std::vector<CHARRANGE> positions = FindBugIDPositions(msg);
 366         std::set<CString> bugIDs;
 367
 368         for (std::vector<CHARRANGE>::iterator iter = positions.begin(), end = positions.end(); iter != end; ++iter)
 369         {
 370                 bugIDs.insert(msg.Mid(iter->cpMin, iter->cpMax - iter->cpMin));
 371         }
 372
 373         return bugIDs;
 374 }
 375
 376 CString ProjectProperties::FindBugID(const CString& msg)
 377 {
 378         CString sRet;
 379         if (!sCheckRe.IsEmpty() || (nBugIdPos >= 0))
 380         {
 381                 std::vector<CHARRANGE> positions = FindBugIDPositions(msg);
 382                 std::set<CString, num_compare> bugIDs;
 383                 for (std::vector<CHARRANGE>::iterator iter = positions.begin(), end = positions.end(); iter != end; ++iter)
 384                 {
 385                         bugIDs.insert(msg.Mid(iter->cpMin, iter->cpMax - iter->cpMin));
 386                 }
 387
 388                 for (std::set<CString, num_compare>::iterator it = bugIDs.begin(); it != bugIDs.end(); ++it)
 389                 {
 390                         sRet += *it;
 391                         sRet += _T(" ");
 392                 }
 393                 sRet.Trim();
 394         }
 395
 396         return sRet;
 397 }
 398
 399 bool ProjectProperties::MightContainABugID()
 400 {
 401         return !sCheckRe.IsEmpty() || (nBugIdPos >= 0);
 402 }
 403
 404 CString ProjectProperties::GetBugIDUrl(const CString& sBugID)
 405 {
 406         CString ret;
 407         if (sUrl.IsEmpty())
 408                 return ret;
 409         if (!sMessage.IsEmpty() || !sCheckRe.IsEmpty())
 410         {
 411                 ret = sUrl;
 412                 ret.Replace(_T("%BUGID%"), sBugID);
 413         }
 414         return ret;
 415 }
 416
 417 BOOL ProjectProperties::CheckBugID(const CString& sID)
 418 {
 419         if (bNumber)
 420         {
 421                 // check if the revision actually _is_ a number
 422                 // or a list of numbers separated by colons
 423                 TCHAR c = 0;
 424                 int len = sID.GetLength();
 425                 for (int i=0; i<len; ++i)
 426                 {
 427                         c = sID.GetAt(i);
 428                         if ((c < '0')&&(c != ',')&&(c != ' '))
 429                         {
 430                                 return FALSE;
 431                         }
 432                         if (c > '9')
 433                                 return FALSE;
 434                 }
 435         }
 436         return TRUE;
 437 }
 438
 439 BOOL ProjectProperties::HasBugID(const CString& sMessage)
 440 {
 441         if (!sCheckRe.IsEmpty())
 442         {
 443                 try
 444                 {
 445                         AutoUpdateRegex();
 446                         return std::tr1::regex_search((LPCTSTR)sMessage, regCheck);
 447                 }
 448                 catch (std::exception) {}
 449         }
 450         return FALSE;
 451 }